import * as Layer from "effect/Layer";
import {
  OrchestrationEventInfrastructureLayerLive,
  OrchestrationLayerLive,
} from "../orchestration/runtimeLayer.ts";
import { ProjectionProjectRepositoryLive } from "../persistence/Layers/ProjectionProjects.ts";
import * as TextGeneration from "../textGeneration/TextGeneration.ts";
import { ProviderAuthServiceLive } from "../provider/Layers/ProviderAuthService.ts";
import { layer as projectServiceLayer } from "../project/ProjectService.ts";
import { layer as projectSetupScriptRunnerLayer } from "../project/ProjectSetupScriptRunner.ts";
import { layer as checkpointCaptureServiceLayer } from "./CheckpointCaptureService.ts";
import { layer as checkpointServiceLayer } from "./CheckpointService.ts";
import { layer as checkpointRollbackServiceLayer } from "./CheckpointRollbackService.ts";
import { layer as commandPolicyLayer } from "./CommandPolicy.ts";
import { layerFromApplicationReceipts as commandReceiptStoreLayer } from "./CommandReceiptStore.ts";
import { layer as contextHandoffServiceLayer } from "./ContextHandoffService.ts";
import { layer as effectOutboxLayer } from "./EffectOutbox.ts";
import {
  executorLayer as effectExecutorLayer,
  layer as effectWorkerLayer,
} from "./EffectWorker.ts";
import { layerFromStores as eventSinkLayer } from "./EventSink.ts";
import { layerFromOrchestrationEventStore as eventStoreLayer } from "./EventStore.ts";
import { layer as idAllocatorLayer } from "./IdAllocator.ts";
import { layer as legacyV1ThreadImporterLayer } from "./LegacyV1ThreadImporter.ts";
import { layer as orchestratorLayer } from "./Orchestrator.ts";
import { layer as projectionStoreLayer } from "./ProjectionStore.ts";
import { layer as projectionMaintenanceLayer } from "./ProjectionMaintenance.ts";
import { layerFromProviderInstanceRegistry as providerAdapterRegistryLayerFromProviderInstances } from "./ProviderAdapterRegistry.ts";
import { layer as providerContinuationRequestsLayer } from "./ProviderContinuationRequests.ts";
import { workerLive as providerContinuationWorkerLive } from "./ProviderContinuationService.ts";
import { layer as threadTitleRegenerationServiceLayer } from "./ThreadTitleRegenerationService.ts";
import { layer as providerEventIngestorLayer } from "./ProviderEventIngestor.ts";
import { layer as providerSessionManagerLayer } from "./ProviderSessionManager.ts";
import { layer as providerRuntimeRecoveryLayer } from "./ProviderRuntimeRecoveryService.ts";
import { layer as providerSwitchServiceLayer } from "./ProviderSwitchService.ts";
import { layer as providerTurnControlServiceLayer } from "./ProviderTurnControlService.ts";
import { layer as providerTurnStartServiceLayer } from "./ProviderTurnStartService.ts";
import { layer as runExecutionServiceLayer } from "./RunExecutionService.ts";
import { layer as runFinalizationServiceLayer } from "./RunFinalizationService.ts";
import { layerFromProjectRepository as runtimePolicyLayerFromProjectRepository } from "./RuntimePolicy.ts";
import { layer as runtimeRequestServiceLayer } from "./RuntimeRequestService.ts";
import { layerWithLegacyImporter as threadManagementServiceLayer } from "./ThreadManagementService.ts";
import { layer as threadLaunchServiceLayer } from "./ThreadLaunchService.ts";
import { layer as threadLifecycleServiceLayer } from "./ThreadLifecycleService.ts";
import { layer as threadForkServiceLayer } from "./ThreadForkService.ts";
import { layer as turnItemPositionStoreLayer } from "./TurnItemPositionStore.ts";
import { layer as scheduledTaskServiceLayer } from "../scheduledTasks/ScheduledTaskService.ts";

const runtimePolicyProvided = runtimePolicyLayerFromProjectRepository.pipe(
  Layer.provide(ProjectionProjectRepositoryLive),
);

const eventStoreProvided = eventStoreLayer.pipe(
  Layer.provide(OrchestrationEventInfrastructureLayerLive),
);
const commandReceiptStoreProvided = commandReceiptStoreLayer.pipe(
  Layer.provide(OrchestrationEventInfrastructureLayerLive),
);

const storesLayer = Layer.mergeAll(
  OrchestrationEventInfrastructureLayerLive,
  eventStoreProvided,
  projectionStoreLayer,
  commandReceiptStoreProvided,
  effectOutboxLayer,
  turnItemPositionStoreLayer,
);

export const OrchestrationV2EventSinkLayerLive = eventSinkLayer.pipe(Layer.provide(storesLayer));
const eventSinkProvided = OrchestrationV2EventSinkLayerLive;
const projectionMaintenanceProvided = projectionMaintenanceLayer.pipe(Layer.provide(storesLayer));
const legacyV1ThreadImporterProvided = legacyV1ThreadImporterLayer.pipe(
  Layer.provide(Layer.mergeAll(eventSinkProvided, eventStoreProvided)),
);

export const ProjectServiceLayerLive = projectServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      ProjectionProjectRepositoryLive,
      OrchestrationLayerLive,
      projectionStoreLayer,
      eventSinkProvided,
      idAllocatorLayer,
      legacyV1ThreadImporterProvided,
    ),
  ),
);

const providerEventIngestorProvided = providerEventIngestorLayer.pipe(
  Layer.provide(Layer.mergeAll(eventSinkProvided, idAllocatorLayer, projectionStoreLayer)),
);

const checkpointServiceProvided = checkpointServiceLayer.pipe(Layer.provide(idAllocatorLayer));
const contextHandoffServiceProvided = contextHandoffServiceLayer.pipe(
  Layer.provide(idAllocatorLayer),
);

const providerAdapterRegistryProvided = providerAdapterRegistryLayerFromProviderInstances;
const providerSwitchServiceProvided = providerSwitchServiceLayer.pipe(
  Layer.provide(providerAdapterRegistryProvided),
);

const providerSessionManagerProvided = providerSessionManagerLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      providerAdapterRegistryProvided,
      eventSinkProvided,
      idAllocatorLayer,
      projectionStoreLayer,
    ),
  ),
);

const providerAuthServiceProvided = ProviderAuthServiceLive.pipe(
  Layer.provide(Layer.merge(projectionStoreLayer, providerSessionManagerProvided)),
);

const runExecutionServiceProvided = runExecutionServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      checkpointServiceProvided,
      eventSinkProvided,
      idAllocatorLayer,
      providerEventIngestorProvided,
    ),
  ),
);

const providerTurnStartServiceProvided = providerTurnStartServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      contextHandoffServiceProvided,
      eventSinkProvided,
      idAllocatorLayer,
      projectionStoreLayer,
      providerSessionManagerProvided,
      providerAuthServiceProvided,
      runExecutionServiceProvided,
      runtimePolicyProvided,
    ),
  ),
);

const providerTurnControlServiceProvided = providerTurnControlServiceLayer.pipe(
  Layer.provide(Layer.merge(projectionStoreLayer, providerSessionManagerProvided)),
);
const runtimeRequestServiceProvided = runtimeRequestServiceLayer.pipe(
  Layer.provide(Layer.merge(projectionStoreLayer, providerSessionManagerProvided)),
);
const checkpointRollbackServiceProvided = checkpointRollbackServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      checkpointServiceProvided,
      eventSinkProvided,
      idAllocatorLayer,
      projectionStoreLayer,
      providerSessionManagerProvided,
      runtimePolicyProvided,
    ),
  ),
);
const checkpointCaptureServiceProvided = checkpointCaptureServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      checkpointServiceProvided,
      eventSinkProvided,
      idAllocatorLayer,
      projectionStoreLayer,
    ),
  ),
);
const runFinalizationServiceProvided = runFinalizationServiceLayer.pipe(
  Layer.provide(Layer.merge(checkpointCaptureServiceProvided, projectionStoreLayer)),
);

const orchestratorProvided = orchestratorLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      checkpointServiceProvided,
      commandPolicyLayer,
      storesLayer,
      eventSinkProvided,
      commandReceiptStoreProvided,
      contextHandoffServiceProvided,
      idAllocatorLayer,
      providerAdapterRegistryProvided,
      // Same layer reference as the continuation worker and the adapter
      // infrastructure so layer memoization yields one shared request queue.
      providerContinuationRequestsLayer,
      providerEventIngestorProvided,
      runtimePolicyProvided,
      providerSessionManagerProvided,
      providerSwitchServiceProvided,
      runExecutionServiceProvided,
      threadForkServiceLayer,
    ),
  ),
);

const threadManagementProvided = threadManagementServiceLayer.pipe(
  Layer.provide(Layer.merge(orchestratorProvided, legacyV1ThreadImporterProvided)),
);
export const ProjectSetupScriptRunnerLayerLive = projectSetupScriptRunnerLayer.pipe(
  Layer.provide(ProjectServiceLayerLive),
);
const threadLaunchProvided = threadLaunchServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      ProjectServiceLayerLive,
      ProjectSetupScriptRunnerLayerLive,
      threadManagementProvided,
      commandReceiptStoreProvided,
      idAllocatorLayer,
    ),
  ),
);
const threadLifecycleProvided = threadLifecycleServiceLayer.pipe(
  Layer.provide(threadManagementProvided),
);
const scheduledTaskProvided = scheduledTaskServiceLayer.pipe(
  Layer.provide(Layer.mergeAll(threadLaunchProvided, threadManagementProvided)),
);
const providerContinuationWorkerProvided = providerContinuationWorkerLive.pipe(
  Layer.provide(
    Layer.mergeAll(providerContinuationRequestsLayer, threadManagementProvided, idAllocatorLayer),
  ),
);
const threadTitleRegenerationProvided = threadTitleRegenerationServiceLayer.pipe(
  Layer.provide(
    Layer.mergeAll(threadManagementProvided, ProjectionProjectRepositoryLive, TextGeneration.layer),
  ),
);
const effectExecutorProvided = effectExecutorLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      runFinalizationServiceProvided,
      checkpointRollbackServiceProvided,
      providerSessionManagerProvided,
      providerTurnControlServiceProvided,
      providerTurnStartServiceProvided,
      runtimeRequestServiceProvided,
      threadTitleRegenerationProvided,
      threadManagementProvided,
    ),
  ),
);
const effectWorkerProvided = effectWorkerLayer.pipe(
  Layer.provide(Layer.merge(storesLayer, effectExecutorProvided)),
);
const providerRuntimeRecoveryProvided = providerRuntimeRecoveryLayer.pipe(
  Layer.provide(
    Layer.mergeAll(
      effectWorkerProvided,
      storesLayer,
      eventSinkProvided,
      idAllocatorLayer,
      projectionStoreLayer,
    ),
  ),
);

export const OrchestrationV2LayerLive = Layer.mergeAll(
  orchestratorProvided,
  threadManagementProvided,
  effectWorkerProvided,
  providerSessionManagerProvided,
  providerAuthServiceProvided,
  providerRuntimeRecoveryProvided,
  projectionMaintenanceProvided,
  legacyV1ThreadImporterProvided,
);

export const OrchestrationV2ProductionLayerLive = Layer.mergeAll(
  OrchestrationLayerLive,
  OrchestrationV2LayerLive.pipe(Layer.provide(ProjectServiceLayerLive)),
  ProjectServiceLayerLive,
  threadLaunchProvided,
  threadLifecycleProvided,
  scheduledTaskProvided,
  providerContinuationWorkerProvided,
);