import test from 'node:test';
import assert from 'node:assert/strict';
import {readFileSync,readdirSync} from 'node:fs';
import {createHash} from 'node:crypto';
const read=p=>readFileSync(p,'utf8');
const coverage=JSON.parse(read('research/ai-adoption/strategy-coverage.json')).routes;

test('connected Strategy covers every canonical route and reader handoff',()=>{
 const files=readdirSync('docs/strategy',{recursive:true}).filter(p=>p.endsWith('.mdx')).map(p=>'docs/strategy/'+p).sort();
 assert.equal(coverage.length,28);
 assert.deepEqual(coverage.map(r=>r.source).sort(),files);
 assert.equal(new Set(coverage.map(r=>r.route)).size,28);
 for(const r of coverage){
  for(const k of ['question','inputs','action_or_decision','output','next_or_feedback','review'])assert(r[k],`${r.source}: ${k}`);
  const page=read(r.source);assert(!/roadmap gates|Evidence-gated phases/.test(page),r.source);
  assert(coverage.some(n=>n.route===r.next_or_feedback),r.next_or_feedback);
  if(r.contract_sha256){
   const body=page.split('{/* contract:start */}\n')[1].split('\n{/* contract:end */}')[0];
   assert.equal(createHash('sha256').update(body).digest('hex'),r.contract_sha256,r.source);
  }
 }
 assert.equal(coverage.filter(r=>r.implementation==='prototype').length,9);
 assert.equal(coverage.filter(r=>r.implementation==='unimplemented').length,7);
});

test('the parent journey connects qualification, pilot authority and feedback without automatic autonomy',()=>{
 const parent=read('docs/strategy/stage-01-skills-adoption.mdx');
 for(const marker of ['illustrative Delivery','independent Quality Engineering reviewer','baseline describes work; it grants no approval','not six rigid sequential approval gates','Governance bounds every activity','separate case for authority and readiness'])assert(parent.toLowerCase().includes(marker.toLowerCase()),marker);
 const governance=read('docs/strategy/skills-governance.mdx');
 for(const marker of ['experimental → bounded pilot','bounded pilot → approved','Initial experimental qualification runs only in approved disposable environments','Real work requires a separate bounded-pilot authorization'])assert(governance.includes(marker),marker);
 assert(!governance.includes('| experimental → approved |'));
 assert(read('docs/strategy/skills-adoption.mdx').includes('pilot decision alone is not general approval'));
 const quality=read('docs/strategy/skills-quality.mdx');
 for(const marker of ['Qualification artifact success is not live task success','planned executed trials','matured real-workflow starts','regression against the currently approved revision'])assert(quality.includes(marker),marker);
 for(const id of ['measurement/index','skills-maintenance'])assert(read(`docs/strategy/${id}.mdx`).includes('skills-quality.mdx'));
 const future=read('docs/strategy/stage-02-autonomous-agent.mdx');
 for(const marker of ['separate authority decision','Unresolved release approval roles remain a hold condition','not deployed autonomy','stop/human-takeover','recorded hold'])assert(future.includes(marker),marker);
});

for(const stage of ['stage01','stage02'])test(`${stage}: native paired views preserve handoffs, decisions and containment`,()=>{
 const pair=['','-mobile'].map(s=>JSON.parse(read(`diagrams/strategy-${stage}${s}.architecture.json`)));
 const nodes=d=>d.components.map(({pos,size,...n})=>n);
 const relationships=d=>d.connections.map(({id,from,to,variant})=>({id,from,to,variant}));
 assert.deepEqual(nodes(pair[0]),nodes(pair[1]));
 assert.deepEqual(relationships(pair[0]),relationships(pair[1]));
 const expected=stage==='stage01'?[['baseline','engineer'],['engineer','qualify'],['qualify','pilot'],['pilot','decide'],['decide','maintain'],['maintain','engineer'],['decide','baseline']]:[['proven','case'],['case','decision'],['decision','execute'],['decision','hold'],['execute','stop'],['stop','hold']];
 assert.deepEqual(pair[0].connections.map(e=>[e.from,e.to]).sort(),expected.sort());
 const by=Object.fromEntries(pair[0].components.map(n=>[n.id,n]));
 if(stage==='stage01'){
  assert(by.qualify.sublabel.includes('Fail / incomplete: hold or rework'));
  assert(by.reference.tag.includes('Throughout'));
  assert(by.decide.sublabel.includes('Compare with baseline, not trials'));
 }else{
  assert(by.decision.sublabel.includes('Owning approver'));
  assert(by.stop.sublabel.includes('Revoke mutations'));
  assert(by.hold.sublabel.includes('No automatic progression'));
 }
});