/** jsdom behavior only; no layout, browser pixels, SDK process or model calls. */
import assert from 'node:assert/strict'
import { createRequire } from 'node:module'
import { readFileSync } from 'node:fs'
const externalRequire=createRequire(process.cwd()+'/package.json')
const {JSDOM}=externalRequire(process.env.YCODE_TEST_DOM_MODULE||'jsdom')
const dom=new JSDOM('<html><body><main id="root"></main></body></html>',{url:'http://localhost/',pretendToBeVisual:true})
for(const key of ['window','document','Node','Element','HTMLElement','HTMLInputElement','HTMLTextAreaElement','MouseEvent','KeyboardEvent','Document','Text','DOMParser','MutationObserver','Range','ShadowRoot','File','FileReader','Event','getComputedStyle']) Object.defineProperty(globalThis,key,{value:dom.window[key],configurable:true})
Object.defineProperty(globalThis,'navigator',{value:dom.window.navigator,configurable:true})
Object.assign(globalThis,{IS_REACT_ACT_ENVIRONMENT:true,requestAnimationFrame:dom.window.requestAnimationFrame.bind(dom.window),cancelAnimationFrame:dom.window.cancelAnimationFrame.bind(dom.window)})
const composerStyle=document.createElement('style')
composerStyle.textContent=['composer.css','composer-source.css'].map(file=>readFileSync(`src/renderer/src/workbuddy/composer/${file}`,'utf8')).join('\n')
document.head.append(composerStyle)
const React=require('react') as typeof import('react')
const {act}=React
const {createRoot}=require('react-dom/client') as typeof import('react-dom/client')
const {PermissionConfirm}=require('../src/renderer/src/workbuddy/conversation/PermissionConfirm') as typeof import('../src/renderer/src/workbuddy/conversation/PermissionConfirm')
const {ComposerControls}=require('../src/renderer/src/workbuddy/composer/ComposerControls') as typeof import('../src/renderer/src/workbuddy/composer/ComposerControls')
const {composeComposer}=require('../src/renderer/src/workbuddy/composer/input-composition') as typeof import('../src/renderer/src/workbuddy/composer/input-composition')
const root=createRoot(document.getElementById('root')!)
let count=0,completed=0,declined=0, resolve!:()=>void,reject!:(e:Error)=>void
let checks=0
const check=(value:unknown,message:string)=>{assert.ok(value,message);checks++}
const options=[{optionId:'once',kind:'allow_once',name:'Once'},{optionId:'session',kind:'allow_always',name:'Session'},{optionId:'deny',kind:'reject_once',name:'Reject'}]
const pending=()=>{count++;return new Promise<void>((yes,no)=>{resolve=yes;reject=no})}
let id='a',status:'pending'|'cancelled'='pending',defaultToNo=false
const render=()=>act(async()=>root.render(<PermissionConfirm pendingId={id} status={status} toolName="Bash" options={options} details={{requestKind:'permission',toolName:'Bash',allowScope:'session',defaultToNo}} resolve={pending} reject={async()=>{declined++}} onDecisionComplete={()=>{completed++}}/>))
const key=(value:string)=>document.querySelector('section')!.dispatchEvent(new KeyboardEvent('keydown',{key:value,bubbles:true,cancelable:true}))
const click=(selector:string)=>document.querySelector(selector)!.dispatchEvent(new MouseEvent('click',{bubbles:true,cancelable:true}))
async function main(){
 await render()
 check(document.activeElement?.getAttribute('data-option-id')==='once','normal prompt focuses first option')
 await act(async()=>{key('1');key('1')})
 check(count===1,'duplicate keyboard submission synchronous guard')
 check(document.querySelectorAll('button[disabled]').length===3,'all choices disabled while submitting')
 await act(async()=>reject(new Error('fixture failed')))
 check(document.querySelector('[role="alert"]')?.textContent?.includes('fixture failed'),'failure visible')
 await act(async()=>click('[data-option-id="once"]'))
 check(count===2,'failed choice retries')
 await act(async()=>resolve())
 check(completed===1,'success completes once')
 id='b';defaultToNo=true;await render()
 check(document.activeElement?.textContent?.includes('Reject'),'default-to-no focuses reject')
 await act(async()=>key('1'));check(count===2,'default-to-no has no one-key approve shortcut')
 await act(async()=>key('Escape'));check(declined===1,'Escape rejects')
 id='c';defaultToNo=false;await render();await act(async()=>click('[data-option-id="once"]'))
 const oldResolve=resolve;const previous=completed
 id='d';await render();await act(async()=>oldResolve())
 check(completed===previous,'late result cannot complete replacement request')
 check(document.querySelector('section')?.getAttribute('data-pending-id')==='d','replacement retained')
 await act(async()=>click('[data-option-id="once"]'))
 status='cancelled';await render();await act(async()=>resolve())
 check(completed===previous,'cancelled request ignores stale success')
 check(document.querySelector('section')?.textContent?.includes('Cancelled'),'cancelled remains visible')
 id='e';status='pending';await render();await act(async()=>click('.conversation-intercept-card__rule-action'))
 check(document.querySelector('[role="status"]')?.textContent?.includes('未提供命中规则详情'),'missing rule explanation explicit')
 // Exercise the real composer with the real approval surface, not a skeleton.
 let session='session-a', active=true, sends=0, stops=0, changes=0, stopFails=false, request='request-1', stopPending=false
 let rejectStop!: (error: Error)=>void
 let settled: 'answered'|'rejected'|undefined
 const draft='preserved draft'
 const attachments=[{id:'attachment-a',name:'a.txt',mimeType:'text/plain',size:1}]
 const resources=['/fixture/reference.ts']
 const quotes=[{id:'quote-a',kind:'table' as const,sourceId:'source-a',markdown:'table',preview:'table'}]
 const renderComposer=()=>act(async()=>{
   const composition=composeComposer({interaction:active?{id:session,kind:'approval',status:'pending'}:null,queueCount:2,running:true})
   root.render(<ComposerControls key={session} sessionId={session} value={draft} onChange={()=>{changes++}} onSend={()=>{sends++}}
     attachments={attachments} resources={resources} quotes={quotes} onStop={()=>{stops++;if(stopFails)throw new Error('stop fixture failed');if(stopPending)return new Promise<void>((_yes,no)=>{rejectStop=no})}}
     queueSlot={composition.queue.visible?<div data-queue="true">two queued messages</div>:undefined}
     approvalKey={request} approvalSlot={!composition.input.visible?<PermissionConfirm pendingId={session} toolName="Bash" options={options} resolve={pending} reject={async()=>{declined++}} onDecisionComplete={decision=>{settled=decision}}/>:undefined}/>)
 })
 await renderComposer()
 const stack=document.querySelector<HTMLElement>('.conversation-input-area__input-stack')!
 check(stack.hidden&&stack.hasAttribute('inert'),'approval hides and inerts preserved input stack')
 check(getComputedStyle(stack).display==='none','composer CSS removes the normal input from layout during approval')
 check(document.querySelectorAll('[data-composer-approval] [role="dialog"]').length===1,'one bottom approval surface')
 check(!document.querySelector('.wb-composer__toolbar'),'normal toolbar and send controls removed during approval')
 check(!document.querySelector('[data-queue]'),'queue hidden without deleting queue state')
 const editor=stack.querySelector<HTMLElement>('[contenteditable]')!
 check(editor?.getAttribute('contenteditable')==='false','rich editor disabled during approval')
 const changesBefore=changes
 await act(async()=>{editor.focus();editor.dispatchEvent(new KeyboardEvent('keydown',{key:'Enter',bubbles:true,cancelable:true}))})
 check(!stack.contains(document.activeElement)&&sends===0&&changes===changesBefore,'hidden editor cannot focus, type or submit')
 await act(async()=>click('[data-option-id="once"]'))
 await act(async()=>reject(new Error('composer retry fixture')))
 check(document.querySelector('[role="alert"]')?.textContent?.includes('composer retry fixture'),'submission failure stays in replacement surface')
 check(stack.hidden&&!document.querySelector('.wb-composer__toolbar'),'failure does not expose editor/send')
 await act(async()=>click('[data-option-id="once"]'));await act(async()=>resolve())
 check(settled==='answered','allow completes through real composer')
 active=false;await renderComposer()
 check(!stack.hidden&&!stack.hasAttribute('inert'),'completion restores input stack')
 check(getComputedStyle(stack).display!=='none','composer CSS restores normal input layout')
 check(stack.textContent?.includes('a.txt')&&stack.textContent?.includes('reference.ts')&&stack.textContent?.includes('会话表格'),'attachment resource and quote survive approval')
 check(stack.textContent?.includes(draft),'rich draft survives approval')
 check(!!document.querySelector('[data-queue]')&&!!document.querySelector('.wb-composer__toolbar'),'queue and send toolbar restore')
 active=true;settled=undefined;await renderComposer();await act(async()=>key('Escape'))
 check(settled==='rejected','deny completes through real composer')
 active=false;await renderComposer();check(!stack.hidden,'deny restores editor after terminal interaction')
 active=true;await renderComposer();await act(async()=>click('[data-option-id="once"]'));const staleResolve=resolve
 session='session-b';active=false;settled=undefined;await renderComposer();await act(async()=>staleResolve())
 check(!document.querySelector('[data-composer-approval]')&&settled===undefined,'session switch unmounts old request and ignores its late result')
 active=true;stopFails=true;await renderComposer();await act(async()=>click('.wb-composer__approval-stop'))
 check(document.querySelector('[data-composer-approval] [role="alert"]')?.textContent?.includes('stop fixture failed'),'failed cancellation visible in approval surface')
 request='request-2';stopFails=false;await renderComposer()
 check(!document.querySelector('[data-composer-approval] [role="alert"]'),'next request clears previous cancellation failure')
 await act(async()=>click('.wb-composer__approval-stop'))
 check(!document.querySelector('[data-composer-approval] [role="alert"]'),'cancellation retry clears error')
 check(stops===2,'stop remains reachable independently of normal send')
 stopPending=true;await renderComposer();await act(async()=>click('.wb-composer__approval-stop'))
 check(document.querySelector<HTMLButtonElement>('.wb-composer__approval-stop')?.disabled,'pending stop disabled against duplicate cancellation')
 request='request-3';stopPending=false;await renderComposer();await act(async()=>rejectStop(new Error('obsolete stop failure')))
 check(!document.querySelector('[data-composer-approval] [role="alert"]')&&!document.querySelector<HTMLButtonElement>('.wb-composer__approval-stop')?.disabled,'late previous-request cancellation cannot alter new request')
 active=false;await renderComposer();check(!document.querySelector('[data-composer-approval]'),'cancelled interaction restores ordinary input')
 // An upload already started before takeover must finish into the same draft without stealing focus.
 let uploaded: typeof attachments=[], stagingResolve!: (value: typeof attachments[number])=>void, uploadActive=false
 const uploadHost={pick:async()=>[],stage:()=>new Promise<typeof attachments[number]>(yes=>{stagingResolve=yes})}
 const renderUpload=()=>act(async()=>root.render(<ComposerControls key="upload-session" sessionId="upload-session" value="upload draft" onChange={()=>{}} onSend={()=>{sends++}}
   attachments={uploaded} onAttachmentsChange={items=>{uploaded=items}} attachmentHost={uploadHost}
   approvalKey="upload-approval" approvalSlot={uploadActive?<PermissionConfirm pendingId="upload-approval" toolName="Bash" options={options} resolve={pending} reject={async()=>{}}/>:undefined}/>))
 await renderUpload()
 const drop=new Event('drop',{bubbles:true,cancelable:true})
 Object.defineProperty(drop,'dataTransfer',{value:{files:[new File(['fixture'],'upload.txt',{type:'text/plain'})],types:[],getData:()=>''}})
 await act(async()=>{document.querySelector('.wb-composer')!.dispatchEvent(drop);await new Promise(yes=>setTimeout(yes,30))})
 check(typeof stagingResolve==='function','attachment staging started before takeover')
 uploadActive=true;await renderUpload()
 await act(async()=>stagingResolve({id:'uploaded',name:'upload.txt',mimeType:'text/plain',size:7}))
 await renderUpload()
 check(uploaded.length===1,'in-flight attachment preserved in owning draft during approval')
 check(!document.querySelector('.conversation-input-area__input-stack')!.contains(document.activeElement),'upload completion does not focus hidden editor')
 uploadActive=false;await renderUpload()
 check(document.querySelector('.conversation-input-area__input-stack')?.textContent?.includes('upload.txt'),'completed attachment restored after approval')
 await act(async()=>root.unmount());dom.window.close()
 console.log(`Permission intercept DOM: ${checks} checks passed (not pixel/SDK verification)`)
 process.exit(0)
}
main().catch(error=>{console.error(error);process.exit(1)})