/*
 * 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 java.nio.file.Path;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.jar.Attributes;
import java.util.stream.Stream;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.ConfigurationException;
import org.jdrupes.builder.api.Generator;
import org.jdrupes.builder.api.IOResource;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.Project;
import org.jdrupes.builder.api.Resource;
import org.jdrupes.builder.api.ResourceProvider;
import org.jdrupes.builder.api.ResourceRequest;
import org.jdrupes.builder.api.ResourceRetriever;
import org.jdrupes.builder.api.ResourceType;
import static org.jdrupes.builder.api.ResourceType.*;
import org.jdrupes.builder.api.Resources;
import org.jdrupes.builder.core.StreamCollector;
import static org.jdrupes.builder.java.JavaTypes.*;

/// A [Generator] for Java libraries packaged as jars. A library jar
/// is expected to contain class files and supporting resources together
/// with additional information in `META-INF/`.
///
/// The generator provides two types of resources.
/// 
/// 1. A [LibraryJarFile]. This type of resource is also returned if a more
///    general [ResourceType] such as [ClasspathElement] is requested.
///
/// 2. An [AppJarFile]. When requesting this special jar type, the
///    generator checks if a main class is specified.
///
/// In addition to explicitly adding resources, this generator supports
/// resource retrieval from added providers. The resources of type [ClassTree]
/// and [JavaResourceTree] that the providers supply will be used in
/// addition to the explicitly added resources. To make adding providers
/// easier, the [LibraryBuilder] itself is automatically filtered from the
/// added providers. This makes it possible to add a project as provider
/// even if this includes the [LibraryBuilder].
///
/// The standard pattern for creating a library is:
/// ```java
/// generator(LibraryGenerator::new).addFrom(providers().select(Supply));
/// ```
///
public class LibraryBuilder extends JarBuilder
        implements ResourceRetriever {

    @SuppressWarnings({ "unused" })
    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
    private final StreamCollector<ResourceProvider> providers
        = StreamCollector.cached();
    private String mainClass;

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

    @Override
    public LibraryBuilder name(String name) {
        rename(name);
        return this;
    }

    /// Returns the main class.
    ///
    /// @return the main class
    ///
    public String mainClass() {
        return mainClass;
    }

    /// Sets the main class.
    ///
    /// @param mainClass the new main class
    /// @return the jar generator for method chaining
    ///
    public LibraryBuilder mainClass(String mainClass) {
        this.mainClass = Objects.requireNonNull(mainClass);
        return this;
    }

    @Override
    public LibraryBuilder addFrom(ResourceProvider... providers) {
        addFrom(Stream.of(providers));
        return this;
    }

    @Override
    public LibraryBuilder addFrom(Stream<ResourceProvider> providers) {
        this.providers.add(providers.filter(p -> !p.equals(this)));
        return this;
    }

    /// return the cached providers.
    ///
    /// @return the cached stream
    ///
    protected StreamCollector<ResourceProvider> contentProviders() {
        return providers;
    }

    @Override
    protected void collectContents(Map<Path, Resources<IOResource>> contents) {
        super.collectContents(contents);
        // Add main class if defined
        if (mainClass() != null) {
            attributes(Map.entry(Attributes.Name.MAIN_CLASS, mainClass()));
        }
        collectFromProviders(contents);
    }

    /// Collects the contents from the providers. This implementation
    /// requests [ClassTree]s and [JavaResourceTree]s.
    ///
    /// @param contents the contents
    ///
    protected void collectFromProviders(
            Map<Path, Resources<IOResource>> contents) {
        contentProviders().stream()
            .map(p -> p.resources(of(ClassTreeType).using(Supply)))
            // Terminate to trigger all future stream evaluations before
            // starting to process the results. Then collect in parallel.
            .toList().stream().flatMap(s -> s).toList().parallelStream()
            .forEach(t -> collect(contents, t));
        contentProviders().stream()
            .map(p -> p.resources(of(JavaResourceTreeType).using(Supply)))
            // Terminate to trigger all future stream evaluations before
            // starting to process the results. Then collect in parallel.
            .toList().stream().flatMap(s -> s).toList().parallelStream()
            .forEach(t -> collect(contents, t));
    }

    @Override
    @SuppressWarnings({ "PMD.CollapsibleIfStatements", "unchecked",
        "PMD.CyclomaticComplexity" })
    protected <T extends Resource> Collection<T>
            doProvide(ResourceRequest<T> request) {
        if (!request.accepts(LibraryJarFileType)
            && !request.accepts(CleanlinessType)) {
            return Collections.emptyList();
        }

        // Maybe only delete
        if (request.accepts(CleanlinessType)) {
            destination().resolve(jarName()).toFile().delete();
            return Collections.emptyList();
        }

        // Upgrade to most specific type to avoid duplicate generation
        if (mainClass() != null && !request.type().equals(AppJarFileType)) {
            return (Collection<T>) context()
                .resources(this, project().of(AppJarFileType)).toList();
        }
        if (mainClass() == null && !request.type().equals(LibraryJarFileType)) {
            return (Collection<T>) context()
                .resources(this, project().of(LibraryJarFileType)).toList();
        }

        // Make sure mainClass is set for app jar
        if (request.isFor(AppJarFileType) && mainClass() == null) {
            throw new ConfigurationException().from(this).message(
                "Main class must be set for %s", name());
        }

        // Prepare jar file
        var destDir = destination();
        if (!destDir.toFile().exists()) {
            if (!destDir.toFile().mkdirs()) {
                throw new BuildException().from(this)
                    .message("Cannot create directory " + destDir);
            }
        }
        var jarResource = request.isFor(AppJarFileType)
            ? AppJarFile.of(destDir.resolve(jarName()))
            : LibraryJarFile.of(destDir.resolve(jarName()));

        buildJar(jarResource);
        return List.of((T) jarResource);
    }
}