/*
 * Copyright 2022-2026 Revetware LLC.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.soklet;

import com.soklet.Soklet.MockHttpServer;
import com.soklet.Soklet.MockSseServer;
import com.soklet.converter.ValueConverterRegistry;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

import javax.annotation.concurrent.NotThreadSafe;
import javax.annotation.concurrent.ThreadSafe;
import java.util.Collection;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;

import static com.soklet.internal.ObjectIdentity.sameInstance;
import static java.util.Objects.requireNonNull;

/**
 * Opaque, single-use execution configuration consumed by one
 * {@link SokletSimulator} run attempt.
 * <p>
 * Each {@link #builder()} and
 * {@link #withSokletConfig(SokletConfig)} owns a fresh set of off-network
 * transports. A successful {@link Builder#build()} seals that transport graph, and
 * {@link SokletSimulator#run(SimulatorConfig, SokletSimulator.Simulation)}
 * atomically claims the completed configuration before lifecycle work begins.
 * Sequential or concurrent reuse is rejected. Create a new configuration for
 * each simulation run.
 * <p>
 * Instances are thread-safe, but deliberately stateful: claiming a run is an
 * irreversible operation. The configuration intentionally exposes no public
 * accessors; configured transports are available from the run's
 * {@link Simulator}.
 */
@ThreadSafe
public final class SimulatorConfig {
        @NonNull
        private final SokletConfig sokletConfig;
        @NonNull
        private final SimulatorOptions simulatorOptions;
        @NonNull
        private final ConfigurationGraph configurationGraph;
        @NonNull
        private final AtomicBoolean runClaimed;

        private SimulatorConfig(@NonNull Builder builder) {
                Builder exactBuilder = requireNonNull(builder);
                this.sokletConfig = exactBuilder.sokletConfigBuilder.build();
                this.simulatorOptions = exactBuilder.simulatorOptions == null
                                ? SimulatorOptions.defaultInstance()
                                : exactBuilder.simulatorOptions;
                this.configurationGraph = exactBuilder.configurationGraph;
                this.runClaimed = new AtomicBoolean();
        }

        /**
         * Creates a builder backed by a fresh off-network transport graph.
         *
         * @return a fresh simulator-configuration builder
         */
        @NonNull
        public static Builder builder() {
                return new Builder();
        }

        /**
         * Creates a builder by importing the application settings and transport
         * shape of an existing Soklet configuration.
         * <p>
         * The returned builder owns a fresh off-network counterpart for each HTTP,
         * SSE, or MCP transport present in the source; it never reuses or changes the
         * source configuration's transport instances.
         * Every transport present in the source remains present in the imported
         * shape. Use {@link #builder()} instead when a test must omit one.
         * Explicitly configured application collaborators are reused by identity,
         * while unset defaults that depend on the completed configuration are
         * derived again for the simulator configuration. MCP collaborators such as
 * admission controllers, interceptors, localizers, rate limiters, the task
 * manager, and its task-event publisher are also reused by identity; stateful
 * ones can be replaced through
         * {@link Builder#configureMcpServer(Consumer)}. Later calls on the returned
         * builder override imported settings.
         * <p>
         * Derivation is transport-isolated, not a deep copy of the application object
         * graph. A dependency-injection provider or other collaborator that captured
         * a source transport is not inspected or rebound and continues to reference
         * that source object. Supply test-scoped collaborators explicitly when that
         * distinction matters.
         * <p>
         * An imported MCP server is reconstructed from its original build settings.
         * Runtime control-plane changes made after that server was built, such as key
         * rotation or localization invalidation, are deliberately not copied.
         * HTTP and SSE streaming lifecycle capacity, callback concurrency, and cleanup
         * timeout are copied from Soklet's built-in servers. The SSE connection queue
         * capacity is also copied. Custom transports use the simulator's defaults.
         *
         * @param sokletConfig source application configuration
         * @return a fresh, transport-isolated simulator-configuration builder
         */
        @NonNull
        public static Builder withSokletConfig(
                        @NonNull SokletConfig sokletConfig) {
                return new Builder(requireNonNull(sokletConfig));
        }

        /**
         * Creates a completed, single-use simulator configuration from an existing
         * Soklet configuration.
         * <p>
         * This is equivalent to {@code withSokletConfig(sokletConfig).build()}.
         * Each invocation creates a fresh off-network transport graph, so the source
         * configuration may be used to derive any number of transport-isolated
         * simulator configurations. Application and MCP collaborators are still
         * shared by identity as described by
         * {@link #withSokletConfig(SokletConfig)}.
         *
         * @param sokletConfig source application configuration
         * @return a fresh, completed, transport-isolated simulator configuration
         */
        @NonNull
        public static SimulatorConfig fromSokletConfig(
                        @NonNull SokletConfig sokletConfig) {
                return withSokletConfig(sokletConfig).build();
        }

        @NonNull
        SokletConfig getSokletConfig() {
                return this.sokletConfig;
        }

        @NonNull
        SimulatorOptions getSimulatorOptions() {
                return this.simulatorOptions;
        }

        void claimForRun() {
                if (!this.runClaimed.compareAndSet(false, true))
                        throw new IllegalStateException(
                                        "The simulator configuration has already been claimed by a run");
        }

        @NonNull
        Object configurationIdentity() {
                return this.configurationGraph.configurationIdentity();
        }

        boolean belongsTo(@NonNull Object configurationIdentity) {
                return sameInstance(this.configurationGraph.configurationIdentity(),
                                requireNonNull(configurationIdentity));
        }

        @NonNull
        MockHttpServer simulatedHttpServer() {
                return this.configurationGraph.httpServer();
        }

        @NonNull
        MockSseServer simulatedSseServer() {
                return this.configurationGraph.sseServer();
        }

        @Nullable
        DefaultMcpServer simulatedMcpServer() {
                return this.configurationGraph.mcpServer();
        }

        /**
         * Builds a single-use configuration against fresh off-network transports.
         * <p>
         * A builder is sealed after a successful {@link #build()}. Builders are not
         * thread-safe and must not be retained after building.
         */
        @NotThreadSafe
        public static final class Builder {
                @NonNull
                private final ConfigurationGraph configurationGraph;
                private final SokletConfig.@NonNull Builder sokletConfigBuilder;
                @Nullable
                private SimulatorOptions simulatorOptions;
                @Nullable
                private DefaultMcpServer importedMcpServer;
                private boolean built;
                private int activeTransportConfigurers;

                private Builder() {
                        this.configurationGraph = new ConfigurationGraph(null, null);
                        this.sokletConfigBuilder = new SokletConfig.Builder();
                }

                private Builder(@NonNull SokletConfig sokletConfig) {
                        SokletConfig exactConfig = requireNonNull(sokletConfig);
                        this.configurationGraph = new ConfigurationGraph(exactConfig.getHttpServer().orElse(null),
                                        exactConfig.getSseServer().orElse(null));
                        this.sokletConfigBuilder = new SokletConfig.Builder();
                        exactConfig.applyApplicationSettingsTo(this.sokletConfigBuilder);
                        if (exactConfig.getHttpServer().isPresent())
                                httpServer();
                        if (exactConfig.getSseServer().isPresent())
                                sseServer();
                        this.importedMcpServer = exactConfig.getMcpServer()
                                        .map(server -> (DefaultMcpServer) server)
                                        .orElse(null);
                }

                /**
                 * Adds this run's fresh simulated HTTP server.
                 *
                 * @return this builder
                 */
                @NonNull
                public Builder httpServer() {
                        requireMutable();
                        this.sokletConfigBuilder.httpServer(
                                        this.configurationGraph.httpServer());
                        return this;
                }

                /**
                 * Adds this run's fresh simulated HTTP server and supplies that exact
                 * server for configuration-time application dependency wiring. For access
                 * from the simulation body, prefer {@link Simulator#getHttpServer()}.
                 * The consumer runs synchronously during this call and must not retain the
                 * server for another configuration.
                 *
                 * @param httpServerConsumer receives this run's HTTP server
                 * @return this builder
                 */
                @NonNull
                public Builder httpServer(
                                @NonNull Consumer<@NonNull HttpServer> httpServerConsumer) {
                        Consumer<@NonNull HttpServer> exactConsumer =
                                        requireNonNull(httpServerConsumer);
                        requireMutable();
                        beginTransportConfigurer();
                        try {
                                exactConsumer.accept(this.configurationGraph.httpServer());
                        } finally {
                                endTransportConfigurer();
                        }
                        requireMutable();
                        this.sokletConfigBuilder.httpServer(
                                        this.configurationGraph.httpServer());
                        return this;
                }

                /**
                 * Adds this run's fresh simulated Server-Sent Events server.
                 *
                 * @return this builder
                 */
                @NonNull
                public Builder sseServer() {
                        requireMutable();
                        this.sokletConfigBuilder.sseServer(
                                        this.configurationGraph.sseServer());
                        return this;
                }

                /**
                 * Adds this run's fresh simulated Server-Sent Events server and supplies
                 * that exact server for configuration-time application dependency wiring.
                 * For access from the simulation body, prefer
                 * {@link Simulator#getSseServer()}. The consumer runs synchronously during
                 * this call and must not retain the server for another configuration.
                 *
                 * @param sseServerConsumer receives this run's SSE server
                 * @return this builder
                 */
                @NonNull
                public Builder sseServer(
                                @NonNull Consumer<@NonNull SseServer> sseServerConsumer) {
                        Consumer<@NonNull SseServer> exactConsumer =
                                        requireNonNull(sseServerConsumer);
                        requireMutable();
                        beginTransportConfigurer();
                        try {
                                exactConsumer.accept(this.configurationGraph.sseServer());
                        } finally {
                                endTransportConfigurer();
                        }
                        requireMutable();
                        this.sokletConfigBuilder.sseServer(
                                        this.configurationGraph.sseServer());
                        return this;
                }

                /**
                 * Configures, builds, and adds one fresh simulated MCP server.
                 * If this builder was created by
                 * {@link SimulatorConfig#withSokletConfig(SokletConfig)} and the source
                 * configuration contains an MCP server, configuration begins with that
                 * server's construction settings. Otherwise, configuration begins with
                 * {@link McpServer#withPort(Integer)} defaults and logical port {@code 0}.
                 * The logical port may be changed with
                 * {@link McpServer.Builder#port(Integer)}.
                 * <p>
                 * The consumer runs synchronously and must only customize the supplied
                 * builder. This outer builder owns the call to
                 * {@link McpServer.Builder#build()}; calling it from the consumer or
                 * retaining the builder for later use is rejected.
                 *
                 * @param mcpServerConfigurer customizes this configuration's MCP builder
                 * @return this builder
                 */
                @NonNull
                public Builder configureMcpServer(
                                @NonNull Consumer<McpServer.@NonNull Builder>
                                                mcpServerConfigurer) {
                        Consumer<McpServer.@NonNull Builder> exactConfigurer =
                                        requireNonNull(mcpServerConfigurer);
                        requireMutable();
                        DefaultMcpServer exactImportedMcpServer = this.importedMcpServer;
                        McpBuilderLease lease = exactImportedMcpServer == null
                                        ? this.configurationGraph.openMcpBuilder(0)
                                        : this.configurationGraph.openMcpBuilder(
                                                        exactImportedMcpServer);
                        return configureAndBuildMcpServer(lease, exactConfigurer);
                }

                @NonNull
                private Builder configureAndBuildMcpServer(
                                @NonNull McpBuilderLease lease,
                                @NonNull Consumer<McpServer.@NonNull Builder> configurer) {
                        requireMutable();
                        try {
                                McpServer.Builder mcpServerBuilder = lease.builder();
                                beginTransportConfigurer();
                                try {
                                        requireNonNull(configurer).accept(mcpServerBuilder);
                                } finally {
                                        endTransportConfigurer();
                                }
                                requireMutable();
                                lease.finishConfiguration();
                                McpServer mcpServer = mcpServerBuilder.build();
                                requireMutable();
                                this.sokletConfigBuilder.mcpServer(mcpServer);
                                this.importedMcpServer = null;
                                return this;
                        } finally {
                                lease.close();
                        }
                }

                /**
                 * Sets the startup and shutdown deadline policy shared by every configured
                 * lifecycle component. Passing {@code null} restores the built-in default.
                 *
                 * @param lifecyclePolicy lifecycle policy, or {@code null} to use the default
                 * @return this builder
                 */
                @NonNull
                public Builder lifecyclePolicy(
                                @Nullable LifecyclePolicy lifecyclePolicy) {
                        requireMutable();
                        this.sokletConfigBuilder.lifecyclePolicy(lifecyclePolicy);
                        return this;
                }

                @NonNull
                Builder internalLifecyclePolicy(
                                @NonNull InternalLifecyclePolicy internalLifecyclePolicy) {
                        requireMutable();
                        this.sokletConfigBuilder.internalLifecyclePolicy(
                                        requireNonNull(internalLifecyclePolicy));
                        return this;
                }

                /**
                 * Sets how Soklet creates application instances for HTTP, SSE, and MCP
                 * handlers and application parameter values. The provider may be called
                 * concurrently.
                 *
                 * @param instanceProvider instance provider, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder instanceProvider(
                                @Nullable InstanceProvider instanceProvider) {
                        requireMutable();
                        this.sokletConfigBuilder.instanceProvider(instanceProvider);
                        return this;
                }

                /**
                 * Sets the registry used for Java value conversions.
                 *
                 * @param valueConverterRegistry registry, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder valueConverterRegistry(
                                @Nullable ValueConverterRegistry valueConverterRegistry) {
                        requireMutable();
                        this.sokletConfigBuilder.valueConverterRegistry(valueConverterRegistry);
                        return this;
                }

                /**
                 * Sets how request bodies are converted to application values.
                 *
                 * @param requestBodyMarshaler marshaler, or {@code null} to derive one
                 * @return this builder
                 */
                @NonNull
                public Builder requestBodyMarshaler(
                                @Nullable RequestBodyMarshaler requestBodyMarshaler) {
                        requireMutable();
                        this.sokletConfigBuilder.requestBodyMarshaler(requestBodyMarshaler);
                        return this;
                }

                /**
                 * Sets how Soklet discovers and resolves Resource Methods.
                 *
                 * @param resourceMethodResolver resolver, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder resourceMethodResolver(
                                @Nullable ResourceMethodResolver resourceMethodResolver) {
                        requireMutable();
                        this.sokletConfigBuilder.resourceMethodResolver(resourceMethodResolver);
                        return this;
                }

                /**
                 * Sets how parameters are supplied for Resource Method invocation.
                 *
                 * @param resourceMethodParameterProvider provider, or {@code null} for the
                 * default
                 * @return this builder
                 */
                @NonNull
                public Builder resourceMethodParameterProvider(
                                @Nullable ResourceMethodParameterProvider
                                                resourceMethodParameterProvider) {
                        requireMutable();
                        this.sokletConfigBuilder.resourceMethodParameterProvider(
                                        resourceMethodParameterProvider);
                        return this;
                }

                /**
                 * Sets how application response values are converted for transmission.
                 *
                 * @param responseMarshaler marshaler, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder responseMarshaler(
                                @Nullable ResponseMarshaler responseMarshaler) {
                        requireMutable();
                        this.sokletConfigBuilder.responseMarshaler(responseMarshaler);
                        return this;
                }

                /**
                 * Sets the interceptor around application request handling.
                 *
                 * @param requestInterceptor interceptor, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder requestInterceptor(
                                @Nullable RequestInterceptor requestInterceptor) {
                        requireMutable();
                        this.sokletConfigBuilder.requestInterceptor(requestInterceptor);
                        return this;
                }

                /**
                 * Replaces the configured lifecycle observers with one observer.
                 *
                 * @param lifecycleObserver observer, or {@code null} for no observers
                 * @return this builder
                 */
                @NonNull
                public Builder lifecycleObserver(
                                @Nullable LifecycleObserver lifecycleObserver) {
                        requireMutable();
                        this.sokletConfigBuilder.lifecycleObserver(lifecycleObserver);
                        return this;
                }

                /**
                 * Replaces the configured lifecycle observers in iteration order.
                 *
                 * @param lifecycleObservers non-null observers, or {@code null} for no
                 * observers; elements must be non-null
                 * @return this builder
                 */
                @NonNull
                public Builder lifecycleObservers(
                                @Nullable Collection<? extends @NonNull LifecycleObserver>
                                                lifecycleObservers) {
                        requireMutable();
                        this.sokletConfigBuilder.lifecycleObservers(lifecycleObservers);
                        return this;
                }

                /**
                 * Sets how Soklet records operational metrics.
                 *
                 * @param metricsCollector collector, or {@code null} for the default
                 * @return this builder
                 */
                @NonNull
                public Builder metricsCollector(
                                @Nullable MetricsCollector metricsCollector) {
                        requireMutable();
                        this.sokletConfigBuilder.metricsCollector(metricsCollector);
                        return this;
                }

                /**
                 * Sets the authorizer for ordinary HTTP and SSE CORS processing.
                 *
                 * @param corsAuthorizer authorizer, or {@code null} to reject all
                 * cross-origin requests
                 * @return this builder
                 */
                @NonNull
                public Builder corsAuthorizer(
                                @Nullable CorsAuthorizer corsAuthorizer) {
                        requireMutable();
                        this.sokletConfigBuilder.corsAuthorizer(corsAuthorizer);
                        return this;
                }

                /**
                 * Sets simulator request and response behavior options.
                 *
                 * @param simulatorOptions options, or {@code null} for defaults
                 * @return this builder
                 */
                @NonNull
                public Builder simulatorOptions(
                                @Nullable SimulatorOptions simulatorOptions) {
                        requireMutable();
                        this.simulatorOptions = simulatorOptions;
                        return this;
                }

                /**
                 * Builds the single-use configuration for one simulator run attempt.
                 *
                 * @return completed simulator configuration
                 * @throws IllegalStateException if the builder is sealed, was already built,
                 * or has no simulated server
                 */
                @NonNull
                public SimulatorConfig build() {
                        requireMutable();
                        if (this.activeTransportConfigurers != 0)
                                throw new IllegalStateException(
                                                "A simulator configuration cannot be built from a transport configurer");
                        if (this.importedMcpServer != null)
                                configureMcpServer(ignored -> {
                                });
                        SimulatorConfig config = new SimulatorConfig(this);
                        this.built = true;
                        this.configurationGraph.seal();
                        return config;
                }

                private void requireMutable() {
                        if (this.built)
                                throw new IllegalStateException(
                                                "The simulator configuration has already been built");
                        this.configurationGraph.requireOpen();
                }

                private void beginTransportConfigurer() {
                        this.activeTransportConfigurers++;
                }

                private void endTransportConfigurer() {
                        this.activeTransportConfigurers--;
                }
        }

        @ThreadSafe
        private static final class ConfigurationGraph {
                @NonNull
                private final Object configurationIdentity;
                @NonNull
                private final MockHttpServer httpServer;
                @NonNull
                private final MockSseServer sseServer;
                private boolean open;
                private @Nullable DefaultMcpServer mcpServer;
                private @Nullable McpBuilderLease activeMcpBuilderLease;

                private ConfigurationGraph(@Nullable HttpServer sourceHttpServer, @Nullable SseServer sourceSseServer) {
                        this.configurationIdentity = new Object();
                        this.httpServer = new MockHttpServer(sourceHttpServer);
                        this.sseServer = new MockSseServer(sourceSseServer);
                        this.open = true;
                }

                @NonNull
                private Object configurationIdentity() {
                        return this.configurationIdentity;
                }

                @NonNull
                private MockHttpServer httpServer() {
                        return this.httpServer;
                }

                @NonNull
                private MockSseServer sseServer() {
                        return this.sseServer;
                }

                @Nullable
                private synchronized DefaultMcpServer mcpServer() {
                        return this.mcpServer;
                }

                @NonNull
                private synchronized McpBuilderLease openMcpBuilder(
                                @NonNull Integer port) {
                        return openMcpBuilder(new McpBuilderLease(this,
                                        requireNonNull(port)));
                }

                @NonNull
                private synchronized McpBuilderLease openMcpBuilder(
                                @NonNull DefaultMcpServer sourceMcpServer) {
                        return openMcpBuilder(new McpBuilderLease(this,
                                        requireNonNull(sourceMcpServer)));
                }

                @NonNull
                private McpBuilderLease openMcpBuilder(
                                @NonNull McpBuilderLease lease) {
                        requireOpen();
                        if (this.mcpServer != null)
                                throw new IllegalStateException(
                                                "A simulator configuration may build at most one MCP server");
                        if (this.activeMcpBuilderLease != null)
                                throw new IllegalStateException(
                                                "A simulator MCP builder is already active");
                        this.activeMcpBuilderLease = requireNonNull(lease);
                        return this.activeMcpBuilderLease;
                }

                private synchronized void verifyBuildAllowed(
                                @NonNull McpBuilderLease lease) {
                        if (this.activeMcpBuilderLease != requireNonNull(lease))
                                throw new IllegalStateException(
                                                "The simulator MCP builder is no longer active");
                        requireOpen();
                        if (!lease.buildAllowed())
                                throw new IllegalStateException(
                                                "Only SimulatorConfig.Builder may build the simulator MCP server");
                        if (this.mcpServer != null)
                                throw new IllegalStateException(
                                                "A simulator configuration may build at most one MCP server");
                }

                private synchronized void register(@NonNull McpBuilderLease lease,
                                @NonNull DefaultMcpServer server) {
                        verifyBuildAllowed(lease);
                        DefaultMcpServer registered = requireNonNull(server);
                        registered.claimSimulatorScope(this);
                        this.mcpServer = registered;
                }

                private synchronized void closeLease(@NonNull McpBuilderLease lease) {
                        if (this.activeMcpBuilderLease == requireNonNull(lease))
                                this.activeMcpBuilderLease = null;
                }

                private synchronized void seal() {
                        this.open = false;
                }

                private synchronized void requireOpen() {
                        if (!this.open)
                                throw new IllegalStateException(
                                                "The simulator configuration has been sealed");
                }
        }

        @ThreadSafe
        private static final class McpBuilderLease
                        implements SimulatorMcpBuildRegistrar, AutoCloseable {
                @NonNull
                private final ConfigurationGraph configurationGraph;
                private final McpServer.@NonNull Builder builder;
                private volatile @Nullable Thread buildThread;

                private McpBuilderLease(@NonNull ConfigurationGraph configurationGraph,
                                @NonNull Integer port) {
                        this.configurationGraph = requireNonNull(configurationGraph);
                        this.builder = McpServer.withPort(requireNonNull(port))
                                        .simulatorBuildRegistrar(this);
                }

                private McpBuilderLease(@NonNull ConfigurationGraph configurationGraph,
                                @NonNull DefaultMcpServer sourceMcpServer) {
                        this.configurationGraph = requireNonNull(configurationGraph);
                        this.builder = requireNonNull(sourceMcpServer)
                                        .copyBuilderForSimulator(this);
                }

                private McpServer.@NonNull Builder builder() {
                        return this.builder;
                }

                private void finishConfiguration() {
                        this.buildThread = Thread.currentThread();
                }

                private boolean buildAllowed() {
                        return sameInstance(this.buildThread, Thread.currentThread());
                }

                @Override
                public void verifyBuildAllowed() {
                        this.configurationGraph.verifyBuildAllowed(this);
                }

                @Override
                public void register(@NonNull DefaultMcpServer server) {
                        this.configurationGraph.register(this, requireNonNull(server));
                }

                @Override
                public void close() {
                        this.buildThread = null;
                        this.configurationGraph.closeLease(this);
                }
        }
}