import * as Effect from "effect/Effect";
import { loadControlPlaneConfig } from "../configuration/control-plane.ts";
import type { InstallationConfig } from "../configuration/customer.ts";
import { parseInstallationConfig } from "../configuration/customer.ts";
import type { Artifact } from "./artifact-types.ts";
import { verifyUpgradeIdentity } from "./artifact.ts";
import type { Env } from "./config.ts";
import { ResourceConflict, SetupRequired } from "./deployment-errors.ts";
import { fingerprint } from "./deployment-values.ts";
import type { Installation } from "./installation-metadata.ts";
import type { InstallationOperation } from "./operation.ts";
import type { WorkerAPI } from "./worker-api.ts";

export function runtimeConfiguration(
  env: Env,
  record: Installation,
  artifact: Artifact,
  deployedOperationId: string,
) {
  return Effect.gen(function* () {
    const { config: cp } = yield* Effect.try({
      try: () => loadControlPlaneConfig(env),
      catch: () => new SetupRequired(),
    });
    if (!cp.bridge) return yield* new SetupRequired();
    return yield* Effect.try({
      try: () =>
        parseInstallationConfig({
          schemaVersion: 1,
          installationId: record.installationId,
          ownerSubject: record.ownerSubject,
          runtimeOrigin: record.resources.runtimeOrigin,
          controlPlaneOrigin: cp.publicOrigin,
          bridge: cp.bridge,
          release: {
            version: artifact.identity.version,
            artifactDigest: artifact.identity.artifactDigest,
            operationId: deployedOperationId,
          },
        }),
      catch: () => new SetupRequired(),
    });
  });
}

export function deploymentConfiguration(
  env: Env,
  record: Installation,
  artifact: Artifact,
  operation: InstallationOperation,
  worker: Pick<WorkerAPI, "settings" | "configuration">,
) {
  return Effect.gen(function* () {
    let config: InstallationConfig = yield* runtimeConfiguration(
      env,
      record,
      artifact,
      operation.workerIntent?.operationId ?? operation.operationId,
    );
    if (operation.upgrade) {
      const source = operation.upgrade.fromRelease;
      yield* verifyUpgradeIdentity(source, artifact);
      const settings = yield* worker.settings();
      if (!settings) return yield* new ResourceConflict();
      const existing = yield* worker.configuration(settings);
      const expected =
        existing.release?.artifactDigest === source.artifactDigest
          ? operation.upgrade.configDigest
          : operation.workerIntent?.configDigest;
      if (!expected || (yield* fingerprint(existing)) !== expected)
        return yield* new ResourceConflict();
      config = {
        ...existing,
        release: {
          version: artifact.identity.version,
          artifactDigest: artifact.identity.artifactDigest,
          operationId:
            operation.workerIntent?.operationId ?? operation.operationId,
        },
      };
    }

    return config;
  });
}