#!/usr/bin/env python3
"""E117 standalone verifier. Standard library only; imports no CAIN code."""
from __future__ import annotations

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

C = []


def check(n, ok, d=""):
    C.append((n, bool(ok), str(d)))


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)]
    return min(1.0, sum(p for p in probs if p <= probs[ao] + 1e-15))


def main():
    root = Path(sys.argv[1] if len(sys.argv) > 1 else ".")
    import ast
    tree = ast.parse(Path(__file__).read_text()); banned = []
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            banned += [a.name for a in node.names if a.name.split(".")[0] == "cain"]
        elif isinstance(node, ast.ImportFrom) and (node.module or "").split(".")[0] == "cain":
            banned.append(node.module)
    check("verifier imports no CAIN code", not banned, banned)
    man = json.loads((root / "MANIFEST.json").read_text())
    bad = [r for r, h in man["files"].items()
           if not (root / r).exists() or hashlib.sha256((root / r).read_bytes()).hexdigest() != h]
    check(f"manifest hashes ({len(man['files'])})", not bad, bad[:5])

    d = json.loads((root / "E117_RAW_RESULTS.json").read_text())
    base, o, si, wm, tr, col, gates = d["baseline"], d["ood"], d["self_improvement"], d["world_model"], d["transfer"], d["collective"], d["gates"]
    check("E116 baseline reproduced", base["e116"]["tests_passed"] == 6 and base["e116"]["verifier"] == "54/54", base["e116"])
    check("E115 baseline reproduced", base["e115"]["tests_passed"] == 18 and base["e115"]["verifier"] == "7/7", base["e115"])

    pr = o["primary"]
    # recompute primary from raw rows
    f = o["raw"]["sealed"]["F_full"]; e = o["raw"]["sealed"][pr["strongest_baseline"]]
    fa = [r["correct"] for r in f]; ea = [r["correct"] for r in e]
    check("primary accuracy recomputed", round(sum(fa) / len(fa), 4) == pr["full_accuracy"], (sum(fa), len(fa)))
    check("primary gain >= 0.15", pr["gain"] >= 0.15, pr["gain"])
    check("primary p < 0.01", pr["mcnemar_p"] < 0.01, pr["mcnemar_p"])
    check("primary replicated p < 0.05", pr["second_p"] < 0.05 and pr["second_gain"] >= 0.15, pr["second_p"])
    check("three capabilities implemented", len(o["capabilities"]) == 3)
    check("at least two capabilities pass sealed", sum(1 for c in o["capabilities"].values() if c["passed"]) >= 2,
          [c["passed"] for c in o["capabilities"].values()])
    check("memory beats no memory", o["memory"]["full_with_memory"] > o["memory"]["full_no_memory"] and
          o["memory"]["mcnemar_memory_vs_none"] < 0.05, o["memory"])
    check("memory survives restart", o["memory"]["restart_retained"] > 0.9, o["memory"]["restart_retained"])
    check("poison rejected", o["memory"]["poison_rejected"] is True)
    check("sealed hash frozen before scoring", "sealed" in o["prereg"]["split_hashes"], o["prereg"].get("split_hashes"))

    check("transfer supported", tr["counts"]["statistically_supported"] >= 2, tr["counts"])
    check("harmful transfer rejected", tr["counts"]["negative_transfer_rejected"] >= 1, tr["counts"])
    check("collective complementary routing beats single specialist",
          col["arms"]["C_specialist_team_routed"]["accuracy"] > col["arms"]["A_best_single_agent"]["accuracy"], col["arms"])
    check("self-improvement is a published negative, not promoted",
          si["status"] == "REJECTED" and si["promotion"]["enabled"] is False, si["status"])
    learned = [r for r in wm["results"] if r["model"] != "symbolic_oracle"]
    best = max(learned, key=lambda r: r["accuracy"])
    table = next(r for r in learned if r["model"] == "learned_table")
    check("best learned world model beats table", best["accuracy"] > table["accuracy"], (best["accuracy"], table["accuracy"]))
    check("world-model shift detected", wm["shift"]["shift_detected"] > 0)
    check("world-model false alarms disclosed", wm["false_alarms_stationary"] >= 0)

    valid = {"PASS", "PARTIAL", "FAIL", "BLOCKED", "NOT TESTED"}
    check("gate statuses valid", all(v["status"] in valid for v in gates.values()))
    counts = {}
    for v in gates.values(): counts[v["status"]] = counts.get(v["status"], 0) + 1
    check("gate counts consistent", counts == json.loads((root / "E117_GATE_MATRIX.json").read_text())["counts"], counts)
    check("primary gate PASS", gates["G6_primary_ood"]["status"] == "PASS")
    check("six-hour gate not PASS", gates["G13_six_hour"]["status"] != "PASS", gates["G13_six_hour"]["status"])
    check("external review BLOCKED", gates["G16_external_review"]["status"] == "BLOCKED")
    check("independent administration BLOCKED", gates["G17_independent_admin"]["status"] == "BLOCKED")
    check("no AGI claim", "NOT" in d["claim"] or "not" in d["claim"], d["claim"])

    passed = sum(1 for _, ok, _ in C if ok)
    for n, ok, x in C:
        print(("PASS " if ok else "FAIL ") + n + (f" [{x}]" if (not ok and x) else ""))
    print(f"\n{passed}/{len(C)} checks passed")
    return 0 if passed == len(C) else 1


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