import crypto from 'node:crypto';
import fs from 'node:fs';
import assert from 'node:assert/strict';
import vm from 'node:vm';
const root=new URL('../',import.meta.url),read=p=>fs.readFileSync(new URL(p,root),'utf8');
const g=JSON.parse(read('graph.json'));
const kinds=new Set(['corpus_evidence','reconstruction','retrospective_connection','model_proposed']);
const byId=rows=>{assert.equal(new Set(rows.map(x=>x.id)).size,rows.length);return new Map(rows.map(x=>[x.id,x]));};
const N=byId(g.nodes),E=byId(g.evidence),R=byId(g.regions);byId(g.edges);byId(g.paths);byId(g.transformations);byId(g.revisions);
const refs=xs=>{assert.ok(Array.isArray(xs)&&xs.length);xs.forEach(id=>assert.ok(E.has(id),'Missing evidence '+id));};
for(const n of g.nodes){
 assert.match(n.id,/^[a-z0-9][a-z0-9-]+$/);assert.equal(n.epistemic_kind,'reconstruction');assert.equal(n.formal_status,'open_problem');refs(n.evidence);
 for(const k of ['title','question','formulation','tension','challenge'])assert.ok(typeof n[k]==='string'&&n[k].length>8);
 assert.ok(n.representations.length>=2);n.representations.forEach(r=>{assert.ok(r.name&&r.affords&&r.loses);assert.equal(r.epistemic_kind,'reconstruction');});
 assert.equal(n.next_move.epistemic_kind,'model_proposed');assert.ok(n.next_move.text);
 for(const id of n.regions){assert.ok(R.has(id));assert.ok(R.get(id).nodes.includes(n.id));}
}
for(const e of g.evidence){assert.equal(e.epistemic_kind,'corpus_evidence');assert.equal(e.rendering,'editorial_paraphrase');assert.ok(e.statement&&e.scope);}
for(const e of g.edges){assert.ok(N.has(e.from)&&N.has(e.to));assert.notEqual(e.from,e.to);assert.ok(kinds.has(e.epistemic_kind));assert.ok(e.warrant.length>20);refs(e.evidence);}
for(const p of g.paths){assert.equal(p.kind,'suggested_reading_route');assert.equal(p.epistemic_kind,'model_proposed');assert.ok(p.steps.length>=2);p.steps.forEach(s=>assert.ok(N.has(s.node)&&s.reason));}
for(const t of g.transformations){assert.ok(N.has(t.node)&&t.operation&&t.validation_status);assert.ok(t.candidate_invariants.length&&t.possible_losses.length);refs(t.evidence);}
for(const r of g.revisions){r.nodes.forEach(id=>assert.ok(N.has(id)));assert.ok(r.unresolved);r.stages.forEach(s=>refs(s.evidence));}
for(const r of g.regions){
 r.nodes.forEach(id=>assert.ok(N.has(id)&&N.get(id).regions.includes(r.id)));
 const s=JSON.parse(read('subgraphs/'+r.id+'.json')),ids=new Set(r.nodes);
 assert.deepEqual(s.nodes,r.nodes.map(id=>N.get(id)));
 assert.deepEqual(s.internal_relations,g.edges.filter(e=>ids.has(e.from)&&ids.has(e.to)));
 assert.deepEqual(s.boundary_relations,g.edges.filter(e=>ids.has(e.from)!==ids.has(e.to)));
 s.evidence.forEach(e=>assert.deepEqual(e,E.get(e.id)));
}
for(const [name,key] of Object.entries({problems:'nodes',relations:'edges',evidence:'evidence',paths:'paths',transformations:'transformations',revisions:'revisions',challenges:'challenge_index'})){
 assert.deepEqual(read('data/'+name+'.jsonl').trim().split('\n').map(JSON.parse),g[key]);
}
const ctx={window:{}};vm.runInNewContext(read('graph-data.js'),ctx);assert.equal(JSON.stringify(ctx.window.RESEARCH_GRAPH),JSON.stringify(g));
for(const n of g.nodes){const doc=read('problems/'+n.id+'.md');assert.ok(doc.includes(n.question)&&doc.includes(n.formulation));}
const visited=new Set();let components=0;for(const id of N.keys()){if(visited.has(id))continue;components++;const q=[id];visited.add(id);for(let i=0;i<q.length;i++)for(const e of g.edges){const next=e.from===q[i]?e.to:e.to===q[i]?e.from:null;if(next&&!visited.has(next)){visited.add(next);q.push(next);}}}
console.log(JSON.stringify({valid:true,version:g.version,problems:N.size,relations:g.edges.length,evidence:E.size,regions:R.size,paths:g.paths.length,transformations:g.transformations.length,revisions:g.revisions.length,components,scope:'Structural integrity and consistency, not source truth or completeness.'},null,2));

const D=byId(g.documents||[]),S=byId(g.document_sections||[]);byId(g.document_links||[]);
for(const d of D.values()){
 assert.equal(d.language,'en');assert.ok(kinds.has(d.epistemic_kind));assert.equal(read(d.path),d.markdown);
 assert.equal(crypto.createHash('sha256').update(d.markdown).digest('hex'),d.sha256);
 d.linked_nodes.forEach(id=>assert.ok(N.has(id)));d.context_evidence.forEach(id=>assert.ok(E.has(id)));
 const own=g.document_sections.filter(s=>s.document===d.id);assert.deepEqual(own.map(s=>s.id),d.section_ids);
 assert.deepEqual(own.map(s=>s.order),own.map((_,i)=>i+1));
 for(const s of own){assert.ok(d.markdown.includes(s.markdown));assert.ok(s.markdown.startsWith('## '+s.title));}
}
for(const l of g.document_links||[]){assert.ok(D.has(l.document)&&N.has(l.node));assert.ok(kinds.has(l.epistemic_kind));}
for(const key of ['documents','document_sections','document_links'])assert.deepEqual(read('data/'+key+'.jsonl').trim().split('\n').map(JSON.parse),g[key]);
console.log(JSON.stringify({documents:D.size,document_sections:S.size,document_links:g.document_links.length,document_validation:true}));