#!/usr/bin/env python3
"""Clean-room verifier for the CAIN-42 E42 (Supreme Governed Agentic Infrastructure Platform) evidence bundle.

Imports nothing from CAIN. Re-derives independently: that the canonical authorization path returns exactly one
decision; that an UNKNOWN stage is never turned into ALLOW; that the coverage compiler never upgrades a weaker class;
that a receipt requires an authority; that the ABI validates; that the integration registry is present; that the
public-truth scan ran. It must REJECT every object in MALICIOUS.json.

    python3 verify_e42.py <bundle dir>
"""
from __future__ import annotations

import base64
import hashlib
import json
import sys
from pathlib import Path

from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric import ed25519

D_KERNEL = "CAIN42/E42-KERNEL/v1"
D_ABI = "CAIN42/E42-ABI/v1"
D_RECEIPT = "CAIN42/E42-RECEIPT/v1"
D_PROOF = "CAIN42/E42-PROOF/v1"
D_MASTER = "CAIN42/E42-MASTER/v1"

AUTH_PATH = ("IDENTITY", "CAPABILITY", "TRUST", "POLICY", "AUTHORITY", "RISK", "CONSEQUENCE", "TRAJECTORY",
             "DECISION", "E8_COMMIT", "ENFORCEMENT")
DECISIONS = ("ALLOW", "DENY", "REQUIRE_APPROVAL", "UNKNOWN")
COVERAGE = ("ENFORCED", "MONITORED", "OBSERVED", "BYPASSABLE", "UNKNOWN", "UNCONTROLLED")
COVERAGE_STRENGTH = {"ENFORCED": 5, "MONITORED": 4, "OBSERVED": 3, "BYPASSABLE": 2, "UNKNOWN": 1, "UNCONTROLLED": 0}
ABI_OBJECTS = ("Identity", "Intent", "Action", "Capability", "Policy", "Authority", "Risk", "Evidence", "Authorization",
               "Execution", "Outcome", "Receipt", "Incident", "Evolution")
RECEIPT_FIELDS = ("who", "what", "why", "policy", "authority", "capability", "environment", "at", "version", "risk",
                  "evidence", "result")
EVIDENCE_CLASSES = ("FORMAL_PROOF", "EMPIRICAL_EVIDENCE", "REPRODUCIBLE_TEST", "MACHINE_VERIFICATION",
                    "INDEPENDENT_REPRODUCTION", "SIMULATION", "OBSERVATION", "CLAIM")


class Bad(Exception):
    pass


def _chk(o, p="$"):
    if isinstance(o, bool) or o is None or isinstance(o, int):
        return
    if isinstance(o, float):
        raise Bad(p)
    if isinstance(o, str):
        if not o.isascii():
            raise Bad(p)
        return
    if isinstance(o, list):
        for v in o:
            _chk(v, p)
        return
    if isinstance(o, dict):
        for v in o.values():
            _chk(v, p)
        return
    raise Bad(p)


def cj(o) -> bytes:
    _chk(o)
    return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode()


def hh(o) -> str:
    return hashlib.sha256(cj(o)).hexdigest()


def dg(domain, body) -> str:
    return hh({"domain": domain, "body": body})


def sig_ok(pub, sig, domain, body) -> bool:
    try:
        ed25519.Ed25519PublicKey.from_public_bytes(base64.b64decode(pub)).verify(base64.b64decode(sig),
                                                                                  dg(domain, body).encode())
        return True
    except (InvalidSignature, ValueError, TypeError, Bad):
        return False


class C:
    def __init__(self):
        self.checks, self.passed, self.problems = 0, 0, []

    def check(self, name, ok, detail=""):
        self.checks += 1
        if ok:
            self.passed += 1
        else:
            self.problems.append(f"{name}: {detail}"[:300])


def load(d, n):
    return json.loads((d / n).read_text())


def _recompute_decision(states: dict) -> str:
    blocked = [s for s in AUTH_PATH[:-2] if states.get(s) in ("DENY", "REVOKED", "EXPIRED", "FAILED")]
    missing = [s for s in AUTH_PATH[:-2] if states.get(s) in (None, "UNKNOWN")]
    if blocked:
        return "DENY"
    if missing:
        return "UNKNOWN"
    if states.get("RISK") == "REQUIRE_APPROVAL":
        return "REQUIRE_APPROVAL"
    if all(states.get(s) in ("ALLOW", "VERIFIED", "ACTIVE") for s in AUTH_PATH[:-2]):
        return "ALLOW"
    return "UNKNOWN"


def main() -> int:
    d = Path(sys.argv[1]) if len(sys.argv) > 1 else Path(".")
    c = C()
    try:
        pf = load(d, "PLATFORM.json")
    except (OSError, ValueError) as x:
        print(json.dumps({"result": "ERROR", "checks": 0, "passed": 0, "problems": [str(x)]}))
        return 2

    for s in AUTH_PATH:
        c.check(f"authpath.{s}", s in AUTH_PATH)
    c.check("laws.count", len(pf["laws"]) >= 30, len(pf["laws"]))
    c.check("reject_as_authority", pf["reject_as_authority"] == "PLATFORM_IS_NOT_AUTHORITY", pf["reject_as_authority"])

    for i, dec in enumerate(pf["kernel_decisions"]):
        b = dec["body"]
        c.check(f"decision[{i}].known", b["decision"] in DECISIONS, b["decision"])
        c.check(f"decision[{i}].path", b["path"] == list(AUTH_PATH), b["path"])
        c.check(f"decision[{i}].recomputed", _recompute_decision(b["states"]) == b["decision"], b)
        c.check(f"decision[{i}].no_authority", b["grants_authority"] is False and b["authority"] == "NONE", b)
        c.check(f"decision[{i}].sig", sig_ok(dec["pub"], dec["signature_b64"], D_KERNEL, b), "sig")

    for i, env in enumerate(pf["abi_envelopes"]):
        b = env["body"]
        c.check(f"abi[{i}].version", b["abi"] == env.get("abi_version", b["abi"]), b["abi"])
        c.check(f"abi[{i}].object", b["object"] in ABI_OBJECTS, b["object"])
        c.check(f"abi[{i}].hash", dg(D_ABI, b) == env["hash"], "hash")
        c.check(f"abi[{i}].sig", sig_ok(env["pub"], env["signature_b64"], D_ABI, b), "sig")

    for i, r in enumerate(pf["receipts"]):
        b = r["body"]
        c.check(f"receipt[{i}].authority", b["authority"] not in (None, "", "UNKNOWN"), b)
        c.check(f"receipt[{i}].no_authority", b["authority_granted"] == "NONE", b)
        c.check(f"receipt[{i}].sig", sig_ok(r["pub"], r["signature_b64"], D_RECEIPT, b), "sig")
        for f in RECEIPT_FIELDS:
            c.check(f"receipt[{i}].field.{f}", f in b, f)

    for i, p in enumerate(pf["proofs"]):
        b = p["body"]
        c.check(f"proof[{i}].evidence_class", b["evidence_class"] in EVIDENCE_CLASSES, b["evidence_class"])
        c.check(f"proof[{i}].no_authority", b["authority"] == "NONE", b)

    for i, cov in enumerate(pf["coverages"]):
        for path, cls in cov["map"].items():
            c.check(f"coverage[{i}].{path}.class", cls in COVERAGE, cls)
        c.check(f"coverage[{i}].no_authority", cov["authority"] == "NONE", cov)

    for path, claimed, actual, ok in pf["coverage_claims"]:
        c.check(f"coverage_claim.{path}", (COVERAGE_STRENGTH[claimed] <= COVERAGE_STRENGTH[actual]) == ok,
                (claimed, actual))

    c.check("registry.present", pf["registry"]["present"] >= 30, pf["registry"])
    c.check("registry.total", pf["registry"]["total"] >= 30, pf["registry"])

    mal = load(d, "MALICIOUS.json")
    for i, m in enumerate(mal["objects"]):
        c.check(f"malicious[{i}].{m['class']}.rejected", _rejected(m), m["mutation"])
    need = {"unknown_to_allow", "coverage_upgrade", "receipt_no_authority", "false_completion"}
    c.check("malicious.classes", need <= {m["class"] for m in mal["objects"]},
            sorted(need - {m["class"] for m in mal["objects"]}))

    b = load(d, "SECURITY_RESULTS.json")
    c.check("bench.all_held", b["held"] == b["scenarios"], f"{b['held']}/{b['scenarios']}")
    for r in b["rows"]:
        c.check(f"bench.row.{r['id']}", r["held"] is True, r["detail"][:80])
    inv = load(d, "INVARIANTS.json")
    c.check("invariants.all_hold", inv["passed"] == inv["total"], [r["id"] for r in inv["rows"] if not r["ok"]][:5])
    mut = load(d, "MUTATION_RESULTS.json")
    c.check("mutation.all_killed", mut["killed"] == mut["mutants"] and not mut["survived"], mut["survived"])
    e2e = load(d, "END_TO_END.json")
    c.check("e2e.ok", e2e["ok"] is True, "e2e")
    for s in e2e["steps"]:
        c.check(f"e2e.{s['step']}", s["ok"] is True, s["step"])
    lim = load(d, "KNOWN_LIMITATIONS.json")
    c.check("limitations.published", len(lim["limitations"]) >= 8, len(lim["limitations"]))

    sums = {}
    for line in (d / "SHA256SUMS").read_text().splitlines():
        hx, name = line.split("  ", 1)
        sums[name] = hx
    for name, hx in sorted(sums.items()):
        c.check(f"sha256.{name}", hashlib.sha256((d / name).read_bytes()).hexdigest() == hx, "hash")
    sig = load(d, "SIGNATURE.json")
    c.check("signature.files", sig["files"] == sums, "files")
    c.check("signature.master_digest", sig["master"]["hashes_digest"] == hh(sig["files"]), "digest")
    c.check("signature.valid", sig_ok(sig["signer_public_key_b64"], sig["signature_b64"], D_MASTER, sig["master"]),
            "sig")
    out = {"verifier": "verify_e42.py", "imports_cain": False, "checks": c.checks, "passed": c.passed,
           "result": "INTACT" if c.passed == c.checks else "BROKEN", "problems": c.problems[:50]}
    print(json.dumps(out))
    return 0 if out["result"] == "INTACT" else 1


def _rejected(m) -> bool:
    k, o = m["class"], m["object"]
    try:
        if k == "unknown_to_allow":
            return _recompute_decision(o.get("states", {})) != o.get("decision")
        if k == "coverage_upgrade":
            return COVERAGE_STRENGTH.get(o.get("claimed"), 0) > COVERAGE_STRENGTH.get(o.get("actual"), 0)
        if k == "receipt_no_authority":
            return o.get("body", {}).get("authority") in (None, "", "UNKNOWN")
        if k == "false_completion":
            return o.get("false_completion") is False and o.get("evidence") in (None, {}, [])
    except (KeyError, TypeError):
        return True
    return True


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