import * as fs from "node:fs/promises";
import { watch } from "node:fs";
import { DatabaseSync } from "node:sqlite";
import * as http from "node:http";
import * as path from "node:path";
import { execFileSync } from "node:child_process";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import * as DateTime from "effect/DateTime";
import { APP_DIR, T3_HOME } from "../e2e.config.ts";
import { makeState, rpcClient, runPromise, test, WEB } from "./t3.ts";

const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
const wrapper = `#!/usr/bin/env node
const {spawn}=require('node:child_process');
const {createInterface}=require('node:readline');
const child=spawn('/usr/local/bin/pi',process.argv.slice(2),{stdio:['pipe','pipe','inherit']});
process.stdin.pipe(child.stdin);
createInterface({input:child.stdout}).on('line',line=>{
 process.stdout.write(line+'\\n');
 try { const e=JSON.parse(line); if(e.type==='agent_start'||(e.type==='message_end'&&e.message?.role==='assistant')||(e.type==='message_update'&&['text_start','text_end'].includes(e.assistantMessageEvent?.type))) fetch(process.env.STEER_OBSERVER,{method:'POST',body:JSON.stringify({threadId:process.env.T3CODE_THREAD_ID,type:e.type==='message_update'?e.assistantMessageEvent.type:e.type})}).catch(()=>{}); } catch {}
});
child.on('exit',code=>process.exit(code??1));
process.on('SIGTERM',()=>child.kill('SIGTERM'));
`;

test(
  "A missed Pi steer keeps its queue place and releases held later work",
  WEB,
  async ({ t3, app, browser, screen }) => {
    const project = await t3.project("Queue order demo");
    const settingsPath = path.join(T3_HOME, "userdata/settings.json");
    const settings = JSON.parse(await fs.readFile(settingsPath, "utf8"));
    const piPath = path.join(T3_HOME, "bin/observed-pi.cjs");
    await fs.writeFile(piPath, wrapper, { mode: 0o755 });
    let onEvent: (type: string, threadId?: string) => void = () => {};
    const server = http.createServer(async (req, res) => {
      let data = "";
      for await (const chunk of req) data += chunk;
      res.end("ok");
      onEvent(JSON.parse(data).type, JSON.parse(data).threadId);
    });
    await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
    const address = server.address() as { port: number };
    // The wrapper observes native output without delaying or changing a Pi frame.
    const launcher = path.join(T3_HOME, "bin/pi-observer");
    await fs.writeFile(
      launcher,
      `#!/bin/sh\nexport STEER_OBSERVER=http://127.0.0.1:${address.port}\nexec node '${piPath}' "$@"\n`,
      { mode: 0o755 },
    );
    settings.providerInstances.pi = {
      driver: "pi",
      enabled: true,
      config: {
        binaryPath: launcher,
        launchArgs:
          "--no-extensions --no-skills --no-prompt-templates --no-context-files --no-mcp --thinking off",
      },
    };
    await fs.writeFile(settingsPath, JSON.stringify(settings));
    const outcomes: unknown[] = [];
    try {
      for (const stop of [false, true]) {
        const loads = [];
        if (stop)
          for (let i = 1; i <= 4; i++)
            loads.push(
              await t3.thread({
                project,
                title: `Worker load ${i}`,
                messages: ["Ready for worker load"],
                model: "multi-turn",
              }),
            );
        const thread = await t3.thread({
          project,
          title: stop ? "Stop and release" : "Missed steer queue order",
          messages: ["Ready to demonstrate queue order"],
          model: "multi-turn",
        });
        await t3.open(thread);
        await screen.getByRole("textbox").tap();
        await runPromise(
          Effect.gen(function* () {
            const rpc = yield* rpcClient(T3_HOME, app.baseUrl!);
            yield* Effect.tryPromise(async () => {
              const dispatch = (command: object) =>
                Effect.runPromise(
                  rpc["orchestration.dispatchCommand"]({
                    commandId: crypto.randomUUID(),
                    threadId: thread.threadId,
                    ...command,
                  } as never),
                );
              const projection = () =>
                Effect.runPromise(
                  rpc["orchestration.getThreadProjection"]({ threadId: thread.threadId } as never),
                );
              const send = (text: string, mode: object, model = false) =>
                dispatch({
                  type: "message.dispatch",
                  messageId: crypto.randomUUID(),
                  text,
                  attachments: [],
                  createdBy: "user",
                  creationSource: "web",
                  dispatchMode: mode,
                  ...(model
                    ? { modelSelection: { instanceId: "pi", model: "openai/gpt-6-luna" } }
                    : {}),
                });
              let receipts: unknown = null;
              let starts: Promise<unknown>[] = [];
              let loadsStarted = false;
              let fired = false,
                earlier = false;
              let runId = "";
              let handler: Promise<void> = Promise.resolve();
              let triggerError = "";
              onEvent = (type, eventThread) => {
                if (eventThread !== thread.threadId) return;
                if (type === "agent_start" && !earlier) {
                  earlier = true;
                  handler = handler.then(async () => {
                    const initial: any = await projection();
                    runId = initial.runs.find((r: any) => r.status === "running")?.id;
                    await send("QUEUED BEFORE: reply with the word BEFORE", {
                      type: "queue_after_active",
                    });
                  });
                }
                if (stop && type === "text_start" && !loadsStarted) {
                  loadsStarted = true;
                  starts = loads.map((load) =>
                    dispatch({
                      type: "message.dispatch",
                      threadId: load.threadId,
                      messageId: crypto.randomUUID(),
                      text: "Reply with exactly the single word READY",
                      attachments: [],
                      createdBy: "user",
                      creationSource: "web",
                      dispatchMode: { type: "start_immediately" },
                      modelSelection: { instanceId: "pi", model: "openai/gpt-6-luna" },
                    }),
                  );
                }
                if (type === (stop ? "text_end" : "message_end") && !fired) {
                  fired = true;
                  handler = handler
                    .then(async () => {
                      if (stop) {
                        const databasePath = path.join(T3_HOME, "userdata/statev2.sqlite");
                        const db = new DatabaseSync(databasePath, { readOnly: true });
                        let closed = false;
                        let observer: ReturnType<typeof watch>;
                        await new Promise<void>((resolve, reject) => {
                          const close = () => {
                            if (closed) return;
                            closed = true;
                            observer.close();
                            db.close();
                          };
                          const check = () => {
                            if (closed) return;
                            try {
                              const row = db
                                .prepare(
                                  `SELECT count(*) AS count FROM orchestration_v2_effect_outbox WHERE effect_type='provider-turn.start' AND thread_id IN (${loads.map(() => "?").join(",")}) AND json_extract(payload_json,'$.runId') LIKE '%:ordinal:2'`,
                                )
                                .get(...loads.map((load) => load.threadId)) as { count: number };
                              if (row.count === 4) {
                                close();
                                resolve();
                              }
                            } catch (error) {
                              close();
                              reject(error);
                            }
                          };
                          observer = watch(`${databasePath}-wal`, check);
                          check();
                        });
                      }

                      const a = await send("STEER: reply with the word STEERED", {
                        type: "steer_active",
                        targetRunId: runId,
                      });
                      let b, c;
                      if (stop) {
                        const databasePath = path.join(T3_HOME, "userdata/statev2.sqlite");
                        const db = new DatabaseSync(databasePath, { readOnly: true });
                        let closed = false;
                        let observer: ReturnType<typeof watch>;
                        const close = () => {
                          if (closed) return;
                          closed = true;
                          observer.close();
                          db.close();
                        };
                        const queued = new Promise<void>((resolve, reject) => {
                          observer = watch(`${databasePath}-wal`, () => {
                            if (closed) return;
                            try {
                              const row = db
                                .prepare(
                                  "SELECT 1 FROM orchestration_events WHERE stream_id=? AND event_type='message.updated' AND json_extract(payload_json,'$.text')=? LIMIT 1",
                                )
                                .get(thread.threadId, "QUEUED LATER: reply with the word LATER");
                              if (row) {
                                close();
                                resolve();
                              }
                            } catch (e) {
                              close();
                              reject(e);
                            }
                          });
                        });
                        const later = send("QUEUED LATER: reply with the word LATER", {
                          type: "queue_after_active",
                        });

                        try {
                          await queued;
                          c = await dispatch({ type: "thread.stop" });
                          b = await later;
                        } finally {
                          close();
                        }
                      } else
                        b = await send("QUEUED LATER: reply with the word LATER", {
                          type: "queue_after_active",
                        });
                      receipts = { steer: a.sequence, later: b.sequence, stop: c?.sequence };
                      await Promise.all(starts);
                    })
                    .catch((e) => {
                      triggerError = String(e);
                    });
                }
              };
              await send(
                "Reply with exactly the single word READY",
                { type: "start_immediately" },
                true,
              );
              let p: any;
              let firedAt = 0;
              const deadline = Date.now() + 60000;
              do {
                await wait(150);
                p = await projection();
                if (fired) {
                  await handler;
                  firedAt ||= Date.now();
                }
                if (
                  firedAt &&
                  Date.now() - firedAt > 1000 &&
                  p.runs.some((r: any) => r.status === "queued" && r.queueHeld) &&
                  !p.runs.some((r: any) => ["running", "starting", "waiting"].includes(r.status))
                )
                  break;
              } while (
                Date.now() < deadline &&
                (!fired ||
                  p.runs.some((r: any) =>
                    ["running", "starting", "queued", "waiting"].includes(r.status),
                  ))
              );
              onEvent = () => {};
              const messages = new Map(p.messages.map((m: any) => [m.id, m.text]));
              const runs = p.runs
                .filter((r: any) => r.status !== "cancelled")
                .filter((r: any) => String(messages.get(r.userMessageId)).match(/^(QUEUED|STEER)/))
                .sort(
                  (a: any, b: any) =>
                    (a.startedAt ? DateTime.toEpochMillis(a.startedAt) : Infinity) -
                    (b.startedAt ? DateTime.toEpochMillis(b.startedAt) : Infinity),
                )
                .map((r: any) => ({
                  text: messages.get(r.userMessageId),
                  status: r.status,
                  held: r.queueHeld ?? false,
                  queuePosition: r.queuePosition,
                  ordinal: r.ordinal,
                  startedAt: r.startedAt ? DateTime.formatIso(r.startedAt) : null,
                }));
              const events = JSON.parse(
                execFileSync(
                  "sqlite3",
                  [
                    "-readonly",
                    "-json",
                    path.join(T3_HOME, "userdata/statev2.sqlite"),
                    `SELECT sequence,event_type,command_id,payload_json FROM orchestration_events WHERE stream_id='${thread.threadId}' AND event_type IN ('run.created','run.updated','message.updated') ORDER BY sequence`,
                  ],
                  { encoding: "utf8" },
                ),
              );
              const effects = JSON.parse(
                execFileSync(
                  "sqlite3",
                  [
                    "-readonly",
                    "-json",
                    path.join(T3_HOME, "userdata/statev2.sqlite"),
                    `SELECT payload_json FROM orchestration_v2_effect_outbox WHERE thread_id='${thread.threadId}' AND effect_type='provider-turn.steer'`,
                  ],
                  { encoding: "utf8" },
                ),
              );
              const steer = p.messages.find((m: any) => m.text.startsWith("STEER:"));
              const later = p.messages.find((m: any) => m.text.startsWith("QUEUED LATER:"));
              const nativeSteer = effects
                .map((e: any) => JSON.parse(e.payload_json))
                .find((e: any) => e.messageId === steer?.id);
              const queueEvents = events.flatMap((e: any) => {
                const value = JSON.parse(e.payload_json);
                return ["run.created", "run.updated"].includes(e.event_type)
                  ? [
                      {
                        sequence: e.sequence,
                        ordinal: value.ordinal,
                        status: value.status,
                        queuePosition: value.queuePosition ?? null,
                        queueHeld: value.queueHeld ?? false,
                        later: value.userMessageId === later?.id,
                        fromSteerFollowUp:
                          e.command_id?.startsWith("command:steer-follow-up:") ?? false,
                      },
                    ]
                  : [];
              });
              const firstResend = Math.min(
                ...queueEvents.filter((e: any) => e.fromSteerFollowUp).map((e: any) => e.sequence),
              );
              const heldBeforeResend = queueEvents.some(
                (e: any) => e.later && e.queueHeld && e.sequence < firstResend,
              );
              const laterReleasedAndShifted = queueEvents.some(
                (e: any) => e.later && e.fromSteerFollowUp && e.queuePosition === 3 && !e.queueHeld,
              );
              const threadCount = Number(
                execFileSync(
                  "sqlite3",
                  [
                    "-readonly",
                    path.join(T3_HOME, "userdata/statev2.sqlite"),
                    "SELECT count(*) FROM orchestration_events WHERE event_type='thread.created'",
                  ],
                  { encoding: "utf8" },
                ).trim(),
              );
              const result = {
                heldBeforeResend,
                laterReleasedAndShifted,
                threadCount,
                case: stop ? "held" : "normal",
                originalStatus: p.runs.find((r: any) => r.id === runId)?.status,
                triggerError,
                fired,
                receipts,
                nativeSteer: !!nativeSteer,
                steerFollowUpAfterRunOrdinal: nativeSteer?.steerFollowUpAfterRunOrdinal,
                resent: queueEvents.some((e: any) => e.fromSteerFollowUp),
                laterWasHeld: queueEvents.some((e: any) => e.later && e.queueHeld),
                runs,
                queueEvents,
              };
              outcomes.push(result);
              const output = process.env.STEER_EVIDENCE_DIR;
              if (output) {
                await fs.mkdir(output, { recursive: true });
                const sha = execFileSync("git", ["rev-parse", "HEAD"], {
                  cwd: APP_DIR,
                  encoding: "utf8",
                }).trim();
                await fs.writeFile(
                  path.join(output, `${sha.slice(0, 10)}-${result.case}.json`),
                  JSON.stringify(result, null, 2),
                );
              }

              await fs.writeFile(
                path.join(T3_HOME, `result-${stop ? "stop" : "normal"}.json`),
                JSON.stringify(result, null, 2),
              );
            });
          }).pipe(Effect.scoped),
        );
        await wait(3000);
        const label = stop ? "stop-release" : "queue-order";
        const first = await app.screenshot(`${label}-stability-check`);
        await wait(500);
        const second = await app.screenshot(label);
        if (!(await fs.readFile(first)).equals(await fs.readFile(second)))
          throw new Error("The final app capture was not stable");
      }
      console.log("QUEUE_RESULTS", JSON.stringify(outcomes));
      for (const result of outcomes as any[]) {
        if (result.triggerError) throw new Error(result.triggerError);
        if (!result.nativeSteer || !result.resent || result.originalStatus !== "completed")
          throw new Error("The native steer did not miss a completed turn");
        if (
          result.receipts.steer >= result.receipts.later ||
          (result.receipts.stop && result.receipts.later >= result.receipts.stop)
        )
          throw new Error("The commands were not accepted in order");
        if (result.case === "held" && !result.heldBeforeResend)
          throw new Error("Stop did not hold the later run before the resend");
        if (result.threadCount !== (result.case === "held" ? 6 : 1))
          throw new Error("The scenario did not start from the expected fresh state");
      }
      await expect(
        outcomes.map((result: any) => ({
          order: result.runs.map((r: any) => r.text.split(":")[0]),
          held: result.runs.map((r: any) => r.held),
          status: result.runs.map((r: any) => r.status),
        })),
      ).toEqual(
        [false, true].map(() => ({
          order: ["QUEUED BEFORE", "STEER", "QUEUED LATER"],
          held: [false, false, false],
          status: ["completed", "completed", "completed"],
        })),
      );
    } finally {
      onEvent = () => {};
      server.close();
    }
  },
);
