import * as fs from "node:fs/promises";
import * as path from "node:path";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import * as Option from "effect/Option";
import {
  ProviderInstanceId,
  ORCHESTRATION_PROTOCOL_VERSION,
  type ServerProvider,
} from "@t3tools/contracts";
import { T3_HOME } from "../e2e.config.ts";
import { makeState, rpcClient, runPromise, test, WEB } from "./t3.ts";

// Real Codex CLI, isolated API-key home. Only selected protocol replies are delayed/dropped.
const proxy = `#!/usr/bin/python3
import os,sys,json,subprocess,threading,pathlib
root=pathlib.Path(__file__).parent
if '--version' in sys.argv:
 os.execv('/usr/local/bin/codex',['codex']+sys.argv[1:])
p=subprocess.Popen(['/usr/local/bin/codex']+sys.argv[1:],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.DEVNULL)
requests={}
def incoming():
 for line in sys.stdin.buffer:
  try:
   frame=json.loads(line); requests[str(frame.get('id'))]=frame.get('method')
  except: pass
  p.stdin.write(line);p.stdin.flush()
threading.Thread(target=incoming,daemon=True).start()
try:
 for line in p.stdout:
  try:
   frame=json.loads(line);method=requests.get(str(frame.get('id')))
   mode=(root/'mode').read_text().strip()
   if mode=='slow' and method=='model/list': continue
   if mode=='ready' and method=='model/list' and 'custom' in pathlib.Path(__file__).name:
    frame['result']['data']=[];line=(json.dumps(frame)+'\\n').encode()
   if mode=='error' and method=='account/read':
    line=(json.dumps({'id':frame['id'],'error':{'code':-32603,'message':'Simulated transient account probe failure'}})+'\\n').encode()
  except: pass
  sys.stdout.buffer.write(line);sys.stdout.buffer.flush()
finally:
 p.terminate();p.wait()
`;

test(
  "Loaded Codex models survive catalog deadlines and one failed health check",
  WEB,
  async ({ t3, app, browser, screen }) => {
    const project = await t3.project("Model picker proof");
    const thread = await t3.thread({
      project,
      title: "Provider health checks",
      messages: ["first"],
    });
    const bin = path.join(T3_HOME, "bin");
    const home = path.join(T3_HOME, "codex-isolated");
    await fs.mkdir(home, { recursive: true });
    await fs.writeFile(
      path.join(home, "auth.json"),
      JSON.stringify({ OPENAI_API_KEY: "synthetic-proof-key" }),
    );
    await fs.writeFile(path.join(bin, "codex-proxy"), proxy, { mode: 0o755 });
    await fs.writeFile(path.join(bin, "mode"), "ready");
    await fs.writeFile(path.join(bin, "codex-custom-proxy"), proxy, { mode: 0o755 });
    const settingsPath = path.join(T3_HOME, "userdata/settings.json");
    const settings = JSON.parse(await fs.readFile(settingsPath, "utf8"));
    settings.providerHealthRefreshInterval = 3600000;
    settings.providerInstances.codex = {
      driver: "codex",
      displayName: "Primary",
      enabled: true,
      config: {
        binaryPath: path.join(bin, "codex-proxy"),
        homePath: home,
        customModels: [{ slug: "proof-custom", name: "Proof custom model" }],
      },
    };
    settings.providerInstances["codex-healthy"] = {
      driver: "codex",
      displayName: "Healthy",
      enabled: true,
      config: { binaryPath: "/usr/local/bin/codex", homePath: home },
    };
    settings.providerInstances["codex-custom"] = {
      driver: "codex",
      displayName: "Custom only",
      enabled: true,
      config: {
        binaryPath: path.join(bin, "codex-custom-proxy"),
        homePath: home,
        customModels: [{ slug: "proof-custom", name: "Proof custom model" }],
      },
    };
    await fs.writeFile(settingsPath, JSON.stringify(settings));
    const call = async (refresh = false, instance = "codex") =>
      runPromise(
        Effect.gen(function* () {
          const c = yield* rpcClient(T3_HOME, app.baseUrl!);
          if (refresh)
            yield* c["server.refreshProviders"]({
              instanceId: ProviderInstanceId.make(instance),
              fresh: true,
            });
          return yield* c["server.getConfig"]({});
        }).pipe(Effect.scoped),
      );
    const snapshot = async (instance = "codex") =>
      (await call()).providers.find((p) => p.instanceId === instance)!;
    // Setup waits are not verdicts: a missing real CLI or sign-in is a setup failure.
    const waitStatus = async (status: string, instance = "codex") => {
      const end = Date.now() + 70000;
      while (Date.now() < end) {
        const s = await snapshot(instance);
        if (s?.status === status) return s;
        await new Promise((r) => setTimeout(r, 500));
      }
      throw new Error(`Setup did not reach ${status}`);
    };
    await waitStatus("ready");
    await t3.open(thread);
    await browser.locator("[data-chat-provider-model-picker]").first().tap();
    await browser.locator('[data-model-picker-provider="codex"] button').tap();
    await screen.getByRole("option", /GPT-6.2-Sol/).waitFor();
    await new Promise((r) => setTimeout(r, 1000));
    await app.screenshot("01-healthy-catalog");
    const issued = await runPromise(
      makeState(T3_HOME).cli(["auth", "session", "issue", "--token-only"]),
    );
    const rawProvider = async (instance: string) => {
      const origin = app.baseUrl!;
      const { ticket } = await (
        await fetch(`${origin}/api/auth/websocket-ticket`, {
          method: "POST",
          headers: { authorization: `Bearer ${issued.stdout.trim()}` },
        })
      ).json();
      return await new Promise<ServerProvider & { modelsRetained?: boolean }>((resolve, reject) => {
        const socket = new WebSocket(
          `${origin.replace(/^http/, "ws")}/ws?orchestrationProtocol=${ORCHESTRATION_PROTOCOL_VERSION}&wsTicket=${encodeURIComponent(ticket)}`,
        );
        socket.addEventListener("open", () =>
          socket.send(
            JSON.stringify({
              _tag: "Request",
              id: "proof",
              tag: "server.getConfig",
              payload: {},
              headers: [],
            }),
          ),
        );
        socket.addEventListener("error", () =>
          reject(new Error("Could not read the real server's wire snapshot")),
        );
        socket.addEventListener("message", (event) => {
          for (const frame of [JSON.parse(String(event.data))].flat())
            if (frame._tag === "Exit") {
              socket.close();
              const provider = frame.exit?.value?.providers?.find(
                (p: { instanceId: string }) => p.instanceId === instance,
              );
              if (provider) resolve(provider);
              else reject(new Error("Provider missing from wire snapshot"));
            }
        });
      });
    };
    const settledScreenshot = async (label: string) => {
      await new Promise((r) => setTimeout(r, 500));
      await browser.evaluate(() => {
        for (const a of document.getAnimations())
          if (Number.isFinite(a.effect?.getComputedTiming().endTime)) a.finish();
        return null;
      });
      await new Promise((r) => setTimeout(r, 500));
      await app.screenshot(label);
    };
    const observations = [];
    const capture = async (label: string, instance = "codex", model = "GPT-6.2-Sol") => {
      const state = await rawProvider(instance);
      // Wait for the stream's new snapshot to render without changing its contents.
      await new Promise((r) => setTimeout(r, 1200));
      await browser.evaluate(() => {
        for (const a of document.getAnimations())
          if (Number.isFinite(a.effect?.getComputedTiming().endTime)) a.finish();
        return null;
      });
      await app.screenshot(label);
      const rows = await browser.evaluate(() =>
        Array.from(document.querySelectorAll('[data-model-picker-content] [role="option"]')).map(
          (x) => x.textContent,
        ),
      );
      const wire = {
        status: state.status,
        modelsRetained: state.modelsRetained ?? false,
        checkedAt: state.checkedAt,
      };
      observations.push({
        label,
        instance,
        wire,
        status: state.status,
        auth: state.auth.status,
        installed: state.installed,
        modelsRetained: wire?.modelsRetained ?? false,
        catalogCount: state.models.length,
        renderedRows: rows,
      });
      await fs.writeFile(
        path.join(T3_HOME, "..", `provider-proof-${new URL(app.baseUrl!).port}.json`),
        JSON.stringify(observations, null, 2),
      );
      return rows.some((x) => x?.includes(model));
    };
    await fs.writeFile(path.join(bin, "mode"), "slow");
    await call(true);
    await waitStatus("warning");
    const firstWarning = await capture("02-first-catalog-timeout");
    await call(true);
    await waitStatus("warning");
    const secondWarning = await capture("03-warning-without-retained-mark");
    await browser.locator('[data-model-picker-provider="codex-custom"] button').tap();
    await call(true, "codex-custom");
    await waitStatus("warning", "codex-custom");
    await capture("03b-custom-only-first-warning", "codex-custom", "Proof custom model");
    await call(true, "codex-custom");
    await waitStatus("warning", "codex-custom");
    const customWarning = await capture(
      "03b-custom-only-warning",
      "codex-custom",
      "Proof custom model",
    );
    await browser.keyboard.press("Escape");
    const current = JSON.parse(await fs.readFile(settingsPath, "utf8"));
    current.defaultModelSelection = null;
    await fs.writeFile(settingsPath, JSON.stringify(current));
    await new Promise((r) => setTimeout(r, 1200));
    await browser.evaluate(() => {
      localStorage.clear();
      return null;
    });
    await t3.open("/");
    await browser.locator("[data-chat-provider-model-picker]").first().tap();
    await settledScreenshot("03c-healthy-instance-selected");
    const healthySelected = await browser.evaluate(
      () =>
        document
          .querySelector('[data-model-picker-provider="codex-healthy"] button')
          ?.getAttribute("aria-pressed") === "true",
    );
    observations.push({ label: "03c-healthy-instance-selected", healthySelected });
    await browser.keyboard.press("Escape");
    await t3.open(thread);
    await browser.locator("[data-chat-provider-model-picker]").first().tap();
    await fs.writeFile(path.join(bin, "mode"), "ready");
    await call(true);
    await waitStatus("ready");
    await browser.locator('[data-model-picker-provider="codex"] button').tap();
    await capture("04-recovered-catalog");
    await fs.writeFile(path.join(bin, "mode"), "error");
    await call(true);
    await waitStatus("error");
    const retainedError = await capture("05-failed-probe-retained-catalog");
    await fs.writeFile(path.join(bin, "mode"), "ready");
    await call(true);
    await waitStatus("ready");
    await capture("06-recovered-after-failure");
    await browser.keyboard.press("Escape");
    const agSettings = JSON.parse(await fs.readFile(settingsPath, "utf8"));
    agSettings.providerInstances.antigravity = {
      driver: "antigravity",
      enabled: true,
      config: { authMethod: "gemini-api-key", apiKey: "synthetic-proof-key" },
    };
    await fs.writeFile(settingsPath, JSON.stringify(agSettings));
    await waitStatus("warning", "antigravity");
    await runPromise(
      Effect.gen(function* () {
        const c = yield* rpcClient(T3_HOME, app.baseUrl!);
        yield* c["provider.auth.start"]({ instanceId: ProviderInstanceId.make("antigravity") });
        const result = yield* c["provider.auth.subscribe"]({
          instanceId: ProviderInstanceId.make("antigravity"),
        }).pipe(
          Stream.filter((s) => s.phase === "succeeded" || s.phase === "failed"),
          Stream.runHead,
        );
        if (Option.isNone(result) || result.value.phase !== "succeeded")
          throw new Error("Antigravity API-key Connect did not succeed");
      }).pipe(Effect.scoped),
    );
    await waitStatus("ready", "antigravity");
    await runPromise(
      Effect.gen(function* () {
        const c = yield* rpcClient(T3_HOME, app.baseUrl!);
        yield* c["provider.install.start"]({ instanceId: ProviderInstanceId.make("antigravity") });
        const result = yield* c["provider.install.subscribe"]({
          instanceId: ProviderInstanceId.make("antigravity"),
        }).pipe(
          Stream.filter((s) => s.phase === "succeeded" || s.phase === "failed"),
          Stream.runHead,
        );
        if (Option.isNone(result) || result.value.phase !== "succeeded")
          throw new Error("Managed runtime installation did not succeed");
        return result.value;
      }).pipe(Effect.scoped),
    );
    await call(true, "antigravity");
    await waitStatus("ready", "antigravity");
    const periodic = JSON.parse(await fs.readFile(settingsPath, "utf8"));
    periodic.providerHealthRefreshInterval = 15000;
    await fs.writeFile(settingsPath, JSON.stringify(periodic));
    await browser.locator("[data-chat-provider-model-picker]").first().tap();
    await browser.locator('[data-model-picker-provider="antigravity"] button').tap();
    await settledScreenshot("07-antigravity-ready");
    const recordName = (await fs.readdir(T3_HOME, { recursive: true })).find((name) =>
      name.endsWith("/.install-complete.json"),
    );
    if (!recordName)
      throw new Error("Managed installation record not found in the isolated T3 home");
    const record = path.join(T3_HOME, recordName);
    await fs.chmod(record, 0o000);
    let agFirst = false,
      agRecheck = false;
    try {
      await new Promise((r) => setTimeout(r, 20000));
      agFirst = await capture("08-antigravity-first-periodic-failure", "antigravity", "Gemini");
      await new Promise((r) => setTimeout(r, 30000));
      agRecheck = await capture("09-antigravity-past-managed-recheck", "antigravity", "Gemini");
    } finally {
      await fs.chmod(record, 0o644);
    }
    await waitStatus("ready", "antigravity");
    await capture("10-antigravity-recovered", "antigravity", "Gemini");
    await fs.writeFile(
      path.join(T3_HOME, "observations.json"),
      JSON.stringify(observations, null, 2),
    );
    expect({
      firstWarning,
      secondWarning,
      customWarning,
      healthySelected,
      retainedError,
      agFirst,
      agRecheck,
    }).toEqual({
      firstWarning: true,
      secondWarning: true,
      customWarning: true,
      healthySelected: true,
      retainedError: true,
      agFirst: true,
      agRecheck: true,
    });
  },
);
