/*
 * JDrupes Builder
 * Copyright (C) 2025 Michael N. Lipp
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package org.jdrupes.builder.mvnrepo;

import com.google.common.flogger.FluentLogger;
import static com.google.common.flogger.LazyArgs.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.DependencyManagement;
import org.apache.maven.model.Model;
import org.apache.maven.model.io.DefaultModelWriter;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.Generator;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.Project;
import static org.jdrupes.builder.api.Project.Properties.*;
import org.jdrupes.builder.api.Resource;
import org.jdrupes.builder.api.ResourceRequest;
import org.jdrupes.builder.api.Resources;
import org.jdrupes.builder.core.AbstractGenerator;
import static org.jdrupes.builder.mvnrepo.MvnProperties.*;
import static org.jdrupes.builder.mvnrepo.MvnRepoTypes.*;

/// A [Generator] (mainly) for POM files. In response to requests for
/// [PomFile] this generator produces a Maven [Model] containing basic
/// project information. The following properties are used:
/// 
///   * The groupId is set to the value of the property
///     [MvnProperties#GroupId] if it is defined.
/// 
///   * The artifactId is set to the property [MvnProperties#ArtifactId],
///     or to the name of the project if [MvnProperties#ArtifactId] is
///     not defined.
/// 
///   * The version is set to the value of the property
///     [Project.Properties#Version].
/// 
/// Dependencies in the model are evaluated by querying the project's
/// providers.
/// 
/// Compile dependencies are evaluated as follows:
/// 
///   * Resources of type [MvnRepoDependency] are obtained from providers
///     associated via `Supply` and `Expose` that are not projects. These
///     resources are Maven repository dependencies declared by the
///     project itself.
/// 
///   * Projects associated via `Supply` and `Expose` dependencies
///     are then queried for resources of type [MvnRepoDependency]
///     using their `Supply` dependencies. This yields the Maven
///     repository coordinates of projects required for compilation.
/// 
/// Runtime dependencies are evaluated as follows:
/// 
///   * Resources of type [MvnRepoDependency] are obtained from providers
///     associated via `Reveal` that are not projects. These
///     resources represent Maven repository dependencies declared by
///     the project itself.
/// 
///   * Projects associated via `Reveal` dependencies are then queried for
///     resources of type [MvnRepoDependency] using their `Supply`
///     dependencies. This yields the Maven repository coordinates of 
///     projects required at runtime.
///
/// The resulting model is passed to [#adaptPom] for project specific
/// customization before it is written to the POM file.
///
/// In addition to handling [PomFile] requests, this generator also 
/// responds to requests for [MvnRepoDependencies][MvnRepoDependency].
/// In this case, it returns Maven coordinates derived from the
/// properties [MvnProperties#GroupId], [MvnProperties#ArtifactId]
/// and [Project.Properties#Version] (see above). This reflects the
/// assumption that a project with a POM file is intended to be released
/// as a Maven artifact. Other projects in a multi-project build will
/// therefore ultimately depend on the Maven artifact to be released.
///
@SuppressWarnings("PMD.TooManyStaticImports")
public class PomFileGenerator extends AbstractGenerator {

    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
    /// The Constant GENERATED_BY.
    public static final String GENERATED_BY = "Generated by JDrupes Builder";
    private Supplier<Path> destination
        = () -> project().buildDirectory().resolve("publications/maven");
    private Consumer<Model> pomAdapter = _ -> {
    };

    /// Instantiates a new library generator.
    ///
    /// @param project the project
    ///
    public PomFileGenerator(Project project) {
        super(project);
    }

    /// Returns the destination directory. Defaults to sub directory
    /// `publications/maven` in the project's build directory
    /// (see [Project#buildDirectory]).
    ///
    /// @return the destination
    ///
    public Path destination() {
        return destination.get();
    }

    /// Sets the destination directory. The [Path] is resolved against
    /// the project's build directory (see [Project#buildDirectory]).
    ///
    /// @param destination the new destination
    /// @return the jar generator
    ///
    public PomFileGenerator destination(Path destination) {
        this.destination
            = () -> project().buildDirectory().resolve(destination);
        return this;
    }

    /// Sets the destination directory.
    ///
    /// @param destination the new destination
    /// @return the jar generator
    ///
    public PomFileGenerator destination(Supplier<Path> destination) {
        this.destination = destination;
        return this;
    }

    @Override
    protected <T extends Resource> Collection<T>
            doProvide(ResourceRequest<T> requested) {
        var pomPath = destination().resolve(Optional.ofNullable(
            project().get(ArtifactId)).orElse(project().name()) + "-pom.xml");
        if (cleanup(requested, pomPath)) {
            return Collections.emptyList();
        }
        if (requested.accepts(MvnRepoDependencyType)) {
            return generateRepoDependency(requested);
        }
        if (!requested.accepts(PomFileType)) {
            return Collections.emptyList();
        }

        // Always provide special type
        if (!requested.type().equals(PomFileType)) {
            @SuppressWarnings("unchecked")
            var result = (Collection<T>) resources(of(PomFileType)).toList();
            return result;
        }

        pomPath.getParent().toFile().mkdirs();
        Model model = generatePom();

        // create, compare and maybe write model
        pomPath.getParent().toFile().mkdirs();
        try {
            // Create new in memory
            ByteArrayOutputStream newPom = new ByteArrayOutputStream();
            new DefaultModelWriter().write(newPom, null, model);
            newPom.close();

            // Read existing
            var existingContent = pomPath.toFile().exists()
                ? Files.readAllBytes(pomPath)
                : new byte[0];

            // Compare and write
            if (Arrays.equals(newPom.toByteArray(), existingContent)) {
                logger.atFine().log("Existing %s is up to date.",
                    lazy(() -> project().rootProject().directory()
                        .relativize(pomPath)));
            } else {
                logger.atFine().log("Updating %s",
                    lazy(() -> project().rootProject()
                        .directory().relativize(pomPath)));
                Files.write(pomPath, newPom.toByteArray());
            }
        } catch (IOException e) {
            throw new BuildException().from(this).cause(e);
        }

        @SuppressWarnings("unchecked")
        var result = (Collection<T>) List.of(PomFile.of(pomPath));
        return result;
    }

    private Model generatePom() {
        Model model = new Model();
        model.setModelVersion("4.0.0");
        model.setDependencyManagement(new DependencyManagement());
        var groupId = project().<String> get(GroupId);
        if (groupId != null) {
            model.setGroupId(groupId);
        }
        model.setArtifactId(Optional.ofNullable(project()
            .<String> get(ArtifactId)).orElse(project().name()));
        model.setVersion(project().get(Version));
        model.setName(project().name());

        // Get declared repository dependencies. These are the
        // explicitly declared dependencies and the repository
        // dependencies supplied by the projects on the compile
        // or runtime classpath.
        var compilationDeps = Resources.of(MvnRepoDependenciesType)
            .addAll(project().providers(Supply, Expose).without(this)
                .without(Project.class).resources(of(MvnRepoDependencyType)))
            .addAll(project().providers()
                .filter(p -> p instanceof Project).select(Supply, Expose)
                .flatMap(p -> p.resources(of(MvnRepoDependencyType)
                    .using(Supply))));
        addDependencies(model, compilationDeps, "compile");
        var runtimeDeps = Resources.of(MvnRepoDependenciesType)
            .addAll(project().providers(Reveal).without(this)
                .without(Project.class).resources(of(MvnRepoDependencyType)))
            .addAll(project().providers()
                .filter(p -> p instanceof Project).select(Reveal)
                .flatMap(p -> p.resources(of(MvnRepoDependencyType)
                    .using(Supply))));
        addDependencies(model, runtimeDeps, "runtime");

        // Adapt
        pomAdapter.accept(model);
        return model;
    }

    private void addDependencies(Model model, Resources<MvnRepoDependency> deps,
            String scope) {
        deps.stream().forEach(d -> {
            var dep = new Dependency();
            dep.setGroupId(d.groupId());
            dep.setArtifactId(d.artifactId());
            dep.setVersion(d.version());
            if (d instanceof MvnRepoBom) {
                dep.setScope("import");
                dep.setType("pom");
                model.getDependencyManagement().addDependency(dep);
            } else {
                dep.setScope(scope);
                model.addDependency(dep);
            }
        });
    }

    /// Allow derived classes to post process the generated POM.
    ///
    /// @param adaptor the adaptor
    /// @return the pom file generator
    ///
    public PomFileGenerator adaptPom(Consumer<Model> adaptor) {
        this.pomAdapter = adaptor;
        return this;
    }

    @SuppressWarnings("unchecked")
    private <T extends Resource> Collection<T>
            generateRepoDependency(ResourceRequest<T> requested) {
        if (requested.accepts(MvnRepoDependenciesType)) {
            return Collections.emptyList();
        }
        return List.of((T) MvnRepoDependency.of(String.format("%s:%s:%s",
            project().<String> get(GroupId), Optional.ofNullable(project()
                .<String> get(ArtifactId)).orElse(project().name()),
            project().get(Version))));
    }

}