"use client";
import {useEffect,useRef,useState} from 'react';
import type {CadSource} from '../../cad-features/index.mjs';
import type {SourceRecoveryRequest,SourceTarget} from '../../independent-slot-source/index.mjs';
import type {PrepareSlotReviewResult} from '../../slot-review/index.mjs';
import type {ClearancePlanRequest,ClearancePlanResult} from '../../slot-review/clearance-plan.mjs';
import type {ReviewedSlotGoal} from '../../independent-slot-check/transaction.mjs';
import type {SlotEvidenceWorkerOutcome} from '../../independent-slot-check/evidence-worker-client.mjs';
import {hashReviewedGoal,runSlotWork,testSlotBytes} from './slot-session';
import './slot-panel.css';

type Prepared=Extract<PrepareSlotReviewResult,{status:'prepared'}>;
type Plan=Extract<ClearancePlanResult,{status:'candidate'}>;
type Point=[number,number,number];
type Field=[string,string,string?];
const setupFields:Field[]=[['origin','Origin in source XYZ (mm)','0, 0, 0'],['x','Setup X axis','1, 0, 0'],['y','Setup Y axis','0, 1, 0'],['z','Setup Z axis','0, 0, 1'],['initial','Initial tool-tip XYZ (mm)'],['stockMin','Stock minimum XYZ (mm)'],['stockMax','Stock maximum XYZ (mm)']];
const toolFields:Field[]=[['radius','Cutter radius (mm)'],['flute','Flute length (mm)'],['shankRadius','Shank radius (mm)'],['shankLength','Shank length (mm)'],['uncertainty','Declared uncertainty (mm)'],['clearance','Fixture clearance (mm)']];
const permissionFields:Field[]=[['remainingRadial','Permitted radial stock remaining (mm)'],['overcut','Permitted wall overcut (mm)'],['remainingAxial','Permitted axial stock remaining (mm)'],['entryExtension','Entry envelope extension (mm)'],['exitExtension','Exit envelope extension (mm)'],['breakthrough','Required breakthrough (mm)'],['feedMin','Reviewed minimum feed (mm/min)'],['feedMax','Reviewed maximum feed (mm/min)'],['plungeMax','Reviewed maximum plunge (mm/min)'],['rpmMin','Reviewed minimum spindle (rpm)'],['rpmMax','Reviewed maximum spindle (rpm)']];
const processFields:Field[]=[['rpm','Spindle speed (rpm)'],['feed','Cut feed (mm/min)'],['plunge','Plunge feed (mm/min)'],['stepdown','Maximum stepdown (mm)'],['stepover','Maximum stepover (mm)'],['roughStock','Rough wall stock (mm)'],['finalStock','Final wall stock (mm)'],['safeZ','Safe tool-tip Z (mm)'],['approach','Approach clearance (mm)']];
const labels=new Map([...setupFields,...toolFields,...permissionFields,...processFields].map(([key,label])=>[key,label]));
const initialFields=()=>({x:'1, 0, 0',y:'0, 1, 0',z:'0, 0, 1',stockState:'raw',direction:'ccw',holders:'',fixtures:'[]'} as Record<string,string>);
const fmt=(value:number)=>Number(value.toFixed(6)).toString();
function numberField(fields:Record<string,string>,key:string){const text=fields[key]?.trim();if(!text||!/^[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i.test(text)||!Number.isFinite(Number(text)))throw new Error(`Enter ${labels.get(key)??key}.`);return Number(text);}
function point(fields:Record<string,string>,key:string):Point{const values=fields[key]?.split(',').map(s=>s.trim());if(!values||values.length!==3||values.some(v=>!v||!Number.isFinite(Number(v))))throw new Error(`Enter three comma-separated values for ${labels.get(key)}.`);return [Number(values[0]),Number(values[1]),Number(values[2])];}
function jsonField<T>(fields:Record<string,string>,key:string):T{try{if((fields[key]?.length??0)>32768)throw 0;return JSON.parse(fields[key]) as T;}catch{throw new Error(`Enter valid ${key} JSON using the shown shape.`);}}
function download(name:string,text:string,type='application/json'){const url=URL.createObjectURL(new Blob([text],{type})),a=document.createElement('a');a.href=url;a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);}

export default function SlotPanel({file,source,options,sourceSignal,onHighlight}:{file:File;source:CadSource;options:SourceRecoveryRequest['options'];sourceSignal:AbortSignal;onHighlight:(target:SourceTarget)=>void}){
  const [prepared,setPrepared]=useState<Prepared|null>(null),[selected,setSelected]=useState<Record<string,string>>({}),[fields,setFields]=useState(initialFields);
  const [review,setReview]=useState<{goal:ReviewedSlotGoal;sha256:string}|null>(null),[plan,setPlan]=useState<Plan|null>(null),[nc,setNc]=useState(''),[outcome,setOutcome]=useState<SlotEvidenceWorkerOutcome|null>(null);
  const [busy,setBusy]=useState(''),[error,setError]=useState(''),[confirmed,setConfirmed]=useState(false);
  const [feedbackStep,setFeedbackStep]=useState(1);
  const epoch=useRef(0),controller=useRef<AbortController|null>(null);
  useEffect(()=>{const abort=()=>{epoch.current++;controller.current?.abort();};sourceSignal.addEventListener('abort',abort,{once:true});if(sourceSignal.aborted)abort();return()=>{sourceSignal.removeEventListener('abort',abort);abort();};},[sourceSignal]);
  function invalidate(level:'review'|'plan'|'test'='review'){epoch.current++;controller.current?.abort();controller.current=null;setBusy('');setError('');setOutcome(null);if(level!=='test'){setPlan(null);setNc('');}if(level==='review'){setReview(null);setConfirmed(false);}}
  function edit(key:string,value:string,generation=false){invalidate(generation?'plan':'review');setFields(current=>({...current,[key]:value}));}
  function begin(label:string,step:number){epoch.current++;controller.current?.abort();const current=epoch.current,c=new AbortController();controller.current=c;setFeedbackStep(step);setBusy(label);setError('');setOutcome(null);return {current,c};}
  function finish(current:number){if(current===epoch.current){controller.current=null;setBusy('');}}
  async function prepare(){invalidate();setPrepared(null);setSelected({});const {current,c}=begin('Recovering exact slot targets from the original STEP…',1);try{const result=await runSlotWork(file,{kind:'prepare',request:{schema_version:'step-slot-source-request-0.1',source,options}},c.signal);if(current!==epoch.current)return;if(result.kind!=='prepare')throw new Error('Unexpected preparation response.');if(result.result.status!=='prepared')throw new Error(`Slot preparation: ${result.result.diagnostic}. This strategy needs closed paired openings in one exact mm solid.`);setPrepared(result.result);}catch(e){if(current===epoch.current)setError(e instanceof Error?e.message:'Slot preparation failed.');}finally{finish(current);}}
  function align(target:SourceTarget){const entrance=target.entrances.find(e=>e.face_id===selected[target.id]);if(!entrance){setFeedbackStep(1);setError('Select the entrance before aligning coordinates.');return;}const delta=entrance.cap_centers_mm[1].map((v,i)=>v-entrance.cap_centers_mm[0][i]),length=Math.hypot(...delta),x=delta.map(v=>v/length),z=entrance.outward_normal,y=[z[1]*x[2]-z[2]*x[1],z[2]*x[0]-z[0]*x[2],z[0]*x[1]-z[1]*x[0]];invalidate();setFields(current=>({...current,origin:entrance.cap_centers_mm[0].join(', '),x:x.join(', '),y:y.join(', '),z:z.join(', ')}));}
  async function reviewGoal(){
    if(!prepared||!confirmed)return;const {current,c}=begin('Binding reviewed declarations to this source…',2);
    try{
      const n=(key:string)=>numberField(fields,key),targets=prepared.source_report.targets.filter(target=>Object.hasOwn(selected,target.id));
      if(!targets.length||targets.length>16)throw new Error('Select between 1 and 16 supported slot targets.');
      const goal:ReviewedSlotGoal={schema_version:'reviewed-slot-goal-0.1',reviewed:true,source_sha256:source.sha256,source_byte_length:source.byte_length,source_namespace_sha256:prepared.source_report.namespace_sha256,
        setup:{origin_source_mm:point(fields,'origin'),x_axis:point(fields,'x'),y_axis:point(fields,'y'),z_axis:point(fields,'z')},initial_tip_mm:point(fields,'initial'),stock:{min_mm:point(fields,'stockMin'),max_mm:point(fields,'stockMax'),state:fields.stockState==='intermediate'?'intermediate':'raw'},
        tool:{kind:'flat_end_mill',radius_mm:n('radius'),flute_length_mm:n('flute'),shank_radius_mm:n('shankRadius'),shank_length_mm:n('shankLength'),holder_segments:jsonField(fields,'holders'),center_cutting:true},fixtures:{reviewed:true,boxes:jsonField(fields,'fixtures')},uncertainty_mm:n('uncertainty'),clearance_mm:n('clearance'),
        process:{feed_min_mm_min:n('feedMin'),feed_max_mm_min:n('feedMax'),plunge_max_mm_min:n('plungeMax'),spindle_min_rpm:n('rpmMin'),spindle_max_rpm:n('rpmMax')},
        targets:targets.map(target=>{const entry=target.entrances.find(e=>e.face_id===selected[target.id]),mapping=prepared.correspondences.find(m=>m.source_target_id===target.id);if(!entry||mapping?.status!=='unique'||!mapping.entries.some(e=>e.entry_face_id===entry.face_id))throw new Error(`Select a supported entrance for ${target.id}.`);return{id:'goal-'+target.id,face_ids:[...target.face_ids],entry_face_id:entry.face_id,permissions:{remaining_radial_mm:n('remainingRadial'),wall_overcut_mm:n('overcut'),remaining_axial_mm:n('remainingAxial'),entry_extension_mm:n('entryExtension'),exit_extension_mm:n('exitExtension'),breakthrough_mm:n('breakthrough')}};})};
      const sha256=await hashReviewedGoal(goal,c.signal);if(current!==epoch.current)return;setReview({goal,sha256});setPlan(null);setNc('');
    }catch(e){if(current===epoch.current)setError(e instanceof Error?e.message:'Goal review failed.');}finally{finish(current);}
  }
  async function generate(){if(!review)return;const {current,c}=begin('Generating a stock-retaining slot candidate…',3);setPlan(null);setNc('');try{const n=(key:string)=>numberField(fields,key),request:ClearancePlanRequest={schema_version:'reviewed-slot-clearance-request-0.1',source,options,goal:review.goal,expected_goal_sha256:review.sha256,process:{spindle_rpm:n('rpm'),feed_mm_min:n('feed'),plunge_mm_min:n('plunge'),max_stepdown_mm:n('stepdown'),max_stepover_mm:n('stepover'),radial_allowance_mm:n('roughStock'),cut_direction:fields.direction==='cw'?'cw':'ccw',safe_z_mm:n('safeZ'),approach_clearance_mm:n('approach')},strategy:{final_wall_stock_mm:n('finalStock')}};
    const result=await runSlotWork(file,{kind:'plan',request},c.signal);if(current!==epoch.current)return;if(result.kind!=='plan')throw new Error('Unexpected generation response.');if(result.result.status!=='candidate')throw new Error(`Generation stopped at ${result.result.stage}: ${result.result.diagnostic}. Check setup, tool reach, stock and the independently reviewed limits; no limits were changed.`);setPlan(result.result);setNc(result.result.nc_text);
  }catch(e){if(current===epoch.current)setError(e instanceof Error?e.message:'Slot generation failed.');}finally{finish(current);}}
  async function test(){if(!plan)return;const {current,c}=begin('Checking final bytes: exit depth, material coverage and protected geometry…',4);try{const result=await testSlotBytes(file,plan.check_request,nc,c.signal);if(current!==epoch.current)return;setOutcome(result);}catch(e){if(current===epoch.current)setError(e instanceof Error?e.message:'Independent slot test failed.');}finally{finish(current);}}
  const inputs=(rows:Field[],generation=false)=><div className="slot-fields">{rows.map(([key,label,placeholder])=><label key={key}>{label}<input value={fields[key]??''} placeholder={placeholder} onChange={e=>edit(key,e.target.value,generation)}/></label>)}</div>;
  const bundle=outcome?.status==='completed'?outcome.bundle:null,full=bundle?.slot_check,exit=bundle?.exit_depth;
  const feedback=(step:number)=>feedbackStep===step&&<>{busy&&<div role="status" className="slot-progress"><span>{busy}</span><button onClick={()=>invalidate('test')}>Cancel slot work</button><small>60-second limit; an incomplete check is never accepted as a pass.</small></div>}{error&&<p role="alert" className="slot-error">{error}</p>}</>;
  return <section id="slot-plan" className="slot-panel" aria-label="Reviewed slot machining"><header><div><h2>Reviewed slot machining</h2><p>Exact paired openings · one declared setup · compact virtual G/M code</p></div><span className="slot-boundary">Selected operations only</span></header>
    <p>Original STEP stays in this browser. Declare the stock and tool assembly; review the intended removal before generating. This does not machine the whole part or qualify a controller.</p>
    <button onClick={()=>void prepare()} disabled={!!busy}>Find supported slot targets</button>
    {feedback(1)}
    {prepared&&<><h3>1. Select the intended removal</h3><p>{prepared.source_report.targets.length} recovered target(s); {prepared.source_report.inventory.unresolved_face_ids.length} other face(s) remain outside this strategy. Highlighting geometry does not select an operation.</p>
      <div className="slot-targets">{prepared.source_report.targets.map(target=>{const mapping=prepared.correspondences.find(m=>m.source_target_id===target.id),chosen=Object.hasOwn(selected,target.id);return <article key={target.id}><label><input type="checkbox" disabled={mapping?.status!=='unique'} checked={chosen} onChange={e=>{invalidate();setSelected(current=>{const next={...current};if(e.target.checked)next[target.id]='';else delete next[target.id];return next;});}}/>{target.id} · width {fmt(2*target.radius_mm)} × length {fmt(target.center_spacing_mm+2*target.radius_mm)} mm</label><p>Local thickness {fmt(target.plane_separation_mm)} mm</p><button onClick={()=>onHighlight(target)}>Highlight {target.id}</button>{chosen&&<><label>Entrance for {target.id}<select value={selected[target.id]} onChange={e=>{invalidate();setSelected(current=>({...current,[target.id]:e.target.value}));}}><option value="">Choose an entrance</option>{target.entrances.map(entry=><option key={entry.face_id} value={entry.face_id}>{entry.face_id} · normal {entry.outward_normal.map(fmt).join(', ')}</option>)}</select></label><button onClick={()=>align(target)}>Align coordinates to this entrance</button></>}{mapping?.status!=='unique'&&<p>Complete source correspondence unavailable. Not selectable.</p>}</article>;})}</div>
      <h3>2. Declare and review the setup</h3><p>Coordinates below use the declared local frame. A source-derived alignment is only a coordinate suggestion. Stock is not inferred from finished-part bounds.</p>
      <details open><summary>Coordinate frame and positioned stock</summary>{inputs(setupFields)}<label>Stock state<select aria-label="Stock state" value={fields.stockState} onChange={e=>edit('stockState',e.target.value)}><option value="raw">Raw</option><option value="intermediate">Intermediate</option></select></label></details>
      <details><summary>Complete tool and fixtures</summary>{inputs(toolFields)}<label>Holder segments (local tool-tip coordinates, mm)<textarea aria-label="Holder segments (local tool-tip coordinates, mm)" value={fields.holders} placeholder={'[{"radius_mm":3,"z_min_mm":11,"z_max_mm":15}]'} onChange={e=>edit('holders',e.target.value)}/></label><label>Reviewed fixture boxes (local setup coordinates, mm)<textarea aria-label="Reviewed fixture boxes (local setup coordinates, mm)" value={fields.fixtures} onChange={e=>edit('fixtures',e.target.value)}/></label><p>Box shape: {`{"id":"clamp-1","min_mm":[x,y,z],"max_mm":[x,y,z]}`}. Empty [] explicitly declares no fixture boxes in this virtual test; it does not establish physical clearance. The cutter must be a centre-cutting flat end mill.</p></details>
      <details><summary>Removal permissions and independent process limits</summary>{inputs(permissionFields)}<p>The same permissions apply to every selected slot. These limits remain unchanged when final code is tested.</p></details>
      <label className="slot-confirm"><input type="checkbox" checked={confirmed} onChange={e=>{invalidate();setConfirmed(e.target.checked);}}/>I reviewed the selected entrances, stock, full tool, fixture declarations and removal limits for this virtual setup.</label><button disabled={!confirmed||!!busy} onClick={()=>void reviewGoal()}>Bind reviewed goal</button>{feedback(2)}{review&&<p role="status">Reviewed goal bound before generation: <code>{review.sha256}</code></p>}
      <h3>3. Generate the candidate</h3>{inputs(processFields,true)}<label>Cut direction<select aria-label="Cut direction" value={fields.direction} onChange={e=>edit('direction',e.target.value,true)}><option value="ccw">Counterclockwise</option><option value="cw">Clockwise</option></select></label><p>Rough wall stock, final wall stock and permitted residual are distinct. Invalid combinations or inaccessible setups are rejected.</p><button className="depth-primary" disabled={!review||!!busy} onClick={()=>void generate()}>Generate reviewed slot G/M code</button>
      {feedback(3)}
      {plan&&<><p>Generated baseline: {plan.counts.motions} motions · {plan.counts.nc_bytes} bytes · {plan.operations.length} selected operations.</p><p>{nc===plan.nc_text?'Current code matches the generated baseline.':'Current code has been edited; baseline counts do not describe these bytes.'} {bundle?'Independent evidence for the current bytes is shown below.':'Current bytes have no retained independent evidence; run the test.'}</p><label>Final slot NC<textarea aria-label="Final slot NC" className="slot-nc" spellCheck={false} value={nc} onChange={e=>{invalidate('test');setNc(e.target.value);}}/></label><div className="slot-actions"><button onClick={()=>download('reviewed-slots-virtual.nc',nc,'text/plain')}>Download current virtual NC</button><button onClick={()=>{invalidate('test');setNc(plan.nc_text);}}>Restore generated NC</button></div><h3>4. Independently test final bytes</h3><p>The original source and reviewed goal are recovered again. Two checks inspect the actual final code; editing it clears prior evidence. Complex cases may hit the fixed deadline.</p><button disabled={!!busy||!nc.trim()} onClick={()=>void test()}>Run independent slot test</button>{feedback(4)}</>}
      {bundle&&<p role="status">Independent checks returned evidence. Exit depth: {exit?.assessment}. Full geometry: {full?.assessment}, {full?.execution}. Not machine approval.</p>}
      {outcome&&outcome.status!=='completed'&&<p role="status">Test {outcome.status}: {outcome.reason}. No evidence bundle retained.</p>}
      {bundle&&<section className="slot-evidence" aria-label="Independent slot evidence"><h3>Independent evidence — not machine approval</h3><dl><dt>Exit-depth check</dt><dd>{exit?.assessment} · {exit?.violations.length??0} retained violation(s){exit?.diagnostic?` · ${exit.diagnostic}`:''}</dd><dt>Full geometry check</dt><dd>{full?.assessment} · {full?.execution}{full?.diagnostic?` · ${full.diagnostic}`:''}</dd></dl>{full?.status==='evaluated'&&<><ul>{full.goals.map(goal=><li key={goal.goal_id}>{goal.goal_id}: {goal.bands.radial_coverage} · {goal.bands.radial_containment}</li>)}</ul><p>{full.checks.protected?.observations.length??0} protected-geometry observation(s). Whole-part completeness and controller qualification remain unproven.</p></>}<p>{full?.negative_findings.length??0} retained negative finding(s), including findings from incomplete checks.</p>{!!full?.negative_findings.length&&<ul>{full.negative_findings.slice(0,20).map((finding,index)=><li key={index}>{finding.stage}: {finding.kind}{finding.line!==null?' · line '+finding.line:''}{finding.goal_id?' · '+finding.goal_id:''}</li>)}</ul>}{(full?.negative_findings.length??0)>20&&<p>First 20 shown; download the report for all retained findings.</p>}<p>Machine release unavailable. A completed test means the software returned evidence, not that machining was approved.</p><button onClick={()=>download('slot-evidence.json',JSON.stringify({source,reviewed_goal:review?.goal,reviewed_goal_sha256:review?.sha256,nc_text:nc,bundle,machine_release:{eligible:false}},null,2))}>Download current slot evidence</button><details><summary>Exact test reports</summary><pre>{JSON.stringify(bundle,null,2)}</pre></details></section>}
    </>}
  </section>;
}