// Personal replay v1. Standalone Node 24+, no packages, repository or network.
// Checks arithmetic from declared assumptions and pinned archived model inputs;
// it does not authenticate original sources or personal spending claims.
import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import { readFileSync } from "node:fs";
import { resolve } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";

export const MODEL_VERSION = "personal-calculation-v1";
export const sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
const round = (value, places) => Math.round(value * 10 ** places) / 10 ** places;
const positive = (n, label) => assert(Number.isFinite(n) && n > 0, `Invalid ${label}`);
const nonnegative = (n, label) => assert(Number.isFinite(n) && n >= 0, `Invalid ${label}`);
const keys = (object, expected, label) =>
  assert.deepEqual(Object.keys(object).sort(), [...expected].sort(), `Unexpected ${label} fields`);
export function canonicalJson(value) {
  if (value === null || typeof value === "string" || typeof value === "boolean")
    return JSON.stringify(value);
  if (typeof value === "number") {
    assert(Number.isFinite(value), "Non-finite JSON number");
    return JSON.stringify(value);
  }
  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
  assert(value && typeof value === "object", "Invalid canonical JSON value");
  return (
    "{" +
    Object.keys(value)
      .sort()
      .map((key) => JSON.stringify(key) + ":" + canonicalJson(value[key]))
      .join(",") +
    "}"
  );
}

function budgetResults(i) {
  keys(
    i,
    [
      "price",
      "quantity",
      "period",
      ...["income", "alternativePrice", "delivery"].filter((key) => key in i),
    ],
    "budget input",
  );
  positive(i.price, "price");
  nonnegative(i.quantity, "quantity");
  assert(["week", "month"].includes(i.period), "Invalid quantity period");
  if ("income" in i) positive(i.income, "income");
  if ("alternativePrice" in i) positive(i.alternativePrice, "alternative price");
  if ("delivery" in i) {
    keys(i.delivery, ["feePerOrder", "orders", "period"], "delivery input");
    nonnegative(i.delivery.feePerOrder, "delivery fee");
    nonnegative(i.delivery.orders, "delivery orders");
    assert(["week", "month"].includes(i.delivery.period), "Invalid delivery period");
  }
  const annualQuantity = i.quantity * (i.period === "week" ? 52 : 12);
  const monthlyQuantity = annualQuantity / 12;
  const annualOrders = i.delivery
    ? i.delivery.orders * (i.delivery.period === "week" ? 52 : 12)
    : 0;
  const annualDeliveryCost = annualOrders * (i.delivery?.feePerOrder ?? 0);
  const annualWrapCost = annualQuantity * i.price;
  const annualCost = annualWrapCost + annualDeliveryCost;
  const monthlyCost = annualCost / 12;
  const result = {
    annualQuantity,
    monthlyQuantity,
    annualOrders,
    annualWrapCost,
    monthlyWrapCost: annualWrapCost / 12,
    annualDeliveryCost,
    monthlyDeliveryCost: annualDeliveryCost / 12,
    annualCost,
    monthlyCost,
    incomeShare: i.income === undefined ? null : (monthlyCost / i.income) * 100,
    alternative:
      i.alternativePrice === undefined
        ? null
        : {
            monthlyCost: (annualQuantity * i.alternativePrice + annualDeliveryCost) / 12,
            annualCost: annualQuantity * i.alternativePrice + annualDeliveryCost,
            monthlyDifference: monthlyQuantity * (i.alternativePrice - i.price),
            annualDifference: annualQuantity * (i.alternativePrice - i.price),
          },
  };
  for (const value of [
    ...Object.values(result).filter((v) => typeof v === "number"),
    ...Object.values(result.alternative ?? {}),
  ])
    assert(
      Number.isFinite(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER / 100,
      "Budget result outside supported range",
    );
  return result;
}

function archiveRows(c, bundle) {
  assert(bundle && bundle.schema_version === 1, "Unsupported bundle schema");
  assert.equal(
    bundle.methodology_version,
    "published-classic-v1",
    "Unsupported baseline methodology",
  );
  assert.equal(
    c.model.baseline_methodology,
    bundle.methodology_version,
    "Baseline methodology mismatch",
  );
  assert.equal(bundle.scope, "baseline-catering-both-product-units", "Unsupported archive scope");
  assert.equal(bundle.dataset.cpi_mode, "catering", "Archive must contain baseline");
  assert.equal(bundle.dataset.version, c.dataset.version, "Dataset version mismatch");
  assert.equal(bundle.dataset.updated, c.dataset.date, "Dataset date mismatch");
  const { rows, coverage } = bundle.dataset;
  assert(
    Number.isInteger(coverage.from) &&
      Number.isInteger(coverage.to) &&
      coverage.to >= coverage.from,
    "Invalid archive coverage",
  );
  assert.equal(rows.length, coverage.to - coverage.from + 1, "Missing archive years");
  rows.forEach((row, index) =>
    assert.equal(row.year, coverage.from + index, "Unordered or missing archive year"),
  );
  return rows;
}

function reverseResults(c, bundle) {
  const i = c.inputs;
  keys(i, ["ref", "basis", ...("target" in i ? ["target"] : [])], "reverse input");
  assert(["annual", "contract"].includes(i.basis), "Invalid wage basis");
  const archived = archiveRows(c, bundle);
  assert(
    Number.isInteger(i.ref) && archived.some((row) => row.year === i.ref),
    "Invalid reference year",
  );
  if ("target" in i)
    assert(
      Number.isFinite(i.target) && i.target >= 1 && Number.isSafeInteger(Math.round(i.target)),
      "Invalid custom target",
    );
  const p = bundle.parameters;
  positive(p.drachma_per_euro, "currency conversion");
  positive(p.reference_meat_grams, "reference grams");
  positive(p.meat_cap, "meat cap");
  assert(p.meat_value_share >= 0 && p.meat_value_share < 1, "Invalid meat share");
  assert(p.non_meat_base >= 0 && p.non_meat_base < 1, "Invalid non-meat base");
  assert.equal(p.classic_decimals, 3, "Unsupported classic rounding");
  assert.equal(bundle.calculations.length, archived.length, "Missing archived calculations");
  const calculations = new Map(bundle.calculations.map((row) => [row.year, row]));
  assert.equal(calculations.size, archived.length, "Duplicate archived calculation");
  const inputs = archived.map((row) => {
    const calc = calculations.get(row.year);
    assert(calc?.wage && calc?.product, "Missing wage/product inputs");
    const w = calc.wage;
    positive(w.original_gross, "gross wage");
    assert(["GRD", "EUR"].includes(w.currency), "Unsupported wage currency");
    assert(
      w.contribution_fraction >= 0 && w.contribution_fraction < 1,
      "Invalid contribution fraction",
    );
    assert(
      Number.isInteger(w.payments) && w.payments > 0 && w.payments <= 14,
      "Invalid payment convention",
    );
    assert.equal(w.income_tax_deducted, false, "Income tax outside this model");
    const payment =
      (w.original_gross / (w.currency === "GRD" ? p.drachma_per_euro : 1)) *
      (1 - w.contribution_fraction);
    const annual = round(payment * (w.payments / 12), 2);
    const contract = round(payment, 2);
    assert.equal(row.salary_annualized_eur, annual, "Archived annual wage mismatch");
    assert.equal(row.salary_contract_eur, contract, "Archived contract wage mismatch");
    assert.equal(row.salary_payments, w.payments, "Archived payment count mismatch");
    positive(calc.product.meat_grams, "meat grams");
    assert(calc.product.fries_share >= 0 && calc.product.fries_share <= 1, "Invalid fries share");
    const equivalent =
      p.meat_value_share * Math.min(calc.product.meat_grams / p.reference_meat_grams, p.meat_cap) +
      (1 - p.meat_value_share) *
        (p.non_meat_base + (1 - p.non_meat_base) * calc.product.fries_share);
    const factor = round(1 / round(equivalent, 3), 3);
    positive(row.price_era_eur, "archived period price");
    const price = round(row.price_era_eur * factor, 3);
    assert.equal(row.price_classic_eur, price, "Archived classic price mismatch");
    return {
      year: row.year,
      price,
      rawPita: row.price_era_eur,
      payments: w.payments,
      annual,
      contract,
      factor: round(w.payments / 12, 4),
    };
  });
  const reference = inputs.find((row) => row.year === i.ref);
  const target =
    "target" in i ? Math.round(i.target) : Math.round(reference.annual / reference.price);
  return {
    target,
    rows: inputs.map((row) => {
      const requiredAnnual = row.price * target;
      const required = i.basis === "annual" ? requiredAnnual : requiredAnnual / row.factor;
      const salary = i.basis === "annual" ? row.annual : row.contract;
      return {
        year: row.year,
        pita: row.price,
        rawPita: row.rawPita,
        payments: row.payments,
        salary,
        required: round(required, 1),
        coverage: round((salary / required) * 100, 1),
        diff: round(salary - required, 1),
      };
    }),
  };
}

export function reconstructPersonalResults(c, bundle = null) {
  assert.equal(c.schema_version, 1, "Unsupported scenario schema");
  assert.equal(c.kind, "gyronomics-personal-scenario", "Unsupported scenario kind");
  assert.equal(c.model.version, MODEL_VERSION, "Unsupported personal model");
  assert(["el", "en"].includes(c.language), "Unsupported language");
  if (c.calculation === "budget") {
    assert.equal(c.model.calculation_version, "gyro-budget-v1", "Unsupported budget model");
    assert.deepEqual(
      c.conventions,
      { weeksPerYear: 52, monthsPerYear: 12, currency: "EUR", rounding: "presentation-only" },
      "Unsupported budget conventions",
    );
    assert.equal(
      c.source_url,
      `https://gyronomics.gr${c.language === "en" ? "/en" : ""}/calculator#gyro-budget`,
      "Budget source URL must not contain personal inputs",
    );
    if (c.source.kind === "user-assumptions") {
      assert.deepEqual(c.source, { kind: "user-assumptions" }, "Unexpected budget provenance");
      assert.equal(c.dataset, null, "User budget must not claim archived provenance");
      assert.equal(
        c.model.baseline_methodology,
        null,
        "User budget must not claim baseline methodology",
      );
    } else {
      assert.equal(c.source.kind, "model-reference", "Unsupported budget provenance");
      const rows = archiveRows(c, bundle);
      const last = rows.at(-1);
      assert.deepEqual(
        c.source,
        { kind: "model-reference", year: last.year, field: "price_era_eur" },
        "Unsupported reference price source",
      );
      assert.equal(c.inputs.price, last.price_era_eur, "Reference price does not match archive");
    }
    return budgetResults(c.inputs);
  }
  assert.equal(c.calculation, "reverse", "Unsupported calculation");
  assert.equal(c.model.calculation_version, "reverse-classic-v1", "Unsupported reverse model");
  assert.deepEqual(c.source, { kind: "archived-baseline" }, "Unsupported reverse provenance");
  assert.deepEqual(
    c.conventions,
    {
      unit: "classic-wrap",
      currency: "EUR",
      target_rounding: "nearest-whole-wrap",
      salary_factor_decimals: 4,
      result_decimals: 1,
      income_tax_deducted: false,
    },
    "Unsupported reverse conventions",
  );
  const s = c.inputs;
  const query = new URLSearchParams({
    ref: String(s.ref),
    ...("target" in s ? { target: String(s.target) } : {}),
    basis: s.basis,
  });
  assert.equal(
    c.source_url,
    `https://gyronomics.gr${c.language === "en" ? "/en" : "/"}?${query}#answer`,
    "Reverse source URL mismatch",
  );
  return reverseResults(c, bundle);
}

export function verifyPersonalFiles({
  scenarioBytes,
  bundleBytes,
  archiveManifestBytes,
  verifierBytes,
}) {
  const c = JSON.parse(Buffer.from(scenarioBytes).toString("utf8"));
  const { integrity, ...payload } = c;
  assert.equal(integrity?.algorithm, "SHA-256", "Unsupported checksum algorithm");
  assert.equal(integrity.canonicalization, "sorted-json-v1", "Unsupported canonicalization");
  assert.equal(integrity.sha256, sha256(canonicalJson(payload)), "Scenario checksum mismatch");
  assert.equal(c.verifier.sha256, sha256(verifierBytes), "Verifier checksum mismatch");
  assert.equal(
    c.verifier.url,
    `https://gyronomics.gr/research/reproduction/${c.verifier.sha256}/reproduce-personal-v1.mjs`,
    "Immutable verifier URL mismatch",
  );
  let bundle = null;
  if (c.dataset !== null) {
    assert(bundleBytes && archiveManifestBytes, "Pinned archive files are required");
    const d = c.dataset;
    assert.equal(
      sha256(archiveManifestBytes),
      d.archive_sha256,
      "Archive manifest checksum mismatch",
    );
    assert.equal(
      d.bundle_url,
      `https://gyronomics.gr/datasets/${d.archive_sha256}/bundle.json`,
      "Immutable bundle URL mismatch",
    );
    assert.equal(
      d.manifest_url,
      `https://gyronomics.gr/datasets/${d.archive_sha256}/manifest.json`,
      "Immutable manifest URL mismatch",
    );
    const manifest = JSON.parse(Buffer.from(archiveManifestBytes).toString("utf8"));
    assert.equal(manifest.schema_version, 1, "Unsupported manifest schema");
    assert.equal(manifest.dataset_version, d.version, "Archive version mismatch");
    assert.equal(manifest.date, d.date, "Archive date mismatch");
    assert.equal(
      manifest.methodology_version,
      c.model.baseline_methodology,
      "Archive methodology mismatch",
    );
    assert.equal(sha256(bundleBytes), manifest.files["bundle.json"], "Bundle checksum mismatch");
    bundle = JSON.parse(Buffer.from(bundleBytes).toString("utf8"));
  }
  const rebuilt = reconstructPersonalResults(c, bundle);
  assert.equal(
    canonicalJson(c.results),
    canonicalJson(rebuilt),
    "Results differ from independent reconstruction",
  );
  const scope =
    c.calculation === "budget" ? "personal-budget-arithmetic" : "all-reverse-year-results";
  const notVerified =
    c.calculation === "budget"
      ? ["personal-input-truth", "market-price-representativeness", "source-authenticity"]
      : ["source-authenticity", "baseline-price-series-from-original-documents", "income-tax"];
  assert.deepEqual(
    c.verification,
    { scope, not_verified: notVerified },
    "Verification scope mismatch",
  );
  return {
    verified: true,
    schema_version: 1,
    model_version: MODEL_VERSION,
    calculation: c.calculation,
    scope,
    rows: c.calculation === "reverse" ? rebuilt.rows.length : 1,
    archive_sha256: c.dataset?.archive_sha256 ?? null,
    not_verified: notVerified,
  };
}

if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
  try {
    const args = process.argv.slice(2);
    assert(
      args.length === 1 || args.length === 3,
      "Usage: node reproduce-personal-v1.mjs scenario.json [bundle.json manifest.json]",
    );
    const [scenario, bundle, manifest] = args;
    console.log(
      JSON.stringify(
        verifyPersonalFiles({
          scenarioBytes: readFileSync(scenario),
          ...(bundle
            ? { bundleBytes: readFileSync(bundle), archiveManifestBytes: readFileSync(manifest) }
            : {}),
          verifierBytes: readFileSync(fileURLToPath(import.meta.url)),
        }),
        null,
        2,
      ),
    );
  } catch (error) {
    console.error(error instanceof Error ? error.message : String(error));
    process.exitCode = 1;
  }
}
