#!/usr/bin/env node
// Proving v0 end to end on a private 3-node test network (spec 7.7, docs/plans/proving-v0.md): ports 29800 and up,
// network igneum-devnet-955, data under /tmp/igneum-proving-v0, infra/fast-time's 60x profile with
// skip_proof_of_work and proving_v0_activation_daa set. Three voting vmine producers (the proving build's
// igneum-miner) share 1 block/s; v0 names a funded EVM address. Node 0 verifies SP1 proofs with the real host
// (IGNEUM_PROOF_VERIFIER); nodes 1 and 2 run in trust mode, so the relay and the verifier are both exercised.
//
// Steps, each timed: wait for the activation DAA, send one transfer, export the chain and cut the fixture with
// igneum-prove-export, check the exporter's plan against the node's igneum_getShardPlan, prove the shard on the
// CPU with igneum-prove-host --mode compressed, sign the record with igneum-miner sign-record (v0's vote key),
// submit it to node 1, watch node 0 verify it, watch a block carry it, and check the payout address's balance.
// Never touches the live devnet (26610/26611, 26640/28640) or the fast-time simnet (29500+).
//
//   node tools/proving-v0/run.mjs [--secs 1500] [--activation 60] [--empty]   (--empty proves the newest empty segment instead)
//   node tools/proving-v0/run.mjs --network-only --secs 3600   (just the 3 nodes and the voters, for the app's prover loop; node 1
//                                                                p2p 127.0.0.1:29811 is the peer to give the app)

import { spawn, spawnSync } from 'node:child_process';
import { mkdirSync, rmSync, writeFileSync, readFileSync, openSync, existsSync } from 'node:fs';
import { connectRpc } from '../finality-attacks/lib/rpc.mjs';
import { privateKeyToAccount } from '../prove-fixtures/node_modules/viem/_esm/accounts/index.js';

const ROOT = new URL('../../', import.meta.url).pathname;
const FILE = `${ROOT}infra/fast-time/override-60x.json`;
const REL = process.env.IGNEUM_PROVING_BIN || `${ROOT}vendor/igneum-node-proving/target/release`;
const IGNEUMD = `${REL}/igneumd`;
const MINER = `${REL}/igneum-miner`;
const PROVE = process.env.IGNEUM_PROVE_BIN || `${ROOT}proving/igneum-prove/target/release`;
const HOST = `${PROVE}/igneum-prove-host`;
const EXPORT = `${PROVE}/igneum-prove-export`;
const TMP = '/tmp/igneum-proving-v0';
const BASE = 29800, SUFFIX = 955, CHAIN_NAME = `igneum-devnet-${SUFFIX}`, CHAIN_ID = 4463;
const args = process.argv.slice(2);
const flag = (name, dflt) => { const i = args.indexOf(name); return i >= 0 && args[i + 1] !== undefined ? +args[i + 1] : dflt; };
const SECS = flag('--secs', 1500);
const ACTIVATION = flag('--activation', 60);
const EMPTY = args.includes('--empty');
const NETWORK_ONLY = args.includes('--network-only');
const started = [];
const t0 = Date.now();
const since = () => ((Date.now() - t0) / 1000).toFixed(1);
const log = (...a) => console.log(new Date().toISOString().slice(11, 23), `t=${since()}s`, ...a);
const sleep = (ms) => new Promise(r => setTimeout(r, ms));
for (const b of [IGNEUMD, MINER, HOST, EXPORT]) if (!existsSync(b)) { console.error(`missing ${b}`); process.exit(2); }

// the funded account: v0's payout address (a throwaway key from tools/prove-fixtures/gen.mjs)
const funded = privateKeyToAccount('0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d');
const PAYOUT = '0x4242424242424242424242424242424242424242';

rmSync(TMP, { recursive: true, force: true }); mkdirSync(TMP, { recursive: true });
const override = `${TMP}/override.json`;
// text edits, not JSON.parse: the file carries u64::MAX values that JavaScript numbers cannot hold
const overrideText = readFileSync(FILE, 'utf8')
  .replace(/"proving_v0_activation_daa":\s*\d+/, `"proving_v0_activation_daa": ${ACTIVATION}`)
  .replace(/"skip_proof_of_work":\s*(true|false)/, '"skip_proof_of_work": true');
if (!/"skip_proof_of_work": true/.test(overrideText) || !new RegExp(`"proving_v0_activation_daa": ${ACTIVATION}`).test(overrideText)) throw new Error('override edit failed');
writeFileSync(override, overrideText);

class Node {
  constructor(i, connect = [], env = {}) {
    this.i = i; this.grpcPort = BASE + i * 10; this.p2pPort = BASE + i * 10 + 1; this.jsonPort = BASE + i * 10 + 2; this.evmPort = BASE + i * 10 + 3;
    this.connect = connect; this.env = env; this.dir = `${TMP}/n${i}`; this.logFile = `${this.dir}/node.log`;
  }
  get grpc() { return `grpc://127.0.0.1:${this.grpcPort}`; }
  get evm() { return `http://127.0.0.1:${this.evmPort}`; }
  async start() {
    mkdirSync(this.dir, { recursive: true });
    const a = ['--devnet', `--devnet-suffix=${SUFFIX}`, '--nodnsseed', '--disable-upnp', '--nologfiles', '--enable-unsynced-mining', '--utxoindex', '--unsaferpc',
      `--appdir=${this.dir}`, `--rpclisten=127.0.0.1:${this.grpcPort}`, `--rpclisten-json=127.0.0.1:${this.jsonPort}`, `--evm-rpclisten=127.0.0.1:${this.evmPort}`,
      `--listen=127.0.0.1:${this.p2pPort}`, `--override-params-file=${override}`, '--loglevel=info', '--yes'];
    if (this.connect.length) a.push(...this.connect.map(c => `--connect=${c}`)); else a.push('--outpeers=0');
    const out = openSync(this.logFile, 'a');
    this.proc = spawn(IGNEUMD, a, { stdio: ['ignore', out, out], env: { ...process.env, ...this.env } });
    started.push(this.proc);
    await sleep(800);
    this.rpc = await connectRpc(`ws://127.0.0.1:${this.jsonPort}`);
    log(`n${this.i} up pid ${this.proc.pid} json ${this.jsonPort} evm ${this.evmPort} p2p ${this.p2pPort} env ${JSON.stringify(this.env)}`);
    return this;
  }
  async eth(method, params = []) {
    const r = await fetch(this.evm, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }) });
    const j = await r.json();
    if (j.error) throw new Error(`${method}: ${j.error.message}`);
    return j.result;
  }
  grepLog(re) { try { return readFileSync(this.logFile, 'utf8').split('\n').filter(l => re.test(l)); } catch { return []; } }
}
function miner(argv, name) {
  const out = openSync(`${TMP}/${name}.log`, 'a');
  const p = spawn(MINER, argv, { stdio: ['ignore', out, out] });
  started.push(p);
  return p;
}
async function stopAll() {
  for (const p of started.reverse()) { try { p.kill('SIGINT'); } catch { } }
  await sleep(1500);
  for (const p of started) { try { p.kill('SIGKILL'); } catch { } }
}
process.on('SIGINT', async () => { await stopAll(); process.exit(130); });
const report = { activation: ACTIVATION, steps: {} };
const step = (k, v) => { report.steps[k] = v; log(`STEP ${k}: ${JSON.stringify(v)}`); };
function run(cmd, argv, env = {}) {
  const t = Date.now();
  const r = spawnSync(cmd, argv, { encoding: 'utf8', maxBuffer: 1 << 28, env: { ...process.env, ...env } });
  return { code: r.status, out: (r.stdout || '') + (r.stderr || ''), secs: (Date.now() - t) / 1000 };
}

try {
  const n0 = await new Node(0, [], { IGNEUM_PROOF_VERIFIER: HOST, SP1_PROVER: 'cpu' }).start();
  const n1 = await new Node(1, [`127.0.0.1:${n0.p2pPort}`], { IGNEUM_PROOF_VERIFY: 'trust' }).start();
  const n2 = await new Node(2, [`127.0.0.1:${n0.p2pPort}`, `127.0.0.1:${n1.p2pPort}`], { IGNEUM_PROOF_VERIFY: 'trust' }).start();
  const nodes = [n0, n1, n2];
  log(`node 0 says: ${n0.grepLog(/Proving v0|proving v0/).join(' | ') || '(no proving line)'}`);

  // three voters sharing 1 block/s; v0 pays the funded account
  nodes.forEach((n, i) => miner(['vmine', n.grpc, String(SECS), '--label', `v${i}`, '--share', String(1 / 3), '--bps', '1', ...(i === 0 ? ['--evm-address', funded.address] : [])], `vmine-v${i}`));
  const keyHashes = [];
  for (let i = 0; i < 3; i++) {
    for (let k = 0; k < 50 && !keyHashes[i]; k++) { const m = (() => { try { return readFileSync(`${TMP}/vmine-v${i}.log`, 'utf8').match(/key=([0-9a-f]{64})/); } catch { return null; } })(); if (m) keyHashes[i] = '0x' + m[1]; else await sleep(200); }
  }
  log(`vote keys: ${keyHashes.join(' ')}`);
  const status0 = await n0.eth('igneum_getProvingStatus');
  log(`proving status n0: ${JSON.stringify(status0)}`);
  step('status', { activationDaa: status0.activationDaa, verifier: status0.verifier });
  if (NETWORK_ONLY) {
    log(`network only: 3 nodes up for ${SECS} s; peer for the app: 127.0.0.1:${n1.p2pPort}; EVM RPC n0 ${n0.evm}`);
    while (Date.now() - t0 < SECS * 1000) {
      await sleep(15000);
      const s = await n0.eth('igneum_getProvingStatus').catch(() => null);
      if (s) log(`daa ${parseInt(s.tipDaa, 16)} active=${s.active} pool=${JSON.stringify(s.pool)} paidShards=${s.paidShards}`);
    }
    report.ok = true;
    throw new Error('network-only run finished');
  }

  // 1. wait for the activation DAA (plus a margin: the sortition window needs dust blocks per key)
  let daa = 0;
  while (daa < ACTIVATION + 5) {
    await sleep(2000);
    const s = await n0.eth('igneum_getProvingStatus');
    daa = parseInt(s.tipDaa, 16);
    if (Math.round(+since()) % 10 === 0) log(`daa ${daa} active=${s.active} pool=${JSON.stringify(s.pool)}`);
  }
  step('activation', { daa, secs: +since() });

  // 2. a transfer from the funded account, so a segment has one transaction
  const balance = BigInt(await n0.eth('eth_getBalance', [funded.address, 'latest']));
  log(`funded ${funded.address} balance ${balance} wei`);
  if (balance === 0n) throw new Error('the funded account has no rewards yet');
  const nonce = parseInt(await n0.eth('eth_getTransactionCount', [funded.address, 'latest']), 16);
  const raw = await funded.signTransaction({ type: 'eip1559', chainId: CHAIN_ID, nonce, to: '0x1111111111111111111111111111111111111111', value: 1_000_000_000_000_000n, gas: 21000n, maxFeePerGas: 20_000_000_000n, maxPriorityFeePerGas: 1_000_000_000n });
  const txHash = await n0.eth('eth_sendRawTransaction', [raw]);
  let receipt = null;
  for (let k = 0; k < 120 && !receipt; k++) { await sleep(1000); receipt = await n0.eth('eth_getTransactionReceipt', [txHash]); }
  if (!receipt) throw new Error('the transfer was not executed in 120 s');
  const txNumber = parseInt(receipt.blockNumber, 16);
  step('transfer', { txHash, number: txNumber, secs: +since() });

  // 3. the work list of v0's key, and the shard to prove
  await sleep(1500);
  const work = await n0.eth('igneum_getAssignedShards', [[keyHashes[0]], 100]);
  const mine = work.filter(w => w.assigned);
  log(`assigned shards for v0 in the last 100 blocks: ${mine.length} of ${work.length} listed (${mine.slice(0, 5).map(w => `#${parseInt(w.number, 16)}/${w.shard} txs ${w.txCount}`).join(', ')} ...)`);
  let target = EMPTY ? mine.find(w => w.txCount === 0) : mine.find(w => parseInt(w.number, 16) === txNumber);
  if (!target) { log(`v0 is not assigned to block ${txNumber} (or no empty shard); taking the newest assigned shard`); target = mine[0]; }
  if (!target) throw new Error('v0 has no assigned shard');
  const number = parseInt(target.number, 16);
  const plan = await n0.eth('igneum_getShardPlan', [target.number]);
  const plan1 = await n1.eth('igneum_getShardPlan', [target.number]);
  if (JSON.stringify(plan.shards) !== JSON.stringify(plan1.shards)) throw new Error('nodes 0 and 1 disagree on the shard plan');
  step('plan', { number, hash: plan.hash, shards: plan.shards.length, eligibleKeys: plan.eligibleKeys, windowBlocks: plan.windowBlocks, assignees: plan.shards[target.shard].assignees.length, pgas: parseInt(plan.shards[target.shard].pgas, 16), shardWei: target.shardWei, sameOnNode1: true });

  // 4. export and cut the fixture; the exporter's plan must be the node's
  const seq = await n0.eth('igneum_exportSegments', ['0x0', target.number]);
  writeFileSync(`${TMP}/seq.json`, JSON.stringify(seq));
  const fixture = `${TMP}/block-${number}.json`;
  const ex = run(EXPORT, [`${TMP}/seq.json`, String(number), fixture, '--source', `proving-v0 test network block ${number}`]);
  writeFileSync(`${TMP}/export.log`, ex.out);
  if (ex.code !== 0) throw new Error(`exporter failed (${ex.code}): ${ex.out.split('\n').slice(-5).join(' | ')}`);
  const fx = JSON.parse(readFileSync(fixture, 'utf8'));
  const fs0 = fx.plan.shards[target.shard], ns0 = plan.shards[target.shard];
  const same = fx.plan.shards.length === plan.shards.length && fs0.pre_root === ns0.preRoot && fs0.post_root === ns0.postRoot && fs0.link_in === ns0.linkIn && fs0.link_out === ns0.linkOut && fs0.receipts_root === ns0.receiptsRoot && fs0.pgas_used === parseInt(ns0.pgas, 16);
  step('export', { secs: ex.secs, exporterShards: fx.plan.shards.length, matchesNode: same, preRoot: fs0.pre_root, postRoot: fs0.post_root });
  if (!same) throw new Error(`the exporter's plan differs from the node's: ${JSON.stringify({ fs0, ns0 })}`);

  // 5. prove the shard on the CPU (execute, then compressed)
  log(`proving block ${number} shard ${target.shard} on the CPU (SP1_PROVER=cpu); this takes minutes on a loaded Mac`);
  const results = `${TMP}/results-${number}-${target.shard}.json`;
  const pr = run(HOST, [fixture, '--mode', 'compressed', '--shard', String(target.shard), '--prover', PAYOUT, '--out', results], { SP1_PROVER: 'cpu', RUST_LOG: 'off' });
  writeFileSync(`${TMP}/prove.log`, pr.out);
  if (pr.code !== 0) throw new Error(`prover failed (${pr.code}): ${pr.out.split('\n').filter(l => /RESULT|error|Error/.test(l)).slice(-6).join(' | ')}`);
  const res = JSON.parse(readFileSync(results, 'utf8'));
  step('prove', { secs: pr.secs, cycles: res.cycles, executeSeconds: res.execute_seconds, compressedSeconds: res.compressed_prove_seconds, verifySeconds: res.compressed_verify_seconds, proofBytes: res.compressed_proof_bytes, statement: res.statement, proofSha256: res.proof_sha256 });

  // 6. sign the record with v0's vote key and submit it to node 1 (trust mode), with the proof bytes
  const sg = run(MINER, ['sign-record', 'v0', CHAIN_NAME, plan.hash, String(number), String(target.shard), PAYOUT, res.statement, res.proof_sha256]);
  if (sg.code !== 0) throw new Error(`sign-record failed: ${sg.out}`);
  const signed = JSON.parse(sg.out.trim().split('\n').pop());
  if (signed.keyHash !== keyHashes[0].slice(2)) throw new Error(`sign-record key ${signed.keyHash} is not v0's ${keyHashes[0]}`);
  const proofHex = '0x' + readFileSync(res.proof_file).toString('hex');
  const sub = await n1.eth('igneum_submitProofRecord', [{ record: signed.record, proof: proofHex }]);
  step('submit', { to: 'n1', ...sub, secs: +since() });
  if (!sub.accepted) throw new Error(`record refused: ${sub.reason}`);

  // 7. node 0 receives it over p2p and verifies the SP1 proof; then a block carries it and the segment pays
  let verified = null, paid = null, carriedBy = null, relayedAt = null, verifiedAt = null, paidAt = null;
  const deadline = Date.now() + 600_000;
  while (Date.now() < deadline && !(paid && verified)) {
    await sleep(1000);
    const r0 = await n0.eth('igneum_getProofRecords', [target.number]);
    const e0 = r0.pool.find(e => e.shard === target.shard);
    if (e0 && relayedAt == null) { relayedAt = +since(); log(`n0 holds the record over p2p (verified=${e0.verified})`); }
    if (e0 && e0.verified != null && verified == null) { verified = e0.verified; verifiedAt = +since(); log(`n0 verifier says ${e0.verified}: ${e0.note}`); }
    const paidRow = r0.paid && r0.paid[target.shard];
    if (paidRow && paid == null) { paid = paidRow; paidAt = +since(); carriedBy = (r0.carried.find(c => c.valid) || {}).carrier; log(`PAID on n0: ${JSON.stringify(paidRow)} carried by ${carriedBy}`); }
    if (Math.round(+since()) % 15 === 0) log(`waiting: pool ${JSON.stringify((e0 || {}).verified)} included ${(e0 || {}).includedIn || 'no'} paid ${paid ? 'yes' : 'no'}`);
  }
  step('relay_verify_pay', { relayedAt, verified, verifiedAt, paidAt, carriedBy, paid });
  if (!verified) throw new Error('node 0 did not verify the proof');
  if (!paid) throw new Error('no block carried the record within 10 minutes');
  // every node agrees on the payment, and the payout address holds the shard's part
  await sleep(3000);
  const agree = [];
  for (const n of nodes) { const r = await n.eth('igneum_getProofRecords', [target.number]); agree.push(r.paid && r.paid[target.shard] ? r.paid[target.shard].wei : null); }
  const bal = BigInt(await n0.eth('eth_getBalance', [PAYOUT, 'latest']));
  const pool = await n0.eth('igneum_getProvingStatus');
  step('payout', { paidWeiPerNode: agree, payoutBalanceWei: bal.toString(), shardWei: BigInt(target.shardWei).toString(), balanceEqualsShardWei: bal === BigInt(target.shardWei), poolBalanceWei: BigInt(pool.poolBalanceWei).toString(), paidShards: pool.paidShards });
  report.ok = bal === BigInt(target.shardWei) && agree.every(a => a === agree[0] && a != null);
  log(`RESULT proving v0 end to end: ${report.ok ? 'PASSED' : 'FAILED'} in ${since()} s`);
} catch (e) {
  report.error = e.message;
  log(`FAILED: ${e.message}`);
} finally {
  writeFileSync(`${TMP}/report.json`, JSON.stringify(report, null, 2));
  console.log(JSON.stringify(report, null, 2));
  await stopAll();
  process.exit(report.ok ? 0 : 1);
}