import { Effect } from "effect";
import type { Config } from "../../config/env";
import { runCommandAsyncEffect } from "../../core/command";
import type { EventManager } from "../system/event-manager";
import type { DeviceId, HostProfile, EngineRuntimeKind } from "./contracts";
import { makeTelemetry, profileFrom, type Telemetry } from "./devices/snapshot";
import { makeInstanceStore, type InstanceStore } from "./instances/store";
import { makeDockerLauncher } from "./launchers/docker";
import { makeProcessLauncher } from "./launchers/process";
import type { Launcher } from "./launchers/launcher";
import { makeComputeService, type ComputeService } from "./lifecycle";

/**
 * Assembly point: telemetry + store + launchers wired into one ComputeService. This is
 * the compute layer's entire footprint in AppContext — there is no other state.
 */

export interface Compute {
  readonly service: ComputeService;
  readonly telemetry: Telemetry;
  readonly store: InstanceStore;
  readonly host: () => Effect.Effect<HostProfile>;
}

const DOCKER_PROBE_TIMEOUT_MS = 5_000;
/** Docker appearing or losing GPU passthrough mid-run is rare; refresh occasionally. */
const DOCKER_PROBE_TTL_MS = 60_000;

interface DockerStatus {
  readonly docker: boolean;
  readonly dockerGpu: boolean;
}

const probeDocker = (): Effect.Effect<DockerStatus> =>
  Effect.gen(function* () {
    const info = yield* runCommandAsyncEffect("docker", ["info", "--format", "{{.Runtimes}}"], {
      timeoutMs: DOCKER_PROBE_TIMEOUT_MS,
    });
    if (info.status !== 0) return { docker: false, dockerGpu: false };
    // The NVIDIA container runtime advertises itself in `docker info`; ROCm needs no
    // special runtime (plain device mounts), so any working docker on linux counts.
    const gpuRuntime = info.stdout.includes("nvidia");
    return { docker: true, dockerGpu: gpuRuntime || process.platform === "linux" };
  }).pipe(Effect.catchCause(() => Effect.succeed({ docker: false, dockerGpu: false })));

export const makeCompute = (config: Config, eventManager: EventManager): Compute => {
  const telemetry = makeTelemetry({
    storagePaths: [config.data_dir, config.models_dir],
  });
  const store = makeInstanceStore(config.data_dir);

  let dockerCache: { readonly at: number; readonly value: DockerStatus } | null = null;
  const dockerStatus = (): Effect.Effect<DockerStatus> =>
    Effect.gen(function* () {
      if (dockerCache && Date.now() - dockerCache.at < DOCKER_PROBE_TTL_MS) {
        return dockerCache.value;
      }
      const value = yield* probeDocker();
      dockerCache = { at: Date.now(), value };
      return value;
    });

  let lastProfile: HostProfile | null = null;
  const host = (): Effect.Effect<HostProfile> =>
    Effect.gen(function* () {
      const snapshot = yield* telemetry.snapshot();
      const docker = yield* dockerStatus();
      const profile = profileFrom(snapshot, {
        nodeId: "self",
        docker: docker.docker,
        dockerGpu: docker.dockerGpu,
      });
      lastProfile = profile;
      return profile;
    });

  const processLauncher = makeProcessLauncher(store.logPath);
  const launcherFor = (runtime: EngineRuntimeKind): Launcher =>
    runtime === "docker"
      ? makeDockerLauncher(lastProfile?.accelerator ?? "cuda")
      : processLauncher;

  const freeDevices = (): Effect.Effect<readonly DeviceId[]> =>
    telemetry
      .snapshot()
      .pipe(Effect.map((snapshot) => snapshot.accelerators.map((accelerator) => accelerator.id)));

  const service = makeComputeService({
    store,
    launcherFor,
    host,
    freeDevices,
    onEvent: (name, stage, message) =>
      eventManager.publishLaunchProgress(name, stage, message),
  });

  return { service, telemetry, store, host };
};