import { Effect } from "effect";
import type { Accelerator, HandleReference, InstanceRecord, LaunchPlan } from "../contracts";
import { runCommandAsyncEffect } from "../../../core/command";
import { dockerFlagsFor } from "../engines/devices";
import { LOG_TAIL_BYTES, spawnFailed, type Launcher } from "./launcher";

/**
 * Container launcher. Ownership is a label pair written at `docker run` time: the
 * instance name and the record's nonce. `owns` compares the nonce, so a container someone
 * recreated by hand under the same name is never signalled — the exact analogue of the
 * process launcher's start-token check. All state queries are one `docker inspect` by
 * exact name; nothing ever lists all containers and filters, which is what made the old
 * launch path O(running containers).
 */

const NAME_LABEL = "local-studio.instance";
const NONCE_LABEL = "local-studio.nonce";
const DOCKER_TIMEOUT_MS = 30_000;

const containerName = (instanceName: string): string =>
  `local-studio-${instanceName.replace(/[^a-zA-Z0-9_.-]/g, "_")}`;

const docker = (
  args: readonly string[],
  timeoutMs = DOCKER_TIMEOUT_MS,
): Effect.Effect<{ status: number | null; stdout: string; stderr: string }> =>
  runCommandAsyncEffect("docker", [...args], { timeoutMs });

export const makeDockerLauncher = (accelerator: Accelerator): Launcher => ({
  start: (plan: LaunchPlan, record: InstanceRecord) =>
    Effect.gen(function* () {
      if (!plan.image) return yield* spawnFailed(`no image for ${record.engine} on this host`);
      const name = containerName(record.name);
      // A previous container under our name that we no longer track is torn down first —
      // by exact name, with force; `docker run` would otherwise fail on the name clash.
      yield* docker(["rm", "-f", name]).pipe(Effect.ignore);
      const deviceFlags = dockerFlagsFor(accelerator, plan.devices);
      const arguments_: string[] = [
        "run",
        "-d",
        "--name",
        name,
        "--label",
        `${NAME_LABEL}=${record.name}`,
        "--label",
        `${NONCE_LABEL}=${record.nonce}`,
        ...deviceFlags.args,
        ...deviceFlags.groupAdd.flatMap((group) => ["--group-add", group]),
        ...plan.ports.flatMap((binding) => ["-p", `${binding.host}:${binding.container}`]),
        ...plan.mounts.flatMap((mount) => [
          "-v",
          `${mount.from}:${mount.to}${mount.readOnly ? ":ro" : ""}`,
        ]),
        ...Object.entries(plan.env).flatMap(([key, value]) => ["-e", `${key}=${value}`]),
        plan.image,
        ...plan.argv,
      ];
      const result = yield* docker(arguments_, 120_000);
      if (result.status !== 0) {
        return yield* spawnFailed(`docker run failed: ${result.stderr || result.stdout}`);
      }
      return { kind: "docker", container: name } as const;
    }),

  alive: (reference: HandleReference) =>
    reference.kind !== "docker"
      ? Effect.succeed(false)
      : docker(["inspect", "-f", "{{.State.Running}}", reference.container]).pipe(
          Effect.map((result) => result.status === 0 && result.stdout.trim() === "true"),
        ),

  owns: (reference: HandleReference, record: InstanceRecord) =>
    reference.kind !== "docker"
      ? Effect.succeed(false)
      : docker([
          "inspect",
          "-f",
          `{{index .Config.Labels "${NONCE_LABEL}"}}`,
          reference.container,
        ]).pipe(
          Effect.map((result) => result.status === 0 && result.stdout.trim() === record.nonce),
        ),

  stop: (reference: HandleReference, graceMs: number) =>
    reference.kind !== "docker"
      ? Effect.void
      : Effect.gen(function* () {
          yield* docker(
            ["stop", "-t", String(Math.ceil(graceMs / 1000)), reference.container],
            graceMs + DOCKER_TIMEOUT_MS,
          ).pipe(Effect.ignore);
          yield* docker(["rm", "-f", reference.container]).pipe(Effect.ignore);
        }),

  logTail: (reference: HandleReference) =>
    reference.kind !== "docker"
      ? Effect.succeed("")
      : docker(["logs", "--tail", "60", reference.container]).pipe(
          Effect.map((result) =>
            `${result.stdout}\n${result.stderr}`.trim().slice(-LOG_TAIL_BYTES),
          ),
        ),
});