// Scratch proof: deterministic ACP frame replay through the real server and web client.
import * as fs from "node:fs/promises";
import * as path from "node:path";
import { ProviderDriverKind, ProviderInstanceId, ThreadId } from "@t3tools/contracts";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { T3_HOME } from "../e2e.config.ts";
import { makeState, rpcClient, runPromise, test, WEB } from "./t3.ts";

// Frames match the native background-subagent lifecycle from the ACP v2 replay fixture.
const AGENT = `#!/usr/bin/env node
import { watchFile, unwatchFile } from "node:fs";
import { createInterface } from "node:readline";
const gate = process.argv[2];
const sessionId = "quiet-proof-parent";
const send = (m) => process.stdout.write(JSON.stringify({jsonrpc:"2.0",...m})+"\\n");
const update = (sessionId, update) => send({method:"session/update",params:{sessionId,update}});
for await (const line of createInterface({input:process.stdin})) {
 const {id,method} = JSON.parse(line);
 if (id === undefined) continue;
 if(method === "initialize") send({id,result:{protocolVersion:2,info:{name:"Background replay",version:"1"},capabilities:{session:{}},authMethods:[]}});
 else if(method === "session/new") send({id,result:{sessionId}});
 else if(method === "session/prompt") {
  update(sessionId,{sessionUpdate:"user_message",messageId:"prompt-1",content:[{type:"text",text:"Start a long-running asynchronous review, then finish this turn while it remains pending."}]});
  send({id,result:{messageId:"prompt-1"}});
  update(sessionId,{sessionUpdate:"state_update",state:"running"});
  update(sessionId,{sessionUpdate:"tool_call_update",toolCallId:"review-1",name:"Agent",title:"Long-running review",kind:"think",status:"in_progress",rawInput:{prompt:"Review the project asynchronously",description:"Long-running review",run_in_background:true}});
  update(sessionId,{sessionUpdate:"subagent_update",sessionId:"review-child",state:{state:"running"}});
  update("review-child",{sessionUpdate:"session_message",messageId:"review-1",senderSessionId:sessionId,recipientSessionId:"review-child",content:[{type:"text",text:"Review the project asynchronously"}]});
  update(sessionId,{sessionUpdate:"tool_call_update",toolCallId:"review-1",status:"completed",_meta:{claudeCode:{toolResponse:{isAsync:true}}}});
  update(sessionId,{sessionUpdate:"agent_message_chunk",content:{type:"text",text:"The asynchronous review is still running. I will wait for its result."}});
  watchFile(gate,{interval:100},(stat)=>{
   if(!stat.nlink) return;
   unwatchFile(gate);
   update(sessionId,{sessionUpdate:"state_update",state:"idle",stopReason:"end_turn"});
  });
 } else send({id,result:{}});
}
`;

test("A completed parent held by its asynchronous subagent stays quiet", WEB, async ({t3, app, screen, browser}) => {
 const project = await t3.project("announcement-demo");
 const observer = await t3.thread({project,title:"Other work",messages:["first"]});
 const script = path.join(project,"claude-agent-acp");
 const gate = path.join(project,"finish-parent");
 await fs.writeFile(script,AGENT,{mode:0o755});
 const instanceId = ProviderInstanceId.make("background-replay");
 await runPromise(Effect.gen(function*(){
  const client=yield* rpcClient(T3_HOME,app.baseUrl ?? "");
  yield* client["server.updateSettings"]({patch:{},providerInstanceMutation:{operation:"upsert",instanceId,instance:{driver:ProviderDriverKind.make("acpRegistry"),displayName:"Background replay",enabled:true,config:{source:"local",commandPath:script,commandArgs:[gate]}}}});
 }).pipe(Effect.scoped));
 const {cli}=makeState(T3_HOME);
 const started=await runPromise(cli(["thread","start",project,"Start a long-running asynchronous review, then finish this turn while it remains pending.","--title","Async review parent","--provider",instanceId,"--model","default","--json"]));
 const parent=JSON.parse(started.stdout) as {threadId:string};
 await t3.open(parent);
 await screen.getByText("The asynchronous review is still running.",{exact:false}).first().waitFor({timeout:60000});
 await app.screenshot("async-review-started");
 await t3.open(observer);
 await screen.getByRole("textbox").first().waitFor();
 await browser.evaluate(()=>{
  const box=document.createElement("section");box.id="announcement-audit";
  box.style.cssText="position:fixed;right:24px;bottom:24px;width:590px;padding:20px;background:#111827;color:#f9fafb;border:2px solid #94a3b8;border-radius:10px;z-index:999999;font:16px/1.5 monospace;white-space:pre-wrap";
  box.textContent="Accessibility announcement audit\nObserving real aria-live DOM updates\nParent: running; asynchronous review pending\nAnnouncements: (none)";document.body.append(box);
  const audit={messages:[] as string[],status:"running"};
  (window as any).__announcementAudit=audit;
  new MutationObserver(records=>{
   if(records.every(r=>box.contains(r.target))) return;
   for(const record of records){const el=record.target instanceof Element?record.target:record.target.parentElement;
    const live=el?.closest('[aria-live]');
    const text=live?.textContent?.trim()??"";
    if(text.includes("Done")&&text.includes("Async review parent")&&!audit.messages.includes(text)) audit.messages.push(text);
   }
   box.textContent=`Accessibility announcement audit\nObserving real aria-live DOM updates\nParent: ${audit.status}; asynchronous review pending\nAnnouncements: ${audit.messages.join(" | ")||"(none)"}`;
  }).observe(document.body,{childList:true,subtree:true,characterData:true});
 });
 await app.screenshot("before-parent-completes");
 await runPromise(Effect.gen(function*(){
  const client=yield* rpcClient(T3_HOME,app.baseUrl ?? "");
  yield* Effect.promise(()=>fs.writeFile(gate,"finish"));
  yield* client["orchestration.subscribeThread"]({threadId:ThreadId.make(parent.threadId)}).pipe(
   Stream.filter(item=>item.kind==="snapshot"?item.projection.runs.some(r=>r.status==="completed"):item.kind==="event"&&item.event.type==="run.updated"&&item.event.payload.status==="completed"),Stream.runHead);
  const projection=yield* client["orchestration.getThreadProjection"]({threadId:ThreadId.make(parent.threadId)});
  if(!projection.subagents.some(s=>s.status==="running")) throw new Error("Replay failed to retain a running asynchronous subagent");
 }).pipe(Effect.scoped));
 await browser.evaluate(async()=>{
  await new Promise(resolve=>setTimeout(resolve,1500));
  const audit=(window as any).__announcementAudit;audit.status="completed";
  document.getElementById("announcement-audit")!.textContent=`Accessibility announcement audit\nObserving real aria-live DOM updates\nParent: completed; asynchronous review pending\nAnnouncements: ${audit.messages.join(" | ")||"(none)"}`;
 });
 await app.screenshot("held-completion-announcement");
 const messages=await browser.evaluate(()=>(window as any).__announcementAudit.messages);
 expect(messages).toEqual([]);
});
