#!/usr/bin/env python3
"""CAIN-42 E142 standalone offline verifier.

Imports no CAIN code and makes no network calls (stdlib + ``cryptography`` only).

    python3 -I verify_e142_offline.py <bundle_dir>

Checks
  1. every manifest file matches its SHA-256; the Merkle root recomputes; the manifest
     signature verifies against the pinned evidence key;
  2. the event log is an unbroken SHA-256 chain with monotonic sequence numbers;
  3. every evaluator verdict carries a valid Ed25519 signature by the same key;
  4. every verdict's arm means and paired statistics recompute from its per-instance scores;
  5. no p value is zero or non-finite anywhere in the analysis or verdicts;
  6. the confirmatory analyses (OW1-OW7, H2-H4) recompute from experiments.jsonl: experiment-level
     wins / losses / ties, mean difference, one-sided sign-test log10 p, Holm decisions, verdict labels;
  7. preregistration precedes start; no experiment has two results or two verdicts;
     adversarial fabrications were all rejected;
  8. drills passed; gate counts are consistent; status invariants hold.

The bootstrap intervals use numpy's generator and are not recomputed here (stdlib only).
Integrity is not truth: a valid signature shows the evidence is unchanged since signing by this
self-generated key, not that the science is right.
"""
from __future__ import annotations

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

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

GENESIS = "0" * 64
RESULTS: list[tuple[bool, str, str]] = []
PRACTICAL = 0.02


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


def canon(obj) -> str:
    return json.dumps(obj, 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_hex, sig_hex, msg: bytes) -> bool:
    try:
        Ed25519PublicKey.from_public_bytes(bytes.fromhex(pub_hex)).verify(bytes.fromhex(sig_hex), 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()]


REGIMES = {
    "OW1": ("ow_explore", "frontier", "random", "higher", lambda p: True, 30),
    "OW2": ("ow_model", "full", "facts", "higher", lambda p: True, 30),
    "OW3": ("ow_transfer", "gated", "scratch", "higher", lambda p: p["budget_mult"] == 0.05, 30),
    "OW3b": ("ow_transfer", "gated", "ungated", "higher", lambda p: True, 30),
    "OW4": ("ow_goal", "full", "e141_best", "higher", lambda p: True, 30),
    "OW5": ("ow_rsi", "inherit_mem", "G0", "higher", lambda p: True, 20),
    "OW5b": ("ow_rsi", "inherit_mem", "random_search", "higher", lambda p: True, 20),
    "OW6": ("ow_rsi", "inherit_mem", "inherit_nomem", "higher", lambda p: True, 20),
    "OW7": ("ow_rsi", "inherit_mem", "reset_mem", "higher", lambda p: True, 20),
    "H2": ("calibration_iw", "iw_temperature", "temperature", "lower",
           lambda p: p["target_noise"] == 0.0 and p["shift"] in (0.5, 1.0, 1.5), 30),
    "H3": ("world_model_frontier", "frontier", "random_walk", "higher",
           lambda p: p["budget_mult"] in (0.5, 1.0) and p["size"] in (9, 12), 30),
    "H4": ("rsi_meta", "inherit", "reset", "higher", lambda p: True, 30),
}


def recompute_confirmatory(exps, ids):
    res = {}
    for tid in ids:
        fam, t, c, better, reg, need = REGIMES[tid]
        sgn = 1.0 if better == "higher" else -1.0
        w = l = ties = 0
        diffs = []
        for x in exps:
            v = x.get("verdict") or {}
            if x["family"] != fam or x["kind"] != "primary" or x["state"] not in ("VERIFIED", "PARTIAL") or "instance_scores" not in v:
                continue
            if not reg(x["params"]):
                continue
            s = v["instance_scores"]
            if t not in s or c not in s:
                continue
            d = sgn * (mean(s[t]) - mean(s[c]))
            diffs.append(d)
            w += d > 1e-12
            l += d < -1e-12
            ties += abs(d) <= 1e-12
        res[tid] = {"n": len(diffs), "wins": w, "losses": l, "ties": ties,
                    "mean": (sum(diffs) / len(diffs)) if diffs else None, "lp": round(log10_sign_p(w, l), 4), "need": need}
    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 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["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 and ed_ok(pub, man["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["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(seqs == sorted(seqs) and len(set(seqs)) == len(seqs), "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 "log10_p_sign" in v and (v["log10_p_sign"] is None or not math.isfinite(v["log10_p_sign"])):
            zero_p += 1
        if str(v.get("p_sign_display", "")).strip() in ("0", "0.0"):
            zero_p += 1
        sc = v.get("instance_scores")
        if sc and v["state"] in ("VERIFIED", "PARTIAL"):
            s = 1.0 if v["better"] == "higher" else -1.0
            d = [s * (a - c) for a, c in zip(sc[v["treatment"]], sc[v["primary_control"]])]
            w, l = sum(1 for z in d if z > 1e-12), sum(1 for z in d if z < -1e-12)
            if 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 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 / "E142_ANALYSIS.json").read_text())
    for blk in ("confirmatory_OW", "confirmatory_H"):
        for r in an[blk].values():
            lp = r.get("log10_p")
            if lp is not None and (not math.isfinite(lp) or str(r.get("p_display", "")).strip() in ("0", "0.0")):
                zero_p += 1
    check(zero_p == 0, "no_zero_p_values", f"{zero_p} zero/non-finite p values")
    mism = []
    cuts = an["stopping_rule"]["cutoffs"]
    for blk, tag, ids in (("confirmatory_OW", "OW", ["OW1", "OW2", "OW3", "OW3b", "OW4", "OW5", "OW5b", "OW6", "OW7"]),
                          ("confirmatory_H", "H", ["H2", "H3", "H4"])):
        c = cuts[tag]["cutoff"]
        sub = [x for x in exps if c is None or (x.get("verified_at") and x["verified_at"] <= c)]
        rc = recompute_confirmatory(sub, ids)
        for tid in ids:
            a, r = an[blk][tid], rc[tid]
            same = (a["n_experiments"] == r["n"] and a["wins"] == r["wins"] and a["losses"] == r["losses"] and a["ties"] == r["ties"]
                    and abs(a["log10_p"] - r["lp"]) < 1e-3 and a["holm"]["holm_significant"] == r["holm"] and a["verdict"] == r["verdict"]
                    and (a["mean_diff"] is None) == (r["mean"] is None)
                    and (r["mean"] is None or abs(a["mean_diff"] - r["mean"]) < 1e-5))
            if not same:
                mism.append(tid)
    check(not mism, "confirmatory_analysis_recompute", f"12 tests (OW1-OW7, H2-H4), mismatches: {mism}")

    comp = Counter(e["experiment_id"] for e in events if e["type"] == "experiment.completed")
    verd = Counter(e["experiment_id"] for e in events if e["type"] in ("experiment.verified", "experiment.rejected")
                   and e["worker_id"] == "evaluator")
    check(max(comp.values(), default=0) <= 1 and max(verd.values(), default=0) <= 1, "no_duplicate_results_or_verdicts",
          f"{len(comp)} completed, {len(verd)} judged")
    pre = {e["experiment_id"]: e["seq"] for e in events if e["type"] == "experiment.preregistered"}
    started = {}
    for e in events:
        if e["type"] == "experiment.started" and e["experiment_id"] not in started:
            started[e["experiment_id"]] = e["seq"]
    check(all(pre.get(k, 10 ** 12) < s for k, s in started.items()), "preregistration_precedes_start", f"{len(started)} started")
    # an adversarial audit attaches a "perfect" claimed summary; it must be rejected unless the claim is
    # in fact true (e.g. every arm really scored 1.0 on a trivial instance), which is checked against raw rows
    import gzip
    claims = {}
    with gzip.open(b / "raw_results.jsonl.gz", "rt") as f:
        for line in f:
            r = json.loads(line)
            if r["result"].get("claimed_means") is not None:
                claims[r["id"]] = r["result"]["claimed_means"]
    adv = [x for x in exps if x["kind"] == "adversarial" and x["state"] in ("REJECTED", "VERIFIED", "PARTIAL")]
    bad_adv = [x["id"] for x in adv if x["state"] != "REJECTED" and not (
        x["id"] in claims and all(abs(claims[x["id"]][a] - x["verdict"]["summary"][a]) <= 1e-9 for a in claims[x["id"]]))]
    true_claims = sum(1 for x in adv if x["state"] != "REJECTED") - len(bad_adv)
    check(not bad_adv, "adversarial_fabrications_rejected",
          f"{len(adv)} audits, {len(adv) - true_claims - len(bad_adv)} rejected, {true_claims} claims that were true, not rejected: {bad_adv[:5]}")
    ow_pre = [x for x in exps if x["family"].startswith("ow_")]
    check(all(x["preregistration"].get("evolution") == "E142" for x in ow_pre), "open_world_experiments_preregistered_E142",
          f"{len(ow_pre)} experiments")

    dp = b / "drills.jsonl"
    drills = jl(dp) if dp.exists() else []
    last = {}
    for d_ in drills:
        if d_["drill"] != "audit":
            last[d_["drill"]] = d_
    earlier_fail = sum(1 for d_ in drills if d_["drill"] != "audit" and not d_.get("pass")) - sum(1 for d_ in last.values() if not d_.get("pass"))
    check({"worker-crash", "kill-switch"} <= set(last) and all(d_.get("pass") for d_ in last.values()), "drills_passed",
          ", ".join(f"latest {k}={v.get('pass')}" for k, v in sorted(last.items())) + f"; earlier failed/invalid records kept: {earlier_fail}")
    gates = json.loads((b / "E142_GATE_MATRIX.json").read_text())
    c = Counter(g["status"] for g in gates["gates"])
    check(dict(c) == gates["summary"] and len(gates["gates"]) >= 34 and set(c) <= {"PASS", "PARTIAL", "BLOCKED", "FAIL"},
          "gate_matrix_consistent", json.dumps(dict(c), sort_keys=True))
    st = json.loads((b / "E142_PUBLIC_SNAPSHOT.json").read_text())["status"]
    check(st["agi"] == "NOT ESTABLISHED" and st["rsi"] == "EXPERIMENTAL" and st["neural_weights_modified"] is False
          and st["independent_reproductions"] == 0 and st["paid_api_usd"] == 0, "status_invariants", json.dumps(st, sort_keys=True))
    for ok_, name, detail in RESULTS:
        print(("PASS " if ok_ else "FAIL ") + name + (f"  [{detail}]" if detail 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__":
    raise SystemExit(main())
