import test from 'node:test';
import assert from 'node:assert/strict';
import { execFileSync } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { upstream58e2204Operations } from '../src/upstream-58e2204.ts';

const PHASE_0_2_COMMIT='9dffadbec271227da7ffb192f31dc78c6ee3c2be';
const BASELINE_PATH='packages/operation-registry/src/upstream-58e2204.ts';
const repoRoot=fileURLToPath(new URL('../../../',import.meta.url));
const safetyFields=['operationId','riskLevel','confirmationPolicy','capability','executionPolicy'] as const;
type SafetyRow=Record<(typeof safetyFields)[number],string>;

function git(...args:string[]){return execFileSync('git',args,{cwd:repoRoot,encoding:'utf8',stdio:['ignore','pipe','pipe']}).trim();}

/** Parse only the JSON array literal assigned to the frozen raw operations constant; never evaluate TypeScript. */
export function parseFrozenSafetyBaseline(source:string):SafetyRow[]{
 const marker='const rawUpstream58e2204Operations = ';
 const start=source.indexOf('[',source.indexOf(marker)+marker.length);
 assert.ok(source.includes(marker)&&start>=0,'frozen operation array marker missing');
 let quoted=false,escaped=false,depth=0,end=-1;
 for(let i=start;i<source.length;i++){
  const ch=source[i];
  if(quoted){if(escaped)escaped=false;else if(ch==='\\')escaped=true;else if(ch==='"')quoted=false;continue;}
  if(ch==='"'){quoted=true;continue;}if(ch==='[')depth++;else if(ch===']'&&--depth===0){end=i+1;break;}
 }
 assert.ok(end>start,'unterminated frozen operation array');
 const parsed=JSON.parse(source.slice(start,end));
 assert.ok(Array.isArray(parsed),'frozen operation baseline is not an array');
 return parsed.map((row:any,index:number)=>Object.fromEntries(safetyFields.map(field=>{assert.equal(typeof row?.[field],'string',`baseline row ${index} missing ${field}`);return [field,row[field]];})) as SafetyRow);
}

export function assertExactSafetyBaseline(actual:readonly SafetyRow[],expected:readonly SafetyRow[]){
 assert.equal(expected.length,117,'independent baseline must contain exactly 117 operations');
 assert.equal(new Set(expected.map(x=>x.operationId)).size,117,'independent baseline operationIds must be unique');
 assert.equal(actual.length,117,'current Registry must contain exactly 117 operations');
 assert.equal(new Set(actual.map(x=>x.operationId)).size,117,'current Registry operationIds must be unique');
 const sort=(rows:readonly SafetyRow[])=>[...rows].sort((a,b)=>a.operationId.localeCompare(b.operationId));
 assert.deepEqual(sort(actual),sort(expected),'current Registry safety fields differ from frozen Phase 0.2 Git object; update requires explicit safety review');
}

const project=(rows:readonly any[]):SafetyRow[]=>rows.map(row=>Object.fromEntries(safetyFields.map(field=>[field,row[field]])) as SafetyRow);

test('independent Phase 0.2 Git object freezes all 117 Registry safety decisions',()=>{
 assert.equal(git('rev-parse','9dffadb'),PHASE_0_2_COMMIT);
 assert.equal(git('cat-file','-t',PHASE_0_2_COMMIT),'commit');
 const baseline=parseFrozenSafetyBaseline(git('show',`${PHASE_0_2_COMMIT}:${BASELINE_PATH}`));
 assertExactSafetyBaseline(project(upstream58e2204Operations),baseline);
});

test('independent safety comparison rejects risk, confirmation, capability and execution-policy mutations',()=>{
 const baseline=parseFrozenSafetyBaseline(git('show',`${PHASE_0_2_COMMIT}:${BASELINE_PATH}`));
 const mutations:[string,string,string][]=[
  ['postData','riskLevel','R0'],
  ['postSmsSend','confirmationPolicy','none'],
  ['postSmsSend','capability','query'],
  ['postSmsSend','executionPolicy','dedicatedFlow']
 ];
 for(const [operationId,field,value] of mutations){const current=structuredClone(project(upstream58e2204Operations));(current.find(x=>x.operationId===operationId)! as any)[field]=value;assert.throws(()=>assertExactSafetyBaseline(current,baseline),/safety fields differ/,`${operationId}:${field}`);}
});