#!/usr/bin/env python3
"""Standalone offline verifier for the CAIN-42 E144 bundle (stdlib + cryptography; imports no CAIN code).

Written by the E143 session under a sub-claim from the E144 session (EVOLUTION144_COORDINATION.md), mirroring
verify_e142_offline.py. Checks:
  1. MANIFEST.json file hashes, Merkle root (= MERKLE_ROOT.txt), Ed25519 manifest signature by evidence_pubkey.txt;
  2. events.jsonl is an unbroken SHA-256 chain with strictly increasing sequence numbers;
  3. every verdict in experiments.jsonl is signed by the same key (body = verdict minus signature/evaluator_pubkey);
  4. every VERIFIED/PARTIAL verdict's paired statistics recompute from its instance_scores (wins/losses with 1e-12,
     effect, one-sided exact sign test in log space) and its summary means recompute;
  5. E144_ANALYSIS.json confirmatory H1-H3 recompute from per-experiment mean differences of the primary
     experiments verified at or before the cutoff in H_ANALYSIS_CUTOFF.json: n, wins/losses/ties, mean, log10 p,
     Holm across H1-H3, verdict label;
  6. no p value is displayed as 0 or non-finite; AGI NOT ESTABLISHED / RSI EXPERIMENTAL in the public snapshot.
Integrity is not truth: a valid signature shows the evidence is unchanged since it was signed by a self-generated
key, not that the science is right.

  python3 -I verify_e144_offline.py <bundle_dir>
"""
from __future__ import annotations

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

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

GENESIS = "0" * 64
PRACTICAL = {"H1": 0.05, "H2": 0.01, "H3": 0.005}   # per hypothesis (E144 prereg); confirmatory practical_threshold must match
FAMILY = {"H1": "e144_director", "H2": "e144_meta", "H3": "e144_selfmodel"}
RESULTS: list = []


def check(ok, name, detail=""):
    RESULTS.append((bool(ok), name, detail))


def canon(o) -> str:
    return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True, default=float)


def sha_file(p: Path) -> str:
    h = hashlib.sha256()
    with p.open("rb") as f:
        for chunk in iter(lambda: f.read(1 << 16), b""):
            h.update(chunk)
    return h.hexdigest()


def merkle(leaves):
    if not leaves:
        return hashlib.sha256(b"").hexdigest()
    level = [hashlib.sha256(b"\x00" + bytes.fromhex(h)).digest() for h in leaves]
    while len(level) > 1:
        level = [hashlib.sha256(b"\x01" + level[i] + level[i + 1]).digest() if i + 1 < len(level) else level[i]
                 for i in range(0, len(level), 2)]
    return level[0].hex()


def ed_ok(pub, sig, msg: bytes) -> bool:
    try:
        Ed25519PublicKey.from_public_bytes(bytes.fromhex(pub)).verify(bytes.fromhex(sig), msg)
        return True
    except Exception:
        return False


def log10_sign_p(w, l):
    n = w + l
    if n == 0:
        return 0.0
    logs = [math.lgamma(n + 1) - math.lgamma(i + 1) - math.lgamma(n - i + 1) - n * math.log(2) for i in range(w, n + 1)]
    m = max(logs)
    return (m + math.log(sum(math.exp(x - m) for x in logs))) / math.log(10)


def mean(x):
    return sum(x) / len(x)


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


def cutoff_of(b: Path) -> str | None:
    if not (b / "H_ANALYSIS_CUTOFF.json").exists():
        return None   # interim export: no frozen analysis yet
    c = json.loads((b / "H_ANALYSIS_CUTOFF.json").read_text())
    for k in ("cutoff", "frozen_at", "at"):
        if isinstance(c.get(k), str):
            return c[k]
    raise SystemExit("H_ANALYSIS_CUTOFF.json has no cutoff/frozen_at/at timestamp")


def recompute(exps, cut, need, practical=None):
    practical = practical or PRACTICAL
    res = {}
    for k, fam in FAMILY.items():
        diffs = []
        for x in exps:
            v = x.get("verdict") or {}
            if x.get("family") != fam or x.get("kind") != "primary" or x.get("state") not in ("VERIFIED", "PARTIAL"):
                continue
            if not x.get("verified_at") or x["verified_at"] > cut or "instance_scores" not in v:
                continue
            s, t, c = v["instance_scores"], v["treatment"], v["primary_control"]
            sgn = 1.0 if v.get("better", "higher") == "higher" else -1.0
            diffs.append(sgn * (mean(s[t]) - mean(s[c])))
        w = sum(1 for d in diffs if d > 1e-12)
        l = sum(1 for d in diffs if d < -1e-12)
        res[k] = {"n": len(diffs), "wins": w, "losses": l, "ties": len(diffs) - w - l,
                  "mean": mean(diffs) if diffs else None, "lp": round(log10_sign_p(w, l), 4), "need": need.get(k, 0)}
    order = sorted(res, key=lambda k: res[k]["lp"])
    stop = False
    for i, k in enumerate(order):
        sig = (not stop) and 10 ** res[k]["lp"] <= 0.05 / (len(order) - i)
        stop = stop or not sig
        r = res[k]
        r["holm"] = sig
        if r["n"] < r["need"]:
            r["verdict"] = "UNDERPOWERED"
        elif sig and r["mean"] > 0:
            r["verdict"] = "SUPPORTED" if r["mean"] >= practical[k] else "SUPPORTED (significant but small)"
        elif r["mean"] is not None and r["mean"] < 0 and r["losses"] > r["wins"]:
            r["verdict"] = "NOT SUPPORTED (treatment worse)"
        else:
            r["verdict"] = "NOT SUPPORTED"
    return res


def main() -> int:
    b = Path(sys.argv[1] if len(sys.argv) > 1 else Path(__file__).resolve().parent)
    man = json.loads((b / "MANIFEST.json").read_text())
    pub = (b / "evidence_pubkey.txt").read_text().strip()
    bad = [f for f, h in man["files"].items() if not (b / f).exists() or sha_file(b / f) != h]
    check(not bad, "manifest_file_hashes", f"{len(man['files'])} files, mismatched: {bad[:5]}")
    root = merkle([man["files"][k] for k in sorted(man["files"])])
    check(root == man.get("merkle_root") == (b / "MERKLE_ROOT.txt").read_text().strip(), "merkle_root", root)
    body = {k: man[k] for k in sorted(man) if k != "signature"}
    check(man.get("evidence_pubkey", pub) == pub and ed_ok(pub, man.get("signature", ""), canon(body).encode()),
          "manifest_signature", pub[:16])

    events = jl(b / "events.jsonl")
    prev, ok, where = GENESIS, True, None
    for e in events:
        eb = {k: e[k] for k in ("event_id", "ts", "type", "evolution", "experiment_id", "worker_id", "provenance",
                                "verification_state", "artifact_ref", "data", "prev_hash")}
        if e["prev_hash"] != prev or hashlib.sha256(canon(eb).encode()).hexdigest() != e["hash"]:
            ok, where = False, e.get("seq")
            break
        prev = e["hash"]
    check(ok, "event_chain", f"{len(events)} events, head {prev[:16]}" + (f", broken at {where}" if where else ""))
    seqs = [e["seq"] for e in events]
    check(all(a < c for a, c in zip(seqs, seqs[1:])), "event_sequence_monotonic", str(len(seqs)))

    exps = jl(b / "experiments.jsonl")
    sig_bad, stat_bad, zero_p, n_re = [], [], 0, 0
    for x in exps:
        v = x.get("verdict")
        if not v:
            continue
        vb = {k: v[k] for k in sorted(v) if k not in ("signature", "evaluator_pubkey")}
        if v.get("evaluator_pubkey") != pub or not ed_ok(pub, v.get("signature", ""), canon(vb).encode()):
            sig_bad.append(x["id"])
        if str(v.get("p_sign_display", "")).strip() in ("0", "0.0") or (
                "log10_p_sign" in v and (v["log10_p_sign"] is None or not math.isfinite(v["log10_p_sign"]))):
            zero_p += 1
        sc = v.get("instance_scores")
        if sc and v.get("state") in ("VERIFIED", "PARTIAL"):
            sgn = 1.0 if v.get("better", "higher") == "higher" else -1.0
            tt, cc = sc[v["treatment"]], sc[v["primary_control"]]
            d = [sgn * (a - c) for a, c in zip(tt, cc)]
            w, l = sum(1 for z in d if z > 1e-12), sum(1 for z in d if z < -1e-12)
            if len(tt) != len(cc) or w != v["wins"] or l != v["losses"] or abs(mean(d) - v["effect"]) > 1e-5 \
                    or abs(log10_sign_p(w, l) - v["log10_p_sign"]) > 1e-3:
                stat_bad.append(x["id"])
            for arm, vals in sc.items():
                if arm in v.get("summary", {}) and abs(mean(vals) - v["summary"][arm]) > 1e-5:
                    stat_bad.append((x["id"], arm))
            n_re += 1
    check(not sig_bad, "verdict_signatures", f"{sum(1 for x in exps if x.get('verdict'))} verdicts, bad: {sig_bad[:5]}")
    check(not stat_bad, "verdict_statistics_recompute", f"{n_re} recomputed, mismatches: {stat_bad[:5]}")

    an = json.loads((b / "E144_ANALYSIS.json").read_text())
    conf = an["confirmatory"]
    cut = cutoff_of(b)
    check(cut is not None, "analysis_cutoff_present", cut or "absent: interim export, confirmatory numbers are not final")
    cut = cut or "9999-12-31T23:59:59Z"
    need = {k: int(conf[k].get("n_required") or conf[k].get("required_experiments") or 0) for k in FAMILY if k in conf}
    thr = {k: conf[k].get("practical_threshold", PRACTICAL[k]) for k in FAMILY if k in conf}
    check(all(abs(float(thr[k]) - PRACTICAL[k]) < 1e-12 for k in thr), "practical_thresholds_match_prereg",
          json.dumps(thr))
    rec = recompute(exps, cut, need, PRACTICAL)
    mism = []
    for k in FAMILY:
        c, r = conf.get(k), rec[k]
        if c is None:
            mism.append((k, "missing"))
            continue
        hs = c["holm"]["holm_significant"] if isinstance(c.get("holm"), dict) else bool(c.get("holm"))
        if (c["n_experiments"], c["wins"], c["losses"], c["ties"]) != (r["n"], r["wins"], r["losses"], r["ties"]) \
                or c["verdict"] != r["verdict"] or hs != r["holm"] \
                or (r["mean"] is not None and abs(c["mean_diff"] - r["mean"]) > 1e-5) \
                or ("log10_p" in c and abs(c["log10_p"] - r["lp"]) > 1e-3):
            mism.append((k, {"claimed": [c["n_experiments"], c["wins"], c["losses"], c["ties"], c["verdict"], hs],
                             "recomputed": [r["n"], r["wins"], r["losses"], r["ties"], r["verdict"], r["holm"]]}))
    check(not mism, "confirmatory_H1_H3_recompute", f"cutoff {cut}; mismatches: {mism}")
    shown = [str(conf[k].get("p_display", "")).strip() for k in conf if conf[k].get("n_experiments")]   # n = 0 has no p
    check(zero_p == 0 and not any(s in ("0", "0.0", "") for s in shown), "no_zero_p_values", f"verdicts {zero_p}, analysis {shown}")
    snap = json.loads((b / "E144_PUBLIC_SNAPSHOT.json").read_text()) if (b / "E144_PUBLIC_SNAPSHOT.json").exists() else {}
    st = snap.get("status") or an.get("status") or {}
    check(st.get("agi") == "NOT ESTABLISHED" and st.get("rsi") == "EXPERIMENTAL", "status_invariants", json.dumps(st))
    for okk, name, det in RESULTS:
        print(("PASS " if okk else "FAIL ") + name + (f"  [{det}]" if det else ""))
    n_ok = sum(1 for r in RESULTS if r[0])
    print(f"\n{n_ok}/{len(RESULTS)} checks passed; {len(RESULTS) - n_ok} failed")
    return 0 if n_ok == len(RESULTS) else 1


if __name__ == "__main__":
    sys.exit(main())
