import { expect } from "e2e";
import { existsSync, writeFileSync, unlinkSync, readFileSync, appendFileSync } from "node:fs";
import { DatabaseSync } from "node:sqlite";
import { setTimeout as delay } from "node:timers/promises";
import { makeState, runPromise, test, WEB } from "./t3.ts";
import { T3_HOME } from "../e2e.config.ts";

const probe = process.env.T3_LOCK_PROBE_DIR!;
async function until(check: () => boolean) {
  for (let i = 0; i < 600; i++) {
    if (check()) return;
    await delay(50);
  }
  throw new Error("Controlled replay or lock fixture did not reach its milestone");
}

test("An idle thread starts its queued follow-up while another thread's lock is busy", WEB,
  async ({ t3, app, screen, browser }) => {
    const busyProject = await t3.project("busy-work", { ".gitignore": ".proof-*\n" });
    const idleProject = await t3.project("idle-work", { ".gitignore": ".proof-*\n" });
    const busy = await t3.thread({ project: busyProject, title: "Busy thread A", messages: ["Initial context"] });
    const idle = await t3.thread({ project: idleProject, title: "Idle thread B", messages: ["Initial context"] });
    const { cli } = makeState(T3_HOME);
    for (const project of [busyProject, idleProject]) {
      writeFileSync(`${project}/.proof-control`, "");
      writeFileSync(`${project}/.proof-hold`, "");
    }
    await runPromise(cli(["thread", "send", busy.threadId, "Active work on A", "--json"]));
    await runPromise(cli(["thread", "send", idle.threadId, "Active work on B", "--json"]));
    await until(() => existsSync(`${busyProject}/.proof-ready`) && existsSync(`${idleProject}/.proof-ready`));
    await runPromise(cli(["thread", "send", idle.threadId, "Queued follow-up on idle thread B", "--json"]));
    await t3.open(idle);
    await screen.getByRole("textbox").fill("", { timeout: 90000 });
    await browser.evaluate(() => {
      const style = document.createElement("style");
      style.textContent = "*,*::before,*::after{animation:none!important;transition:none!important;caret-color:transparent!important}";
      document.head.append(style);
      (document.activeElement as HTMLElement)?.blur();
    });
    writeFileSync(`${probe}/request`, busy.threadId);
    await until(() => existsSync(`${probe}/entered`));
    try {
      const db = new DatabaseSync(`${T3_HOME}/userdata/statev2.sqlite`, { readOnly: true });
      // Seed turns are already complete; require a new completion after the held active turn.
      const seedSequence = db.prepare("SELECT MAX(sequence) AS seq FROM orchestration_events").get()!.seq as number;
      unlinkSync(`${busyProject}/.proof-hold`);
      await until(() => Boolean(db.prepare("SELECT sequence FROM orchestration_events WHERE stream_id = ? AND event_type = 'run.updated' AND json_extract(payload_json, '$.status') = 'completed' AND sequence > ?").get(busy.threadId, seedSequence)));
      await delay(250);
      unlinkSync(`${idleProject}/.proof-hold`);
      await until(() => Boolean(db.prepare("SELECT sequence FROM orchestration_events WHERE stream_id = ? AND event_type = 'run.updated' AND json_extract(payload_json, '$.status') = 'completed' AND sequence > ?").get(idle.threadId, seedSequence)));
      await delay(3500);
      const milestones = db.prepare("SELECT sequence, stream_id, event_type, json_extract(payload_json, '$.status') AS status FROM orchestration_events WHERE event_type = 'run.updated' ORDER BY sequence").all().map(row => ({ sequence: row.sequence, thread: row.stream_id === busy.threadId ? "A" : "B", status: row.status }));
      writeFileSync(`${probe}/milestones.json`, JSON.stringify({ lockEntered: existsSync(`${probe}/entered`), lockReleased: existsSync(`${probe}/released`), events: milestones }, null, 2));
      appendFileSync(`${probe}/milestones.ndjson`, JSON.stringify({ lockEntered: existsSync(`${probe}/entered`), lockReleased: existsSync(`${probe}/released`), events: milestones }) + "\n");
      db.close();
      const first = await app.screenshot("stability-check");
      await delay(500);
      const second = await app.screenshot("idle-queue-with-unrelated-lock-held");
      if (!readFileSync(first).equals(readFileSync(second))) throw new Error("Evidence screenshots were not stable");
      await expect(screen.getByText("Queued follow-up started while the unrelated busy lock is held.", { exact: false })).toBeVisible({ timeout: 3000 });
      if (existsSync(`${probe}/released`)) throw new Error("Lock fixture expired before the assertion");
    } finally {
      writeFileSync(`${probe}/release`, "");
    }
  });
