#!/usr/bin/env python3
"""E126 standalone offline verifier. Standard library only. Imports no CAIN code."""
from __future__ import annotations

import hashlib
import json
import math
import sys
from pathlib import Path

FAILS = []
CHECKS = 0


def ok(cond, name, detail=""):
    global CHECKS
    CHECKS += 1
    print(("PASS " if cond else "FAIL ") + name + (" " + detail if detail else ""))
    if not cond:
        FAILS.append(name)


def sha(p):
    h = hashlib.sha256()
    with p.open("rb") as fh:
        for c in iter(lambda: fh.read(1 << 20), b""):
            h.update(c)
    return h.hexdigest()


def load(p):
    return json.loads(p.read_text())


def rows(p):
    return [json.loads(x) for x in p.read_text().splitlines() if x.strip()]


def canon(o):
    return json.dumps(o, sort_keys=True, separators=(",", ":"))


def mcnemar(a, b):
    ao = sum(1 for x, y in zip(a, b) if x and not y)
    bo = sum(1 for x, y in zip(a, b) if y and not x)
    n = ao + bo
    if n == 0:
        return 1.0
    probs = [math.comb(n, i) * 0.5 ** n for i in range(n + 1)]
    p = probs[ao]
    return min(1.0, sum(x for x in probs if x <= p + 1e-15))


def main():
    root = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(__file__).resolve().parent
    print("E126 offline verifier root=" + str(root))
    man = load(root / "MANIFEST.json")
    for e in man["files"]:
        p = root / e["path"]
        ok(p.exists() and sha(p) == e["sha256"], "manifest:" + e["path"], "" if p.exists() else "MISSING")
    ev = root / "evidence"
    env = load(ev / "env_results.json")
    er = rows(ev / "env_rows.jsonl")
    key = load(ev / "env_answer_key.json")
    commit = load(ev / "env_commitment.json")["commitment"]
    ok(hashlib.sha256(canon(key).encode()).hexdigest() == commit, "env_commitment", commit[:16])
    ok(env["counts"]["instances"] == 100 and len(er) == 600, "env_denominator", "100 instances, 6 arms")
    for arm, s in env["arms"].items():
        sub = [r for r in er if r["arm"] == arm]
        acc = round(sum(r["success"] for r in sub) / len(sub), 4)
        ok(acc == s["completion"] and len(sub) == s["n"], "env:" + arm, str(acc))
    full = [r["success"] for r in er if r["arm"] == "full"]
    retr = [r["success"] for r in er if r["arm"] == "retrieval"]
    e125 = [r["success"] for r in er if r["arm"] == "e125"]
    ok(abs(mcnemar(full, retr) - env["comparisons"]["full_vs_retrieval"]["p_exact_two_sided"]) < 1e-12,
       "env_full_vs_retrieval", str(sum(full)) + " vs " + str(sum(retr)))
    ok(abs(mcnemar(full, e125) - env["comparisons"]["full_vs_e125"]["p_exact_two_sided"]) < 1e-12,
       "env_full_vs_e125", str(sum(full)) + " vs " + str(sum(e125)))

    cont = load(ev / "continual_results.json")
    cr = rows(ev / "continual_rows.jsonl")
    for mode, s in cont["arms"].items():
        sub = [r for r in cr if r["mode"] == mode and r["phase"] == "test"]
        acc = round(sum(r["success"] for r in sub) / len(sub), 4)
        ok(acc == s["accuracy"] and len(sub) == s["n"], "continual:" + mode, str(acc))

    ca = load(ev / "causal_results.json")
    for mode, s in ca["summary"].items():
        sub = [r for r in ca["rows"] if r["mode"] == mode]
        mae = round(sum(r["intervention_mae"] for r in sub) / len(sub), 4)
        ok(mae == s["intervention_mae"], "causal:" + mode, str(mae))
    ok(all("counterfactual" in r for r in ca["rows"]), "causal_counterfactuals_present", "")

    tr = load(ev / "transfer_results.json")
    ok(tr["harmful"]["false_accepts"] == 0, "transfer_zero_false_accepts", str(tr["harmful"]["false_accepts"]))
    ok(tr["positive"]["n"] == 40 and tr["harmful"]["n"] == 40, "transfer_pathways", "40+40")
    ok(tr["applied_paired"]["gain"] > 0 and tr["applied_paired"]["p_exact_two_sided"] < 0.05,
       "transfer_improvement", str(tr["applied_paired"]["gain"]))

    co = load(ev / "collective_results.json")
    ok(co["decisions"] == 500 and co["summary"]["dynamic_verified"]["n"] == 500, "collective_decisions", "500")
    ok(co["summary"]["dynamic_verified"]["byzantine_flips"] == 0, "collective_byzantine_flips", "0")
    ok(co["summary"]["dynamic_verified"]["accuracy"] > co["summary"]["best_single"]["accuracy"],
       "collective_advantage", str(co["summary"]["dynamic_verified"]["accuracy"]))

    d = load(ev / "discovery_results.json")
    ok(d["summary"]["n_cycles"] == 8, "discovery_cycles", "8")
    ok(d["summary"]["independent_reproductions"] == 2, "discovery_reproductions", "2")

    si = load(ev / "self_improvement_results.json")
    ok(si["n_evaluated"] == 40 and si["n_refused_protected"] == 4, "self_improvement", "40 evaluated, 4 refused")
    ok(si["n_promoted"] == sum(1 for r in si["rows"] if r["promoted"]), "self_improvement_promoted", str(si["n_promoted"]))

    gov = load(ev / "governance_results.json")
    ok(gov["unauthorized_effects"] == 0 and gov["post_fence_effects"] == 0, "governance_zero_effects", "0/0")
    ok(gov["ledger_chain_valid"], "governance_ledger", "")

    adp = load(ev / "adaptation_results.json")
    ok(adp["weights_changed"], "adaptation_weights_changed", "")
    ok(adp["arms"]["lora_replay"] > adp["arms"]["frozen"], "adaptation_target_gain",
       str(adp["arms"]["lora_replay"]) + " vs " + str(adp["arms"]["frozen"]))

    mis = load(ev / "mission_results.json")
    mr = rows(ev / "mission_journal.jsonl")
    prev = "0" * 64
    good = True
    for row in mr:
        body = {k: v for k, v in row.items() if k not in ("hash", "sig")}
        if row.get("prev") != prev or row.get("hash") != hashlib.sha256(canon(body).encode()).hexdigest():
            good = False
            break
        prev = row["hash"]
    ok(good and len(mr) == mis["tasks_completed"], "mission_journal", str(len(mr)))
    ok(mis["repeated_work"] == 0, "mission_no_repeats", "0")

    pub = load(ev / "public_manifest.json")
    ok(pub["agi_status"] == "NOT ESTABLISHED", "public_agi_status", "")
    ok(len(pub["modules"]) == 6, "public_modules", "6")

    if er:
        copy = [dict(r) for r in er]
        copy[0]["success"] = 1 - copy[0]["success"]
        arm = copy[0]["arm"]
        acc2 = sum(r["success"] for r in copy if r["arm"] == arm) / sum(1 for r in copy if r["arm"] == arm)
        ok(abs(acc2 - env["arms"][arm]["completion"]) > 0, "tamper_detection", "flipped row changes accuracy")

    print(f"\n{CHECKS - len(FAILS)}/{CHECKS} checks passed; {len(FAILS)} failed")
    if FAILS:
        print("FAILURES:", FAILS)
        return 1
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
