import assert from 'node:assert/strict';
import {spawnSync} from 'node:child_process';
import {cpSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync} from 'node:fs';
import {join, relative, resolve} from 'node:path';
import {hashAt} from './boot-contract-report.mjs';

assert.equal(process.argv.length, 3,
  'usage: node scripts/os-acceptance/shared-memory-ring.mjs <K1375-matrix-report.json>');
const root = process.cwd();
const predecessorPath = relative(root, resolve(process.argv[2]));
assert.match(predecessorPath,
  /^reports\/os-implementation\/K1375-lifetime-el0-matrix-check-[A-Za-z0-9_-]+\/report\.json$/);
const predecessor = JSON.parse(readFileSync(join(root, predecessorPath), 'utf8'));
assert.equal(predecessor.status, 'K1375_LIFETIME_EL0_DEVELOPMENT_MATRIX_VALIDATED');
assert.equal(predecessor.guestAccepted, true);
const directory = mkdtempSync(join(root,
  'reports/os-implementation/K1380-shared-memory-ring-local-preflight-'));
const workspace = join(directory, 'workspace');
const source = 'os-shared-memory/src/ring.rs';
const tests = 'kernel/tests/os/shared_memory_ring.rs';
mkdirSync(join(workspace, 'os-shared-memory/src'), {recursive: true});
mkdirSync(join(workspace, 'kernel/tests/os'), {recursive: true});
cpSync(join(root, source), join(workspace, source));
cpSync(join(root, tests), join(workspace, tests));
const artifact = path => ({path: relative(root, path),
  sha256: hashAt(root, relative(root, path))});
const run = (name, command, args) => {
  const answer = spawnSync(command, args, {cwd: root, encoding: 'utf8',
    timeout: 600000, maxBuffer: 64 * 1024 * 1024});
  const log = join(directory, name + '.log');
  writeFileSync(log, (answer.stdout ?? '') + (answer.stderr ?? ''));
  return {exitCode: answer.status, error: answer.error?.message ?? null,
    log: artifact(log)};
};
const binary = join(directory, 'shared-memory-ring-test');
const compile = run('host-compile', 'rustc', ['--edition=2024', '--test',
  join(workspace, tests), '-o', binary]);
assert.equal(compile.exitCode, 0,
  readFileSync(join(root, compile.log.path), 'utf8'));
const green = run('host-tests', binary, ['--nocapture']);
const greenText = readFileSync(join(root, green.log.path), 'utf8');
assert.equal(green.exitCode, 0, greenText);
for (const name of ['os_shared_memory_ring_positive',
  'os_shared_memory_ring_negative',
  'ring_full_and_empty_boundaries_are_atomic'])
  assert.match(greenText, new RegExp(`test ${name} \\.\\.\\. ok`));
assert.match(greenText, /3 passed; 0 failed/);

const wrapper = join(workspace, 'os-shared-memory/src/no_std_check.rs');
writeFileSync(wrapper, '#![no_std]\n#[path = "ring.rs"]\nmod ring;\n');
const target = run('aarch64-no-std-check', 'rustc', ['--edition=2024',
  '--crate-type=lib', '--target=aarch64-unknown-none', '--emit=metadata',
  wrapper, '-o', join(directory, 'shared-memory-ring-aarch64.rmeta')]);
assert.equal(target.exitCode, 0,
  readFileSync(join(root, target.log.path), 'utf8'));

const copiedSource = join(workspace, source);
const original = readFileSync(copiedSource, 'utf8');
const guard = 'if distance > CAPACITY as u64 { return Err(Error::Invalid); }';
assert.equal(original.split(guard).length, 2);
writeFileSync(copiedSource, original.replace(guard,
  'if false { return Err(Error::Invalid); }'));
const mutantCompile = run('unauthorized-acquire-mutant-compile', 'rustc',
  ['--edition=2024', '--test', join(workspace, tests),
    '-o', join(directory, 'shared-memory-ring-mutant-test')]);
assert.equal(mutantCompile.exitCode, 0,
  readFileSync(join(root, mutantCompile.log.path), 'utf8'));
const red = run('unauthorized-acquire-mutant',
  join(directory, 'shared-memory-ring-mutant-test'),
  ['os_shared_memory_ring_negative', '--exact', '--nocapture']);
const redText = readFileSync(join(root, red.log.path), 'utf8');
assert.notEqual(red.exitCode, 0);
assert.match(redText, /os_shared_memory_ring_negative \.\.\. FAILED/);
writeFileSync(copiedSource, original);

const report = {schema: 'turkos-k1380-shared-memory-ring-local-preflight/v1',
  status: 'K1376_K1379_LOCAL_VALIDATED',
  guestAccepted: false, productAccepted: false,
  predecessor: artifact(join(root, predecessorPath)),
  sources: {contract: artifact(join(root,
    'os-shared-memory/RING_CONTRACT.md')),
  model: artifact(join(root, source)), tests: artifact(join(root, tests)),
  harness: artifact(join(root, 'scripts/os-acceptance/shared-memory-ring.mjs'))},
  tests: {compile, green, target, mutantCompile, red,
    greenCount: 3, mutationRejected: true},
  scope: 'Local sixteen-slot shared user ring model: one thousand messages preserve producer-consumer order, full and empty boundaries are atomic, and corrupt or stale producer indexes are rejected before slot access without changing slots or the kernel canary. Three host tests, an AArch64 no_std build and a rejected index-guard mutant are checked. Native EL0 six-profile integration remains K1380.'};
const reportPath = join(directory, 'report.json');
writeFileSync(reportPath, JSON.stringify(report, null, 2) + '\n');
console.log(JSON.stringify({status: report.status,
  report: relative(root, reportPath), green: report.tests.greenCount}));