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

import java.io.PrintStream;
import java.nio.file.Path;
import java.util.EnumSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.cli.CommandLine;
import org.jdrupes.builder.api.BuildContext;
import org.jdrupes.builder.api.BuildException;
import 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 static org.jdrupes.builder.api.ResourceType.CleanlinessType;
import org.jdrupes.builder.api.RootProject;
import org.jdrupes.builder.api.StatusLine;
import org.jdrupes.builder.core.console.SplitConsole;

/// A context for building.
///
@SuppressWarnings({ "PMD.CouplingBetweenObjects", "PMD.TooManyMethods" })
public class DefaultBuildContext implements BuildContext {

    @SuppressWarnings("PMD.FieldNamingConventions")
    private static final ScopedValue<AtomicBoolean> providerInvocationAllowed
        = ScopedValue.newInstance();
    private final FutureStreamCache cache;
    private ExecutorService executor
        = Executors.newVirtualThreadPerTaskExecutor();
    private final Path buildRoot;
    private final Properties jdbldProperties;
    private final CommandLine commandLine;
    private final AwaitableCounter executingFutureStreams
        = new AwaitableCounter();
    private final SplitConsole console;
    @SuppressWarnings("PMD.FieldNamingConventions")
    private static final ScopedValue<
            DefaultBuildContext> scopedBuildContext = ScopedValue.newInstance();
    private final CompletableFuture<AbstractRootProject> buildProject
        = new CompletableFuture<>();
    @SuppressWarnings("PMD.FieldNamingConventions")
    private static final ScopedValue<CallChainLink> callChainEnd
        = ScopedValue.newInstance();
    private final Map<ProviderInvocation<?>, CallChainLink> callChains
        = new ConcurrentHashMap<>();

    static {
        ScopedValueContext.add(scopedBuildContext, callChainEnd);
    }

    /// A link in the call chain.
    ///
    /// @param previous the previous
    /// @param invocation the invocation
    ///
    public record CallChainLink(CallChainLink previous,
            ProviderInvocation<?> invocation) {
    }

    /// Instantiates a new default build. By default, the build uses
    /// a virtual thread per task executor.
    ///
    /* default */ DefaultBuildContext(Path buildRoot,
            Properties jdbldProperties, CommandLine commandLine) {
        this.buildRoot = buildRoot;
        this.jdbldProperties = jdbldProperties;
        this.commandLine = commandLine;
        cache = new FutureStreamCache();
        console = SplitConsole.open();
    }

    /// Returns the executor service used by this build to create futures.
    ///
    /// @return the executor service
    ///
    public ExecutorService executor() {
        return executor;
    }

    /// Sets the executor service used by this build to create futures.
    ///
    /// @param executor the executor
    ///
    public void executor(ExecutorService executor) {
        this.executor = executor;
    }

    /// Executing future streams.
    ///
    /// @return the awaitable counter
    ///
    public AwaitableCounter executingFutureStreams() {
        return executingFutureStreams;
    }

    /// Returns the build root.
    ///
    /// @return the path
    ///
    public Path buildRoot() {
        return buildRoot;
    }

    @Override
    public CommandLine commandLine() {
        return commandLine;
    }

    @Override
    public String property(String name, String defaultValue) {
        return jdbldProperties.getProperty(name,
            defaultValue);
    }

    /// Returns the context.
    ///
    /// @return the optional
    ///
    public static Optional<DefaultBuildContext> context() {
        if (scopedBuildContext.isBound()) {
            return Optional.of(scopedBuildContext.get());
        }
        return Optional.empty();
    }

    /// Return a carrier with this context available from [#context].
    ///
    /// @return the carrier
    ///
    public ScopedValue.Carrier inScope() {
        return ScopedValue.where(scopedBuildContext, this);
    }

    /// Return a carrier with this context available from [#context] and
    /// the provider invocation allowed flag set.
    ///
    /// @param carrier the carrier
    /// @return the augmented carrier
    ///
    /* default */ ScopedValue.Carrier inScopeForProviderCall() {
        return inScope()
            .where(providerInvocationAllowed, new AtomicBoolean(true));
    }

    /* default */ SplitConsole console() {
        return console;
    }

    @Override
    public StatusLine statusLine() {
        return FutureStream.statusLine.orElse(SplitConsole.nullStatusLine());
    }

    @Override
    public PrintStream out() {
        return console().out();
    }

    @Override
    public PrintStream error() {
        return console().err();
    }

    @Override
    public <T extends Resource> Stream<T> resources(ResourceProvider provider,
            ResourceRequest<T> request) {
        // Normalize request, non-project providers don't get intends
        var invocation = new ProviderInvocation<>(provider,
            provider instanceof Project || request.uses().isEmpty() ? request
                : request.using(EnumSet.noneOf(Intent.class)));
        return ScopedValue.where(scopedBuildContext, this)
            .where(providerInvocationAllowed, new AtomicBoolean(true))
            .where(callChainEnd, new CallChainLink(
                callChainEnd.isBound() ? callChainEnd.get()
                    : new CallChainLink(null, ProviderInvocation.LAUNCH),
                invocation))
            .call(() -> inResourcesContext(invocation));
    }

    @SuppressWarnings({ "PMD.AvoidSynchronizedStatement",
        "PMD.AvoidInstantiatingObjectsInLoops" })
    private <T extends Resource> Stream<T> inResourcesContext(
            ProviderInvocation<T> invocation) {
        var prev = callChainEnd().previous;
        while (prev != null) {
            if (invocation.equals(prev.invocation())) {
                throw new BuildException().message("Request loop: %s",
                    callChain().stream().map(ProviderInvocation::toString)
                        .collect(Collectors.joining(" ≪ ")));
            }
            prev = prev.previous;
        }
        callChains.put(invocation, callChainEnd());
        if (invocation.provider() instanceof Project) {
            // As a project's provide only delegates to other providers
            // it is inefficient to invoke it asynchronously. Besides, it
            // leads to recursive invocations of the project's deploy
            // method too easily and results in a loop detection without
            // there really being a loop.
            return ((AbstractProvider) invocation.provider()).toSpi()
                .provide(invocation.request());
        }
        if (!invocation.request().type().equals(CleanlinessType)) {
            return cache.computeIfAbsent(
                invocation, k -> new FutureStream<T>(this, k)).stream();
        }

        // Special handling for cleanliness. Clean one by one...
        synchronized (executor) {
            // Await completion of all generating threads
            try {
                executingFutureStreams().await(0);
            } catch (InterruptedException e) {
                throw new BuildException().cause(e);
            }
        }
        var result = ((AbstractProvider) invocation.provider()).toSpi()
            .provide(invocation.request());
        // Purge cached results from provider
        cache.purge(invocation.provider());
        return result;
    }

    /// Returns the end of the current call chain.
    ///
    /// @return the call chain link
    ///
    /* default */ CallChainLink callChainEnd() {
        return callChainEnd
            .orElseThrow(() -> new IllegalStateException("No call chain"));
    }

    /* default */ List<ProviderInvocation<?>> callChain() {
        var cur = callChainEnd();
        List<ProviderInvocation<?>> result = new LinkedList<>();
        while (cur != null) {
            result.add(cur.invocation);
            cur = cur.previous;
        }
        return result;
    }

    /* default */ List<ProviderInvocation<?>>
            callChain(ProviderInvocation<?> running) {
        var cur = callChains.get(running);
        List<ProviderInvocation<?>> result = new LinkedList<>();
        while (cur != null) {
            result.add(cur.invocation);
            cur = cur.previous;
        }
        return result;
    }

    /// Checks if is provider invocation is allowed. Clears the
    /// allowed flag to also detect nested invocations.
    ///
    /// @return true, if is provider invocation allowed
    ///
    public static boolean isProviderInvocationAllowed() {
        return providerInvocationAllowed.isBound()
            && providerInvocationAllowed.get().getAndSet(false);
    }

    @Override
    public void close() {
        executor.shutdownNow();
        console.close();
    }

    /* default */ Future<AbstractRootProject> buildProject() {
        return buildProject;
    }

    /// Creates and initializes the root project and the sub projects.
    /// Adds the sub projects to the root project automatically. This
    /// method should be used if the launcher detects the sub projects
    /// e.g. by reflection and the root project does not add its sub
    /// projects itself.
    ///
    /// @param buildRoot the build root
    /// @param rootProject the root project
    /// @param subprojects the sub projects
    /// @param jdbldProps the builder properties
    /// @param commandLine the command line
    /// @return the root project
    ///
    public static AbstractRootProject createProjects(
            Path buildRoot, Class<? extends RootProject> rootProject,
            List<Class<? extends Project>> subprojects,
            Properties jdbldProps, CommandLine commandLine) {
        try {
            return ScopedValue
                .where(scopedBuildContext,
                    new DefaultBuildContext(buildRoot, jdbldProps, commandLine))
                .call(() -> {
                    var result = (AbstractRootProject) rootProject
                        .getConstructor().newInstance();
                    result.unlockProviders();
                    subprojects.forEach(result::project);
                    scopedBuildContext.get().buildProject.complete(result);
                    return result;
                });
        } catch (SecurityException | NegativeArraySizeException
                | IllegalArgumentException | ReflectiveOperationException e) {
            throw new IllegalArgumentException(e);
        }
    }
}