/*
 * 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.java;

import com.google.common.flogger.FluentLogger;
import static com.google.common.flogger.LazyArgs.*;
import java.io.File;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaFileObject;
import javax.tools.ToolProvider;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.ConfigurationException;
import org.jdrupes.builder.api.FileResource;
import org.jdrupes.builder.api.FileTree;
import org.jdrupes.builder.api.Intent;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.Project;
import org.jdrupes.builder.api.Resource;
import org.jdrupes.builder.api.ResourceRequest;
import static org.jdrupes.builder.api.ResourceType.*;
import org.jdrupes.builder.api.Resources;
import org.jdrupes.builder.api.UnavailableException;
import org.jdrupes.builder.core.StreamCollector;
import static org.jdrupes.builder.java.JavaTypes.*;

/// The [Javadoc] generator provides the resource [JavadocDirectory],
/// a directory that contains generated javadoc files.
///
/// No attempt is made to define dedicated types for Javadoc tool options.
/// Instead, options are passed as strings, as suggested by the
/// [ToolProvider] API. Notable exceptions exist for options that are
/// directly related to resource types originating from the builder
/// context (such as files, directory trees, and paths).
/// 
/// By default, the generator builds the Javadoc for the project passed
/// to the constructor. In some cases – such as generating a shared
/// Javadoc for multiple projects – this behavior is not desired. In
/// these cases, the project(s) for which Javadoc is generated can be
/// configured via [#projects(Stream)].
///
/// The classpath and module-path for the Javadoc tool invocation are
/// assembled by requesting the [CodeContribution]s with intents
/// [Consume][Intent#Consume], [Reveal][Intent#Reveal] and
/// [Expose][Intent#Expose] from the configured project(s).
/// 
/// The [JavaSourceFile]s to be processed are obtained by requesting
/// resources of [JavaTypes#JavaSourceTreeType] with intents
/// [Supply][Intent#Supply] and [Expose][Intent#Expose] from the configured
/// project(s). This default behavior can be overridden by setting the
/// sources explicitly using one or more invocations of the `addSources`
/// methods.
///
/// ## JPMS support
///
/// When the sources contain a `module-info.java`, or when the module mode
/// is set to `ModuleMode.MODULE`, generation uses the module-path
/// (`--module-path`) for code contributions that contain a module descriptor.
/// Non-modular code contributions remain on the classpath (`-cp`). In
/// `ModuleMode.AUTO` mode (the default), module compilation is activated
/// automatically when a `module-info.java` is found among the sources.
///
public class Javadoc extends JavaTool {

    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
    private final StreamCollector<FileTree<JavaSourceFile>> sources
        = StreamCollector.cached();
    private StreamCollector<Project> projects = StreamCollector.cached();
    private Path destination = Path.of("doc");
    private final StreamCollector<CodeContribution> tagletpath
        = StreamCollector.cached();
    private final List<String> taglets = new ArrayList<>();

    /// Instantiates a new java compiler.
    ///
    /// @param project the project
    ///
    public Javadoc(Project project) {
        super(project);
        projects.add(project);
    }

    /// Sets the projects to generate javadoc for.
    ///
    /// @param projects the projects
    /// @return the javadoc
    ///
    public Javadoc projects(Stream<Project> projects) {
        this.projects = StreamCollector.cached();
        this.projects.add(projects);
        return this;
    }

    /// Returns the destination directory. Defaults to "`doc`".
    ///
    /// @return the destination
    ///
    public Path destination() {
        return destination;
    }

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

    /// Adds the source tree.
    ///
    /// @param sources the sources
    /// @return the javadoc generator
    ///
    @SafeVarargs
    public final Javadoc addSources(FileTree<JavaSourceFile>... sources) {
        this.sources.add(Arrays.stream(sources));
        return this;
    }

    /// Adds the files from the given directory matching the given pattern.
    /// Short for
    /// `addSources(project().newFileTree(directory, pattern, JavaSourceFile.class))`.
    ///
    /// @param directory the directory
    /// @param pattern the pattern
    /// @return the javadoc generator
    /// 
    public final Javadoc addSources(Path directory, String pattern) {
        addSources(FileTree.of(
            project(), directory, JavaSourceFile.class, pattern));
        return this;
    }

    /// Adds the sources.
    ///
    /// @param sources the sources
    /// @return the java compiler
    ///
    public final Javadoc addSources(Stream<FileTree<JavaSourceFile>> sources) {
        this.sources.add(sources);
        return this;
    }

    /// Source paths.
    ///
    /// @return the collection
    ///
    private Collection<Path> sourcePaths(
            Stream<FileTree<JavaSourceFile>> sources) {
        return sources.map(Resources::stream)
            .flatMap(Function.identity()).map(FileResource::path)
            .collect(Collectors.toSet());
    }

    @Override
    protected boolean hasModuleInfo() {
        return sources.stream().flatMap(Resources::stream)
            .anyMatch(f -> f.path().endsWith("module-info.java"));
    }

    /// Adds the given classpath elements to the tagletpath. The classpath
    /// elements can be classpath elements or modules.
    ///
    /// @param classpathElements the classpath elements
    /// @return the javadoc
    ///
    public Javadoc
            tagletpath(Stream<? extends CodeContribution> classpathElements) {
        tagletpath.add(classpathElements);
        return this;
    }

    /// Adds the given taglets.
    ///
    /// @param taglets the taglets
    /// @return the javadoc
    ///
    public Javadoc taglets(Stream<String> taglets) {
        this.taglets.addAll(taglets.toList());
        return this;
    }

    @Override
    @SuppressWarnings({ "PMD.AvoidCatchingGenericException",
        "PMD.ExceptionAsFlowControl" })
    protected <T extends Resource> Collection<T>
            doProvide(ResourceRequest<T> requested) {
        if (!requested.accepts(JavadocDirectoryType)
            && !requested.accepts(CleanlinessType)) {
            return Collections.emptyList();
        }

        // Get destination and check if we only have to cleanup.
        var destDir = project().buildDirectory().resolve(destination);
        var generated = ClassTree.of(project(), destDir);
        if (requested.accepts(CleanlinessType)) {
            generated.cleanup();
            destDir.toFile().delete();
            return Collections.emptyList();
        }

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

        // Generate
        var javadoc = ToolProvider.getSystemDocumentationTool();
        var diagnostics = new DiagnosticCollector<JavaFileObject>();
        try (var fileManager
            = javadoc.getStandardFileManager(diagnostics, null, null)) {
            List<String> allOptions = evaluateOptions(destDir);
            logger.atFinest().log("Javadoc options: %s", allOptions);
            var sourcePaths = sourcePaths(sources.stream());
            if (sourcePaths.isEmpty()) {
                sourcePaths = sourcePaths(projects.stream().flatMap(p -> p
                    .resources(of(JavaSourceTreeType).using(Supply, Expose))));
            }
            var finalSourcePaths = sourcePaths;
            logger.atFinest().log("Javadoc sources: %s", finalSourcePaths);
            var sourceFiles
                = fileManager.getJavaFileObjectsFromPaths(sourcePaths);
            if (!javadoc.getTask(null, fileManager, diagnostics, null,
                allOptions, sourceFiles).call()) {
                throw new UnavailableException().from(this);
            }
        } catch (Exception e) {
            logger.atSevere().withCause(e).log(
                "Project %s: Cannot generate Javadoc: %s",
                project().name(), e.getMessage());
            throw new BuildException().from(this).cause(e);
        } finally {
            logDiagnostics(diagnostics);
        }
        @SuppressWarnings("unchecked")
        var result = (Collection<T>) List.of(
            JavadocDirectory.of(project(), destDir));
        return result;
    }

    private List<String> evaluateOptions(Path destDir) {
        if (options().contains("-d")) {
            new ConfigurationException().from(this).message("Specifying the"
                + " destination directory with options() is not allowed.");
        }
        List<String> allOptions = new ArrayList<>(options());
        allOptions.addAll(List.of("-d", destDir.toString()));

        // Handle classpath and module-path
        var ccResources = Resources.of(CodeContributionsType).addAll(
            projects.stream().flatMap(p -> p.resources(
                of(CodeContributionType).using(Consume, Reveal, Expose))));
        var useModulePath = effectiveModuleMode() == ModuleMode.MODULE;
        var cpe = ccResources.stream()
            .filter(cc -> !useModulePath || !cc.isModular()).toList();
        var mpe = ccResources.stream()
            .filter(cc -> useModulePath && cc.isModular()).toList();
        logger.atFinest().log(
            "Generating in %s with classpath %s and module-path %s", project(),
            lazy(() -> cpe.stream().map(Resource::toString).toList()),
            lazy(() -> mpe.stream().map(Resource::toString).toList()));
        if (!cpe.isEmpty()) {
            var classpath = cpe.stream().map(e -> e.toPath().toString())
                .collect(Collectors.joining(File.pathSeparator));
            allOptions.addAll(List.of("-cp", classpath));
        }
        if (!mpe.isEmpty()) {
            var modulePath = mpe.stream().map(e -> e.toPath().toString())
                .collect(Collectors.joining(File.pathSeparator));
            allOptions.addAll(List.of("--module-path", modulePath));
        }

        // Handle taglets
        var tagletPath = tagletPath();
        if (!tagletPath.isEmpty()) {
            allOptions.addAll(List.of("-tagletpath", tagletPath));
        }
        for (var taglet : taglets) {
            allOptions.addAll(List.of("-taglet", taglet));
        }
        return allOptions;
    }

    private String tagletPath() {
        return tagletpath.stream().<Path> mapMulti((e, consumer) -> {
            if (e instanceof ClassTree classTree) {
                consumer.accept(classTree.root());
            } else if (e instanceof JarFile jarFile) {
                consumer.accept(jarFile.path());
            }
        }).map(Path::toString).collect(Collectors.joining(File.pathSeparator));
    }
}