import * as fs from "node:fs/promises";
import * as path from "node:path";
import { expect } from "e2e";
import * as Effect from "effect/Effect";
import { ThreadId, ProviderInstanceId } from "@t3tools/contracts";
import { T3_HOME } from "../e2e.config.ts";
import { makeState, rpcClient, runPromise, test, WEB } from "./t3.ts";

const replay = `#!/usr/bin/env node
import { createInterface } from 'node:readline';
const root='reasoning-parent';
const send = message => process.stdout.write(JSON.stringify({jsonrpc:'2.0',...message})+'\\n');
const update = (sessionId,update) => send({method:'session/update',params:{sessionId,update}});
let optionValue='high';
const config=()=>[{id:'model',name:'Model',category:'model',type:'select',currentValue:'reasoning-model',options:[{value:'reasoning-model',name:'Reasoning Model'}]},{id:'thought_level',name:'Thinking Level',category:'thought_level',type:'select',currentValue:optionValue,options:[{value:'low',name:'Low'},{value:'high',name:'High thinking'}]}];
for await (const line of createInterface({input:process.stdin})) {
 const {id,method,params={}}=JSON.parse(line); if(id===undefined)continue;
 const respond=result=>send({id,result});
 if(method==='initialize') respond({protocolVersion:2,info:{name:'@agentclientprotocol/claude-agent-acp',version:'0.90.0'},capabilities:{session:{}},authMethods:[]});
 else if(method==='session/new'||method==='session/load') respond({sessionId:root});
 else if(method==='session/set_config_option'){if(params.configId==='thought_level')optionValue=params.value;respond({});}
 else if(method==='session/set_model')respond({});
 else if(method==='session/prompt'){
  update(root,{sessionUpdate:'user_message',messageId:'user-1',content:[{type:'text',text:'Review reasoning metadata'}]});

  respond({messageId:'user-1'}); update(root,{sessionUpdate:'state_update',state:'running'});
  update(root,{sessionUpdate:'tool_call_update',toolCallId:'agent-1',name:'Agent',title:'Reasoning review',kind:'think',status:'in_progress',rawInput:{prompt:'Review reasoning metadata',description:'Reasoning review',run_in_background:true}});
  update(root,{sessionUpdate:'subagent_update',sessionId:'reasoning-child',state:{state:'running'}});
  update('reasoning-child',{sessionUpdate:'session_message',messageId:'agent-1',senderSessionId:root,recipientSessionId:'reasoning-child',content:[{type:'text',text:'Review reasoning metadata'}]});
  update(root,{sessionUpdate:'tool_call_update',toolCallId:'agent-1',status:'completed',_meta:{claudeCode:{toolResponse:{isAsync:true}}}});
  update('reasoning-child',{sessionUpdate:'agent_message_chunk',messageId:'child-reply',content:{type:'text',text:'Reasoning review complete.'}});
  update('reasoning-child',{sessionUpdate:'state_update',state:'idle',stopReason:'end_turn'});
  update(root,{sessionUpdate:'agent_message_chunk',messageId:'reply',content:{type:'text',text:'The child completed its reasoning review.'}});
  update(root,{sessionUpdate:'state_update',state:'idle',stopReason:'end_turn'});
 } else if(method==='session/close')respond({});
 else respond({});
}
`;

test("Provider child shows the stated thinking level using its catalog label", WEB, async ({t3,app,screen})=>{
 const project=await t3.project('Reasoning demo');
 const executable=path.join(project,'claude-agent-acp');
 await fs.writeFile(executable,replay,{mode:0o755});
 const settingsPath=path.join(T3_HOME,'userdata/settings.json');
 const settings=JSON.parse(await fs.readFile(settingsPath,'utf8'));
 settings.providerInstances.reasoningReplay={driver:'acpRegistry',displayName:'Reasoning replay',enabled:true,config:{source:'local',commandPath:executable,customModels:[{slug:'reasoning-model',name:'Reasoning Model',capabilities:{optionDescriptors:[{id:'thought_level',label:'Thinking Level',type:'select',role:'reasoning',options:[{id:'low',label:'Low'},{id:'high',label:'High thinking'}]}]}}]}};
 await fs.writeFile(settingsPath,JSON.stringify(settings));
 await runPromise(Effect.gen(function*(){
  const client=yield* rpcClient(T3_HOME,app.baseUrl??'');
  yield* client['server.updateSettings']({patch:{providerInstances:settings.providerInstances}});
  yield* client['server.refreshProviders']({instanceId:ProviderInstanceId.make('reasoningReplay'),cwd:project,fresh:true,refreshModels:true});
 }).pipe(Effect.scoped));
 const {cli}=makeState(T3_HOME);
 let parent; let last;
 for(let attempt=0;attempt<8&&!parent;attempt++){
  const started=await runPromise(cli(['thread','start',project,'Review reasoning metadata','--title','Reasoning metadata','--provider','reasoningReplay','--model','reasoning-model','--option','thought_level=high','--wait','--json'],[0,1]));
  last=started; if(started.stdout.includes('threadId'))parent=JSON.parse(started.stdout);
 }
 if(!parent)throw new Error('Replay provider did not start: '+JSON.stringify(last));
 const child=await runPromise(Effect.gen(function*(){
  const client=yield* rpcClient(T3_HOME,app.baseUrl??'');
  const family=yield* client['orchestration.getThreadFamily']({threadId:ThreadId.make(parent.threadId)});
  return family.threads.find(thread=>thread.lineage.relationshipToParent==='subagent');
 }).pipe(Effect.scoped));
 if(!child)throw new Error('Native child session was not projected: '+JSON.stringify(parent));
 await t3.open({threadId:child.id});
 await screen.getByText('Reasoning review complete.',{exact:true}).waitFor({timeout:60000});
 try{await expect(screen.getByText('High thinking',{exact:true})).toBeVisible();}
 finally{await app.screenshot('provider-child-thinking-label');}
});
