/*
 * JDrupes Builder
 * Copyright (C) 2025, 2026 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.core;

import io.github.azagniotov.matcher.AntPathMatcher;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.Spliterators.AbstractSpliterator;
import java.util.Stack;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.ConfigurationException;
import org.jdrupes.builder.api.Generator;
import org.jdrupes.builder.api.Intent;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.MergedTestProject;
import org.jdrupes.builder.api.NamedParameter;
import org.jdrupes.builder.api.Project;
import org.jdrupes.builder.api.PropertyKey;
import org.jdrupes.builder.api.ProviderSelection;
import org.jdrupes.builder.api.Resource;
import org.jdrupes.builder.api.ResourceProvider;
import org.jdrupes.builder.api.ResourceRequest;
import org.jdrupes.builder.api.RootProject;

/// A default implementation of a [Project].
/// 
/// Noteworthy features:
/// 
///   * Providers are added to a project successively in its constructor.
///     This implies that the list of providers is incomplete during
///     the execution of the constructor and may only be accesses via the
///     lazily evaluated `Stream` return by [#providers]. The only place
///     where the registered providers are accessed is the private method
///     `dependencies`. Therefore this method checks if access to providers
///     is unlocked. Unlocking happens via [#unlockProviders] after
///     new instances of projects have been created, either in
///     [AbstractProject] for regular projects or in [DefaultBuildContext]
///     for the root project.
///
@SuppressWarnings({ "PMD.CouplingBetweenObjects", "PMD.GodClass",
    "PMD.TooManyMethods" })
public abstract class AbstractProject extends AbstractProvider
        implements Project {

    @SuppressWarnings("PMD.FieldNamingConventions")
    private static final AntPathMatcher pathMatcher
        = new AntPathMatcher.Builder().build();
    private static Path jdbldDirectory = Path.of("marker:jdbldDirectory");
    private final AbstractProject parent;
    private final String projectName;
    private final Path projectDirectory;
    private final Map<ResourceProvider, Intent> providers
        = new ConcurrentHashMap<>();
    private boolean providersUnlocked;
    @SuppressWarnings("PMD.UseConcurrentHashMap")
    private final Map<PropertyKey<?>, Object> properties = new HashMap<>();

    /// Named parameter for specifying the parent project.
    ///
    /// @param parentProject the parent project
    /// @return the named parameter
    ///
    protected static NamedParameter<Class<? extends Project>>
            parent(Class<? extends Project> parentProject) {
        return new NamedParameter<>("parent", parentProject);
    }

    /// Named parameter for specifying the name.
    ///
    /// @param name the name
    /// @return the named parameter
    ///
    protected static NamedParameter<String> name(String name) {
        return new NamedParameter<>("name", name);
    }

    /// Named parameter for specifying the directory.
    ///
    /// @param directory the directory
    /// @return the named parameter
    ///
    protected static NamedParameter<Path> directory(Path directory) {
        return new NamedParameter<>("directory", directory);
    }

    /// Creates an instance of [NamedParameter] with name "directory"
    /// and value `context().jdbldDirectory()`.
    /// 
    /// Simply using `directory(context().jdbldDirectory())` is not possible
    /// because referring to an instance method while explicitly invoking
    /// a constructor is not possible. 
    ///
    /// @return the named parameter
    ///
    protected static NamedParameter<Path> jdbldDirectory() {
        return new NamedParameter<>("directory", jdbldDirectory);
    }

    /// Base class constructor for all projects. The behavior depends 
    /// on whether the project is a root project (implements [RootProject])
    /// or a subproject and on whether the project specifies a parent project.
    ///
    /// [RootProject]s must invoke this constructor with a null parent project
    /// class.
    ///
    /// A sub project that wants to specify a parent project must invoke this
    /// constructor with the parent project's class. If a sub project does not
    /// specify a parent project, the root project is used as parent. In both
    /// cases, the constructor adds a [Intent#Forward] dependency between the
    /// parent project and the new project. This can then be overridden in the
    /// sub project's constructor.
    ///
    /// @param params the named parameters
    ///   * parent - the class of the parent project
    ///   * name - the name of the project. If not provided the name is
    ///     set to the (simple) class name
    ///   * directory - the directory of the project. If not provided,
    ///     the directory is set to the name with uppercase letters
    ///     converted to lowercase for subprojects.
    /// 
    ///     If a project implements [MergedTestProject] and does not 
    ///     specify a directory, its directory is set to the parent
    ///     project's directory.
    /// 
    ///     For root projects the directory is always set to the current
    ///     working directory.
    ///
    @SuppressWarnings({ "PMD.ConstructorCallsOverridableMethod",
        "PMD.AvoidCatchingGenericException", "PMD.CognitiveComplexity",
        "PMD.AvoidDeeplyNestedIfStmts", "PMD.CyclomaticComplexity",
        "PMD.UseLocaleWithCaseConversions", "PMD.CollapsibleIfStatements" })
    protected AbstractProject(NamedParameter<?>... params) {
        // Evaluate name
        projectName = NamedParameter.<String> get(params, "name",
            () -> getClass().getSimpleName());

        // Evaluate parent project
        var parentProject = NamedParameter.<
                Class<? extends Project>> get(params, "parent", null);
        if (parentProject == null) {
            if (AbstractRootProject.scopedRootProject.isBound()) {
                parent = AbstractRootProject.scopedRootProject.get();
            } else {
                parent = null;
            }
            if (this instanceof RootProject) {
                if (parent != null) {
                    throw new ConfigurationException().from(this).message(
                        "Root project of type %s cannot be a sub project",
                        getClass().getSimpleName());
                }
            }
        } else {
            parent = (AbstractProject) project(parentProject);
        }

        // Set directory, add fallback dependency
        var directory = NamedParameter.<Path> get(params, "directory", null);
        if (directory == jdbldDirectory) { // NOPMD
            directory = context().jdbldDirectory();
        }

        // Evaluate the project's directory and add to hierarchy
        if (this instanceof MergedTestProject) {
            // Special handling
            if (directory != null || parentProject == null) {
                throw new ConfigurationException().from(this).message(
                    "Merged test projects must specify a parent project"
                        + " and must not specify a directory.");
            }
            projectDirectory = parent.directory();
            parent.dependency(Forward, this);
        } else if (parent == null) {
            if (directory != null) {
                throw new ConfigurationException().from(this).message(
                    "Root project of type %s cannot specify a directory.",
                    getClass().getSimpleName());
            }
            projectDirectory = context().buildRoot();
        } else {
            if (directory == null) {
                directory = Path.of(projectName.toLowerCase());
            }
            projectDirectory = parent.directory().resolve(directory);
            // Fallback, will be replaced when the parent explicitly adds a
            // dependency.
            parent.dependency(Forward, this);
        }
        try {
            rootProject().prepareProject(this);
        } catch (Exception e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    @Override
    public RootProject rootProject() {
        // The method may be called (indirectly) from the constructor
        // of a subproject, that specifies its parent project class, to
        // get the parent project instance. In this case, the new
        // project's parent attribute has not been set yet and we have
        // to use the fallback.
        return Optional.ofNullable(parent)
            .orElseGet(AbstractRootProject.scopedRootProject::get)
            .rootProject();
    }

    @Override
    public Project project(Class<? extends Project> prjCls) {
        if (this.getClass().equals(prjCls)) {
            return this;
        }
        return rootProject().project(prjCls);
    }

    @Override
    public Optional<Project> parentProject() {
        return Optional.ofNullable(parent);
    }

    @Override
    @SuppressWarnings("checkstyle:OverloadMethodsDeclarationOrder")
    public String name() {
        return projectName;
    }

    @Override
    @SuppressWarnings("checkstyle:OverloadMethodsDeclarationOrder")
    public Path directory() {
        return projectDirectory;
    }

    @Override
    public Project generator(Generator provider) {
        if (this instanceof MergedTestProject) {
            providers.put(provider, Consume);
        } else {
            providers.put(provider, Supply);
        }
        return this;
    }

    @Override
    public Project dependency(Intent intent, ResourceProvider provider) {
        providers.put(provider, intent);
        return this;
    }

    /// Unlock access to providers.
    ///
    /* default */ void unlockProviders() {
        providersUnlocked = true;
    }

    /* default */ Stream<ResourceProvider> dependencies(Set<Intent> intents) {
        // Ordered evaluation
        return List.of(Consume, Reveal, Supply, Expose, Forward).stream()
            .filter(intents::contains).map(this::providersWithIntent)
            .flatMap(s -> s);
    }

    private Stream<ResourceProvider> providersWithIntent(Intent intent) {
        if (!providersUnlocked) {
            throw new BuildException().message(
                "Attempt to access dependencies of %s while"
                    + " invoking its constructor.",
                this);
        }
        return providers.entrySet().stream()
            .filter(e -> e.getValue() == intent).map(Entry::getKey);
    }

    @Override
    public DefaultProviderSelection providers() {
        return new DefaultProviderSelection(this);
    }

    @Override
    public ProviderSelection providers(Set<Intent> intends) {
        return new DefaultProviderSelection(this, intends);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T get(PropertyKey<T> property) {
        return (T) Optional.ofNullable(properties.get(property))
            .orElseGet(() -> {
                if (parent != null) {
                    return parent.get(property);
                }
                return property.defaultValue();
            });
    }

    @Override
    public <T> AbstractProject set(PropertyKey<T> property, T value) {
        properties.put(property, value);
        return this;
    }

    @Override
    protected <T extends Resource> Collection<T>
            doProvide(ResourceRequest<T> request) {
        return providers().resources(request).toList();
    }

    @SuppressWarnings("PMD.CommentRequired")
    private static final class ProjectTreeSpliterator
            extends AbstractSpliterator<Project> {

        private Project next;
        @SuppressWarnings("PMD.LooseCoupling")
        private final Stack<Iterator<Project>> stack = new Stack<>();
        private final Set<Project> seen = new HashSet<>();

        /// Initializes a new project tree spliterator.
        ///
        /// @param root the root
        ///
        private ProjectTreeSpliterator(Project root) {
            super(Long.MAX_VALUE, ORDERED | DISTINCT | IMMUTABLE | NONNULL);
            this.next = root;
        }

        private Iterator<Project> children(Project project) {
            return project.providers().select(EnumSet.allOf(Intent.class))
                .filter(p -> p instanceof Project).map(Project.class::cast)
                .filter(p -> !seen.contains(p))
                .iterator();
        }

        @Override
        public boolean tryAdvance(Consumer<? super Project> action) {
            if (next == null) {
                return false;
            }
            action.accept(next);
            seen.add(next);
            var children = children(next);
            if (children.hasNext()) {
                next = children.next();
                stack.push(children);
                return true;
            }
            while (!stack.isEmpty()) {
                if (stack.peek().hasNext()) {
                    next = stack.peek().next();
                    return true;
                }
                stack.pop();
            }
            next = null;
            return true;
        }
    }

    /// Provide the projects matching the given ant-style path patterns.
    ///
    /// @param patterns the patterns
    /// @param without the without
    /// @return the stream
    /// @see RootProject#projects(String[], String[])
    ///
    @SuppressWarnings("PMD.UseVarargs")
    public Stream<Project> projects(String[] patterns, String[] without) {
        return StreamSupport.stream(new ProjectTreeSpliterator(this), false)
            .filter(prj -> Arrays.stream(patterns)
                .anyMatch(pattern -> pathMatcher.isMatch(pattern,
                    rootProject().directory().relativize(prj.directory())
                        .toString())))
            .filter(prj -> !Arrays.stream(without)
                .anyMatch(wo -> pathMatcher.isMatch(wo,
                    rootProject().directory().relativize(prj.directory())
                        .toString())));
    }

    @Override
    public int hashCode() {
        return Objects.hash(projectDirectory, projectName);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        AbstractProject other = (AbstractProject) obj;
        return Objects.equals(projectDirectory, other.projectDirectory)
            && Objects.equals(projectName, other.projectName);
    }

    @Override
    public String toString() {
        return "Project " + nameWithDirectory();
    }

}