import * as NodeWS from "@effect/platform-node/NodeWS";
import { ORCHESTRATION_PROTOCOL_VERSION, ProviderInstanceId, WsRpcGroup } from "@t3tools/contracts";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as Schedule from "effect/Schedule";
import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
import { RpcClient, RpcSerialization } from "effect/rpc";
import { Socket } from "effect/socket";
import { mkdtempSync, writeFileSync, readFileSync } from "node:fs";
import { setTimeout as delay } from 'node:timers/promises';
import { T3_HOME } from "../e2e.config.ts";
import { makeState, runPromise, test, WEB } from "./t3.ts";

// A deterministic ACP peer, with the exact child notification from the reported reproduction.
const agent = String.raw`
import readline from 'node:readline';

const send = x => process.stdout.write(JSON.stringify({jsonrpc:'2.0', ...x})+'\n');
const update = (sessionId, role, text, messageId) => send({method:'session/update',params:{sessionId,update:{sessionUpdate:role, ...(messageId ? {messageId}:{}),content:{type:'text',text}}}});
readline.createInterface({input:process.stdin}).on('line', line => {
 const m=JSON.parse(line); if(m.id===undefined) return;
 let result={};
 if(m.method==='initialize') result={protocolVersion:1,agentCapabilities:{loadSession:true,sessionCapabilities:{list:{}}},authMethods:[],agentInfo:{name:'Idle child replay',version:'1'}};
 if(m.method==='session/new') result={sessionId:'mock-root-session',models:{currentModelId:'default',availableModels:[{modelId:'default',name:'Default'},{modelId:'other',name:'Other'}]}};
 if(m.method==='session/list') result={sessions:[{sessionId:'mock-root-session',cwd:m.params?.cwd || process.cwd(),title:'Root conversation',updatedAt:'2026-11-16T00:00:00.000Z'}]};
 if(m.method==='session/load') {
   update(m.params.sessionId,'user_message_chunk','Show the root history','u1');
   update(m.params.sessionId,'agent_message_chunk','hi there','a1');
   update(m.params.sessionId,'user_message_chunk','next','u2');
   update(m.params.sessionId,'agent_message_chunk','done','a2');
   send({id:m.id,result:{}});
   // Root replay has ended, no prompt/turn is active; a child emits private output.
   update('mock-child-session','agent_message_chunk','Child private work');
   return;
 }
 if(m.method==='session/prompt') result={stopReason:'end_turn'};
 if(m.method==='session/new') send({method:'session/update',params:{sessionId:'mock-root-session',update:{sessionUpdate:'available_commands_update',availableCommands:[]}}});
 send({id:m.id,result});
});
`;
const rpcClient = Effect.fn("scenario.rpc")(function* (origin: string) {
 const issued=yield* makeState(T3_HOME).cli(['auth','session','issue','--token-only']);
 const {ticket}=yield* HttpClient.execute(HttpClientRequest.post(`${origin}/api/auth/websocket-ticket`).pipe(HttpClientRequest.bearerToken(issued.stdout.trim()))).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk),Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Struct({ticket:Schema.String}))),Effect.provide(FetchHttpClient.layer));
 const protocol=yield* Layer.build(RpcClient.layerProtocolSocket().pipe(Layer.provide(Socket.layerWebSocket(`${origin.replace(/^http/,'ws')}/ws?orchestrationProtocol=${ORCHESTRATION_PROTOCOL_VERSION}&wsTicket=${encodeURIComponent(ticket)}`)),Layer.provide(RpcSerialization.layerJson),Layer.provide(NodeWS.layerWebSocketConstructor)));
 return yield* RpcClient.make(WsRpcGroup).pipe(Effect.provideContext(protocol));
});
test('Idle ACP child output stays out of root history', WEB, async ({t3,app,screen}) => {
 const project=await t3.project('ACP history demo');
 await t3.open();
 const directory=mkdtempSync(`${process.env.T3_EVIDENCE_SCRATCH}/peer-`);
 const agentPath=`${directory}/idle-child-peer.mjs`;
 writeFileSync(agentPath,agent);
 const imported=await runPromise(Effect.gen(function*(){
  const client=yield* rpcClient(app.baseUrl ?? '');
  const shell=yield* client['orchestration.subscribeShell']({}).pipe(Stream.filter(x=>x.kind==='snapshot'),Stream.take(1),Stream.runCollect);
  const projectId=Array.from(shell)[0]!.snapshot.projects.find(p=>p.workspaceRoot===project)!.id;
  const instanceId=ProviderInstanceId.make('idleChildReplay');
  yield* client['server.updateSettings']({patch:{},providerInstanceMutation:{operation:'upsert',instanceId,instance:{driver:'acpRegistry',displayName:'Idle child replay',enabled:true,config:{source:'local',commandPath:process.execPath,commandArgs:[agentPath]}}}});
  yield* client['server.refreshProviders']({instanceId,cwd:project,fresh:true,refreshModels:true});
  yield* client['subscribeServerConfig']({}).pipe(
    Stream.filter(event=>{
      const providers=event.type==='snapshot' ? event.config.providers : event.type==='providerStatuses' ? event.payload.providers : [];
      return providers.some(provider=>provider.instanceId===instanceId && provider.nativeSessions?.canLoad===true);
    }),
    Stream.take(1), Stream.runDrain,
  );
  return yield* client['server.importAcpRegistrySession']({instanceId,projectId,sessionId:'mock-root-session',title:'Root conversation'}).pipe(Effect.retry({schedule:Schedule.spaced('1 second'),times:30}));
 }).pipe(Effect.scoped));
 await t3.open(imported);
 // The import has completed before navigating; capture all root history on both sides.
 await screen.getByText('next',{exact:true}).waitFor({state:'visible'});
 let previous=readFileSync(await app.screenshot('settling'));
 for(let attempt=0;attempt<10;attempt++){
   await delay(500);
   const current=readFileSync(await app.screenshot('idle-child-history'));
   if(previous.equals(current)) break;
   if(attempt===9) throw new Error('History did not stabilize');
   previous=current;
 }
 await expect(screen.getByText('Child private work',{exact:false})).toBeHidden();
});
