/*
 * JDrupes Builder
 * Copyright (C) 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 java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;
import org.jdrupes.builder.api.BuildException;
import org.jdrupes.builder.api.ConfigurationException;
import static org.jdrupes.builder.api.Intent.*;
import org.jdrupes.builder.api.NamedParameter;
import org.jdrupes.builder.api.Project;
import org.jdrupes.builder.api.ResourceRequest;
import static org.jdrupes.builder.api.ResourceType.*;
import org.jdrupes.builder.api.RootProject;

/// A base class for implementing [RootProject]s.
///
public abstract class AbstractRootProject extends AbstractProject
        implements RootProject {

    /* default */ @SuppressWarnings("PMD.FieldNamingConventions")
    static final ScopedValue<
            AbstractRootProject> scopedRootProject = ScopedValue.newInstance();
    private DefaultBuildContext context;
    private final Map<String, CommandData> commands;
    private final Map<Class<? extends Project>, Future<Project>> projects;

    /// Initializes a new abstract root project.
    ///
    /// @param params the params
    ///
    @SuppressWarnings("PMD.ConstructorCallsOverridableMethod")
    public AbstractRootProject(NamedParameter<?>... params) {
        super(params);
        context = LauncherBase.context();

        // ConcurrentHashMap does not support null values.
        projects = Collections.synchronizedMap(new HashMap<>());
        commands = new HashMap<>();
        commandAlias("clean").description("Removes generated resources")
            .projects("**")
            .resources(of(CleanlinessType).using(Supply, Consume));
    }

    @Override
    public DefaultBuildContext context() {
        // In case super() calls context() before we set it
        if (context == null) {
            context = LauncherBase.context();
        }
        return context;
    }

    /// Close.
    ///
    @Override
    public void close() {
        if (this instanceof RootProject) {
            context().close();
        }
    }

    /// Root project.
    ///
    /// @return the root project
    ///
    @Override
    public RootProject rootProject() {
        return this;
    }

    /// Project.
    ///
    /// @param prjCls the prj cls
    /// @return the project
    ///
    @Override
    public Project project(Class<? extends Project> prjCls) {
        if (this.getClass().equals(prjCls)) {
            return this;
        }
        try {
            return projects.computeIfAbsent(prjCls, this::futureProject).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new BuildException().from(this).cause(e);
        }
    }

    private Future<Project> futureProject(Class<? extends Project> prjCls) {
        var snapshot = ScopedValueContext.snapshot();
        return context().executor().submit(() -> {
            var origThreadName = Thread.currentThread().getName();
            try {
                Thread.currentThread().setName("Creating " + prjCls);
                return snapshot.call(() -> createProject(prjCls));
            } finally {
                Thread.currentThread().setName(origThreadName);
            }
        });
    }

    private Project createProject(Class<? extends Project> prjCls) {
        try {
            return ScopedValue.where(scopedRootProject, this)
                .call(() -> {
                    var result = prjCls.getConstructor().newInstance();
                    ((AbstractProject) result).unlockProviders();
                    return result;
                });
        } catch (SecurityException | ReflectiveOperationException e) {
            throw new IllegalArgumentException(e);
        }
    }

    /// Command alias.
    ///
    /// @param name the name
    /// @return the root project. command builder
    ///
    @Override
    public RootProject.CommandBuilder commandAlias(String name) {
        if (!(this instanceof RootProject)) {
            throw new ConfigurationException().from(this).message(
                "Commands can only be defined for the root project.");
        }
        return new CommandBuilder((RootProject) this, name);
    }

    /// The Class CommandBuilder.
    ///
    public class CommandBuilder implements RootProject.CommandBuilder {
        private final RootProject rootProject;
        private final String name;
        private String description;
        private String[] projects = { "" };
        private String[] without = {};

        /// Initializes a new command builder.
        ///
        /// @param rootProject the root project
        /// @param name the name
        ///
        public CommandBuilder(RootProject rootProject, String name) {
            this.rootProject = rootProject;
            this.name = name;
        }

        @Override
        public CommandBuilder description(String description) {
            this.description = Objects.requireNonNull(description);
            return this;
        }

        @Override
        @SuppressWarnings("PMD.ArrayIsStoredDirectly")
        public RootProject.CommandBuilder projects(String... projects) {
            this.projects = projects;
            return this;
        }

        @Override
        @SuppressWarnings("PMD.ArrayIsStoredDirectly")
        public RootProject.CommandBuilder without(String... without) {
            this.without = without;
            return this;
        }

        @Override
        public RootProject resources(ResourceRequest<?>... requests) {
            for (int i = 0; i < requests.length; i++) {
                if (requests[i].uses().isEmpty()) {
                    requests[i] = requests[i].usingAll();
                }
            }
            if (description == null) {
                description = "Generate resources of type "
                    + Arrays.stream(requests).map(r -> r.type().toString())
                        .collect(Collectors.joining(", "));
            }
            commands.put(name, new CommandData(projects, without, requests,
                description));
            return rootProject;
        }
    }

    /// The Record CommandData.
    ///
    /// @param patterns the patterns
    /// @param without the without
    /// @param requests the requests
    /// @param description the description
    ///
    public record CommandData(String[] patterns, String[] without,
            ResourceRequest<?>[] requests, String description) {
    }

    /// Lookup command.
    ///
    /// @param name the name
    /// @return the command data
    ///
    public CommandData lookupCommand(String name) {
        return commands.getOrDefault(name,
            new CommandData(new String[] { "" }, new String[0],
                new ResourceRequest[0], null));
    }

    /// Return the registered command names with their descriptions.
    /// The values in the map (the descriptions) are never null, but
    /// may be empty strings.
    ///
    /// @return the command names with their descriptions
    ///
    public Map<String, String> commands() {
        return commands.entrySet().stream().collect(Collectors.toMap(
            Map.Entry::getKey, e -> e.getValue().description() != null
                ? e.getValue().description()
                : ""));
    }

}