/// <reference lib="dom" />
import * as fs from "node:fs/promises";
import { expect } from "e2e";
import { T3_HOME } from "../e2e.config.ts";
import { test, WEB } from "./t3.ts";

// A deterministic ACP replay peer: two provider-native children stay busy after the parent acknowledges cancel.
// Its second instance exits when a replacement session is opened.
const peer = `const readline = require('node:readline');
const fail = process.argv.includes('--fail');
const send = x => process.stdout.write(JSON.stringify({jsonrpc:'2.0',...x})+'\\n');
const update = (sessionId, update) => send({method:'session/update',params:{sessionId,update}});
readline.createInterface({input:process.stdin}).on('line', line => {
 const m=JSON.parse(line);
 if(m.method==='session/cancel') { update('root',{sessionUpdate:'state_update',state:'idle',stopReason:'cancelled'}); return; }
 if(m.id==null || !m.method) return;
 const p=m.params||{}; const reply=result=>send({id:m.id,result});
 if(m.method==='initialize') return reply({protocolVersion:2,info:{name:'scenario-replay',version:'1'},capabilities:{session:{}},authMethods:[]});
 if(m.method==='session/new'||m.method==='session/load') {if(fail) return process.exit(9); return reply({sessionId:'root'});}
 if(m.method==='session/prompt') {
  reply({messageId:'prompt'});
  update('root',{sessionUpdate:'state_update',state:'running'});
  update('root',{sessionUpdate:'agent_message_chunk',messageId:'reply',content:{type:'text',text:'Reading two files in parallel. Partial reply is preserved.'}});
  for(const [i,title] of [[1,'Read file one'],[2,'Read file two']]) {
   update('root',{sessionUpdate:'tool_call_update',toolCallId:'agent-'+i,name:'Agent',title,kind:'think',status:'in_progress',rawInput:{prompt:title,description:title,run_in_background:true}});
   update('root',{sessionUpdate:'subagent_update',sessionId:'child-'+i,state:{state:'running'}});
   update('child-'+i,{sessionUpdate:'session_message',messageId:'agent-'+i,senderSessionId:'root',recipientSessionId:'child-'+i,content:[{type:'text',text:title}]});
   update('child-'+i,{sessionUpdate:'state_update',state:'running'});
  }
  return;
 }
 if(m.method==='session/cancel') return;
 reply({});
});`;

test('A failed replacement session settles inherited native subagents', WEB, async ({t3, app, browser, screen}) => {
  const script = `${T3_HOME}/native-children.cjs`;
  await fs.writeFile(script, peer);
  const launcher = `${T3_HOME}/claude-agent-acp`;
  await fs.writeFile(launcher, `#!/bin/sh\nexec '${process.execPath}' '${script}' \"$@\"\n`);
  await fs.chmod(launcher,0o755);
  const settingsPath = `${T3_HOME}/userdata/settings.json`;
  const settings = JSON.parse(await fs.readFile(settingsPath,'utf8'));
  for (const [id, title, args] of [['busyReplay','Busy replay',[]],['failedReplay','Failing replay',['--fail']]] as const) {
    settings.providerInstances[id] = {driver:'acpRegistry',displayName:title,enabled:true,config:{source:'local',commandPath:launcher,commandArgs:[...args],customModels:['default']}};
  }
  await fs.writeFile(settingsPath,JSON.stringify(settings));
  const project = await t3.project('Restart proof');
  const thread = await t3.thread({project,title:'Inherited native work',messages:['Set up the workspace']});
  await browser.addInitScript(() => {
    const original = WebSocket.prototype.send;
    let sequence = 900000;
    const pending = new Map<string,{resolve:(x:any)=>void,reject:(x:any)=>void}>();
    const observed = new WeakSet<WebSocket>();
    WebSocket.prototype.send = function(data) {
      if (!observed.has(this)) {
        observed.add(this);
        this.addEventListener('message', event => {
          if(typeof event.data !== 'string') return;
          let messages; try { messages=[JSON.parse(event.data)].flat(); } catch { return; }
          for(const m of messages) {
            const waiter = pending.get(String(m.requestId));
            if(m._tag === 'Exit' && waiter) {
              pending.delete(String(m.requestId));
              if(m.exit._tag==='Success') waiter.resolve(m.exit.value); else waiter.reject(new Error(JSON.stringify(m.exit)));
            }
          }
        });
      }
      const socket=this;
      (window as any).proofRpc=(tag:string,payload:unknown)=>new Promise((resolve,reject)=>{
        const id=String(++sequence); pending.set(id,{resolve,reject});
        original.call(socket,JSON.stringify({_tag:'Request',id,tag,payload,headers:[]}));
      });
      return original.call(this,data);
    };
  });
  await t3.open(thread);
  await screen.getByText('first fixture turn complete',{exact:false}).waitFor({state:'visible',timeout:60000});
  const rpc = (tag:string,payload:unknown) => browser.evaluate(async ({tag,payload}) => (window as any).proofRpc(tag,payload),{tag,payload});
  const projection = () => rpc('orchestration.getThreadProjection',{threadId:thread.threadId}) as Promise<any>;
  const dispatch = (text:string,instanceId:string,dispatchMode:unknown) => rpc('orchestration.dispatchCommand',{
    type:'message.dispatch',commandId:crypto.randomUUID(),messageId:crypto.randomUUID(),threadId:thread.threadId,
    createdBy:'user',creationSource:'web',text,attachments:[],modelSelection:{instanceId,model:'default'},dispatchMode,
  });
  await dispatch('Read two files using native subagents','busyReplay',{type:'start_immediately'});
  // Waits establish reproduction milestones; only the final assertion judges the bug.
  await screen.getByText('Read file one',{exact:false}).first().waitFor({state:'visible',timeout:60000});
  await screen.getByText('Read file two',{exact:false}).first().waitFor({state:'visible',timeout:60000});
  const running = await projection();
  const run = running.runs.find((r:any)=>r.status==='running');
  if(!run || running.subagents.filter((r:any)=>r.status==='running').length!==2) throw new Error('Reproduction setup did not create two running native children: '+JSON.stringify({runs:running.runs,subagents:running.subagents}));
  await app.screenshot('native-children-running');
  await dispatch('Restart on the failing provider','failedReplay',{type:'restart_active',targetRunId:run.id});
  await screen.getByText('Provider session failed to open',{exact:false}).first().waitFor({state:'visible',timeout:60000});
  await screen.getByRole('button','Dismiss Failing replay provider warning').tap();
  await screen.getByRole('button','Dismiss error',{exact:true}).tap();
  await app.screenshot('failed-restart');
  await expect(screen.getByText('2 working',{exact:true})).not.toBeVisible();
  await expect(screen.getByText('Waiting on 2 subagents',{exact:false})).not.toBeVisible();
});
