import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
import type { DesktopUpdateState, DesktopUpdateStatusReport } from "@t3tools/contracts";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";

import * as ServerConfig from "../config.ts";
import * as DesktopTelemetryReceiver from "../resourceTelemetry/DesktopTelemetryReceiver.ts";
import * as DesktopAppUpdate from "./DesktopAppUpdate.ts";

function makeState(overrides: Partial<DesktopUpdateState> = {}): DesktopUpdateState {
  return {
    enabled: true,
    status: "idle",
    channel: "latest",
    currentVersion: "1.2.3",
    hostArch: "arm64",
    appArch: "arm64",
    runningUnderArm64Translation: false,
    availableVersion: null,
    downloadedVersion: null,
    releaseNotes: [],
    downloadPercent: null,
    checkedAt: null,
    message: null,
    errorContext: null,
    canRetry: false,
    omittedReleaseCount: 0,
    ...overrides,
  };
}

function report(
  requestId: string,
  state: DesktopUpdateState,
  terminal?: {
    readonly outcome: DesktopUpdateStatusReport["outcome"];
    readonly reason?: string;
  },
): DesktopUpdateStatusReport {
  return {
    version: 1,
    type: "desktopUpdateStatus",
    requestId,
    ...(terminal?.outcome === undefined ? {} : { outcome: terminal.outcome }),
    ...(terminal?.reason === undefined ? {} : { reason: terminal.reason }),
    state,
  };
}

interface HarnessOptions {
  readonly mode?: "web" | "desktop";
  readonly controlFd?: number | undefined;
  /** Reports emitted for the run, given the requestId the service generated.
      The stream ends after the last one unless `keepOpen` is set. */
  readonly reports?: (requestId: string) => readonly DesktopUpdateStatusReport[];
  readonly keepOpen?: boolean;
}

const makeHarness = Effect.fn("test.make_desktop_app_update_harness")(function* (
  options: HarnessOptions = {},
) {
  const fs = yield* FileSystem.FileSystem;
  const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-desktop-app-update-test-" });
  const requestIdDeferred = yield* Deferred.make<string>();
  const baseConfig = yield* ServerConfig.ServerConfig.pipe(
    Effect.provide(ServerConfig.layerTest(process.cwd(), baseDir)),
  );
  const config: ServerConfig.ServerConfig["Service"] = {
    ...baseConfig,
    mode: options.mode ?? "desktop",
    ...("controlFd" in options
      ? { desktopTelemetryControlFd: options.controlFd }
      : { desktopTelemetryControlFd: 5 }),
  };
  const reportsForRun = options.reports ?? (() => []);
  const changes = Stream.unwrap(
    Deferred.await(requestIdDeferred).pipe(
      Effect.map((requestId) => {
        const emitted = Stream.fromIterable(reportsForRun(requestId));
        return options.keepOpen ? Stream.concat(emitted, Stream.never) : emitted;
      }),
    ),
  );

  const service = yield* DesktopAppUpdate.make().pipe(
    Effect.provide(
      Layer.mergeAll(
        DesktopTelemetryReceiver.layerTest({
          requestDesktopUpdate: (requestId) =>
            Deferred.succeed(requestIdDeferred, requestId).pipe(Effect.asVoid),
          desktopUpdates: Effect.succeed({
            latest: Option.none<DesktopUpdateStatusReport>(),
            changes,
          }),
        }),
        ServerConfig.layer(config),
      ),
    ),
  );
  return { service };
});

it.layer(NodeServices.layer)("desktop app update", (it) => {
  it.effect("is unavailable without desktop mode or the control fd", () =>
    Effect.gen(function* () {
      const web = yield* makeHarness({ mode: "web" });
      expect(web.service.available).toBe(false);
      const noFd = yield* makeHarness({ controlFd: undefined });
      expect(noFd.service.available).toBe(false);
      expect((yield* noFd.service.run(() => Effect.void).pipe(Effect.flip)).reason).toContain(
        "not started by the T3 Code desktop app",
      );
      const desktop = yield* makeHarness();
      expect(desktop.service.available).toBe(true);
    }),
  );

  it.effect("collapses state reports into progress stages and succeeds on installing", () =>
    Effect.gen(function* () {
      const { service } = yield* makeHarness({
        reports: (requestId) => [
          report(requestId, makeState({ status: "checking" })),
          report(requestId, makeState({ status: "available", availableVersion: "1.2.4" })),
          report(requestId, makeState({ status: "downloading", downloadPercent: 40 })),
          // Reports from another run must be ignored.
          report("other-run", makeState({ status: "error", message: "unrelated" })),
          report(requestId, makeState({ status: "downloaded", downloadedVersion: "1.2.4" }), {
            outcome: "ready-to-install",
          }),
        ],
      });
      const stages: string[] = [];
      const result = yield* service.run((stage) => Effect.sync(() => void stages.push(stage)));
      expect(result).toEqual({
        targetVersion: "1.2.4",
        method: "desktop-app",
        desktopUpdateToken: expect.any(String),
      });
      // "downloading" is not repeated for every download report.
      expect(stages).toEqual(["downloading", "installing"]);

      // Success releases the in-flight guard: if the desktop rejected the
      // install after reporting, the server must accept a retry instead of
      // refusing until restart. (The second run fails differently because
      // the stub report stream is exhausted.)
      const retry = yield* service.run(() => Effect.void).pipe(Effect.flip);
      expect(retry.reason).not.toBe("A desktop app update is already in progress.");
    }),
  );

  it.effect("maps up-to-date and failed outcomes to readable errors", () =>
    Effect.gen(function* () {
      const upToDate = yield* makeHarness({
        reports: (requestId) => [
          report(requestId, makeState({ status: "up-to-date" }), { outcome: "up-to-date" }),
        ],
      });
      expect((yield* upToDate.service.run(() => Effect.void).pipe(Effect.flip)).reason).toBe(
        "The T3 Code desktop app on this machine is already up to date on 1.2.3.",
      );

      const failed = yield* makeHarness({
        reports: (requestId) => [
          report(requestId, makeState({ status: "error", message: "feed unreachable" }), {
            outcome: "failed",
            reason: "feed unreachable",
          }),
        ],
      });
      expect((yield* failed.service.run(() => Effect.void).pipe(Effect.flip)).reason).toBe(
        "feed unreachable",
      );
    }),
  );

  it.effect("replays a retained commit failure for the preparation token", () =>
    Effect.gen(function* () {
      const { service } = yield* makeHarness({
        reports: (requestId) => [
          report(requestId, makeState({ status: "downloaded", downloadedVersion: "1.2.4" }), {
            outcome: "ready-to-install",
          }),
          report(
            requestId,
            makeState({
              status: "downloaded",
              downloadedVersion: "1.2.4",
              errorContext: "install",
              message: "installer refused",
            }),
            { outcome: "failed", reason: "installer refused" },
          ),
        ],
      });
      const prepared = yield* service.run(() => Effect.void);

      expect(
        (yield* service.commit(prepared.desktopUpdateToken ?? "missing").pipe(Effect.flip)).reason,
      ).toBe("installer refused");
    }),
  );

  it.effect("fails when the desktop stops reporting before a terminal outcome", () =>
    Effect.gen(function* () {
      const { service } = yield* makeHarness({
        reports: (requestId) => [report(requestId, makeState({ status: "checking" }))],
      });
      expect((yield* service.run(() => Effect.void).pipe(Effect.flip)).reason).toBe(
        "The desktop app stopped reporting its update.",
      );
    }),
  );

  it.effect("allows only one desktop update at a time", () =>
    Effect.gen(function* () {
      const { service } = yield* makeHarness({ reports: () => [], keepOpen: true });
      const first = yield* Effect.forkChild(
        service.run(() => Effect.void),
        {
          startImmediately: true,
        },
      );
      expect((yield* service.run(() => Effect.void).pipe(Effect.flip)).reason).toBe(
        "A desktop app update is already in progress.",
      );
      yield* Fiber.interrupt(first);

      const retry = yield* Effect.forkChild(
        service.run(() => Effect.void),
        {
          startImmediately: true,
        },
      );
      yield* Effect.yieldNow;
      expect((yield* service.run(() => Effect.void).pipe(Effect.flip)).reason).toBe(
        "A desktop app update is already in progress.",
      );
      yield* Fiber.interrupt(retry);
    }),
  );
});