#!/usr/bin/env python3
"""Clean-room verifier for the CAIN-42 E36 (Machine Agency Exchange Fabric) evidence bundle.

Imports nothing from CAIN; only `cryptography` and the standard library. Re-derives, from the published artifacts
alone, the E36 invariants: that no economic object (identity, passport, contract, bid, reputation, payment, price,
receipt) is ever authority; that discovery never upgrades UNKNOWN to MATCH; that a subcontractor cannot exceed its
parent; that substitution, recovery and version changes require revalidation; that receipts require an E8 commit; and
that the exchange is not a bank, custodian or regulator. It must REJECT every object in MALICIOUS.json.

    python3 verify_e36.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

DOMAINS = {k: "CAIN42/E36-" + k + "/v1" for k in (
    "SERVICE-PASSPORT", "CONTRACT", "RECEIPT", "PAYMENT-AUTHORIZATION", "SERVICE-CERT", "DESCRIPTOR", "WARRANTY",
    "SERVICE-CHAIN-PROOF", "MARKETPLACE")}
D_MASTER = "CAIN42/E36-MASTER/v1"
MATCH_CLASSES = ("MATCH", "PARTIAL_MATCH", "UNKNOWN", "NON_COMPLIANT")
DISPUTE_STATES = ("OPEN", "UNDER_REVIEW", "EVIDENCE_REQUIRED", "MEDIATION", "RESOLVED", "ESCALATED", "UNKNOWN")
ESCROW_STATES = ("FUNDS_COMMITTED", "CONDITIONS", "EXECUTION", "PROOF", "VERIFICATION", "SETTLEMENT", "DISPUTE")
CONTRACT_SECTIONS = ("parties", "identities", "capabilities", "objectives", "obligations", "prohibitions",
                     "permissions", "resource_limits", "time_limits", "budget", "evidence_requirements",
                     "proof_requirements", "security_requirements", "escalation", "revocation", "dispute", "recovery",
                     "termination")
PASSPORT_FIELDS = ("service_id", "owner_id", "operator_id", "agent_id", "model_id", "runtime_id", "capability_set",
                   "governance_profile", "conformance_profile", "proof_profile", "service_version", "uptime_evidence",
                   "incident_history", "recovery_history", "security_history", "pricing_model", "supported_protocols",
                   "authorization_model", "revocation_endpoint", "service_limits", "unknown_surface")
RECEIPT_FIELDS = ("buyer", "seller", "agent", "service", "contract", "authorization", "action", "e8_commit",
                  "execution", "proof", "outcome", "settlement", "fees", "disputed", "verification_state")
AGENCY_NODES = ("agent", "service", "organization", "capability", "contract", "transaction", "proof", "identity",
                "authority", "tool", "model", "runtime", "resource", "incident", "payment", "dispute")
AGENCY_EDGES = ("HIRES", "DELEGATES", "CONTRACTS", "EXECUTES", "PROVES", "VERIFIES", "PAYS", "DEPENDS_ON",
                "SUBCONTRACTS", "REVOKES", "RECOVERS", "REVIEWS")
BREAK_STEPS = ("DETECT", "SCORE", "FREEZE_OPTIONAL_AUTHORITY", "PRESERVE_EVIDENCE", "ISOLATE",
               "REVOKE_IF_AUTHORIZED", "INVESTIGATE", "RECOVER", "REAUTHORIZE")
ATTACKS = ("sybil", "collusion", "fake_reputation", "bid_manipulation", "transaction_splitting", "budget_exhaustion",
           "escrow_manipulation", "contract_ambiguity", "subcontracting_abuse", "identity_rotation",
           "service_substitution", "capability_laundering", "governance_laundering")


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

    # ---- laws + lifecycle ----
    c.check("laws.count_30", len(ex["laws"]) == 30, len(ex["laws"]))
    c.check("reject_as_authority", ex["reject_as_authority"] == "EXCHANGE_IS_NOT_AUTHORITY", ex["reject_as_authority"])
    for i, s in enumerate(ex["lifecycle"]):
        c.check(f"lifecycle[{i}]", s in ex["lifecycle"], s)

    # ---- passports ----
    for i, p in enumerate(ex["passports"]):
        b = p["body"]
        c.check(f"passport[{i}].sig", sig_ok(p["pub"], p["signature_b64"], DOMAINS["SERVICE-PASSPORT"], b), "sig")
        c.check(f"passport[{i}].no_authority", b["grants_authority"] is False and b["authority"] == "NONE", b)
        c.check(f"passport[{i}].unknowns", bool(b["unknown_surface"]), b.get("unknown_surface"))
        for f in PASSPORT_FIELDS:
            c.check(f"passport[{i}].field.{f}", f in b, f)
    for m in ex["passport_missing"]:
        c.check(f"passport.missing.{m['field']}", m["refused"] is True, m)

    # ---- discovery / match ----
    for i, m in enumerate(ex["match_cases"]):
        c.check(f"match[{i}].class", m["result"] in MATCH_CLASSES, m["result"])
    c.check("match.unknown_never_match", all(m["result"] != "MATCH" for m in ex["match_cases"]
                                             if m["expect"] == "UNKNOWN"), ex["match_cases"])
    for i, f in enumerate(ex["discovery"]):
        c.check(f"discovery[{i}].no_authority", f["authority"] == "NONE", f)
        c.check(f"discovery[{i}].unknown_not_match", all(x not in f["matches"] for x in f["unknown"]), f)

    # ---- contracts ----
    for i, ct in enumerate(ex["contracts"]):
        b = ct["body"]
        c.check(f"contract[{i}].sig", sig_ok(ct["pub"], ct["signature_b64"], DOMAINS["CONTRACT"], b), "sig")
        c.check(f"contract[{i}].no_authority", b["authority_created"] is False, b)
        for s in CONTRACT_SECTIONS:
            c.check(f"contract[{i}].section.{s}", s in b, s)
    for m in ex["contract_missing"]:
        c.check(f"contract.missing.{m['section']}", m["refused"] is True, m)
    for i, r in enumerate(ex["contract_compile"]):
        c.check(f"compiler[{i}].status", r["status"] in ("COMPILED", "ESCALATE"), r["status"])
        c.check(f"compiler[{i}].ambiguous_not_guessed", r["ambiguous"] is False or r["status"] == "ESCALATE", r)

    # ---- negotiation ----
    for i, n in enumerate(ex["negotiations"]):
        c.check(f"negotiation[{i}].no_authority", n["authority_created"] is False, n)
        if n["status"] == "GOVERNANCE_UNKNOWN":
            c.check(f"negotiation[{i}].unknown", bool(n["unknown_items"]), n)

    # ---- reputation provenance ----
    for i, r in enumerate(ex["reputation"]):
        c.check(f"reputation[{i}].provenance", all(r.get(k) for k in ("event", "evidence", "proof", "verifier")), r)
        c.check(f"reputation[{i}].no_authority", r["authority"] == "NONE", r)
    c.check("reputation.no_self_review", ex["reputation_self_review"] is True, ex["reputation_self_review"])

    # ---- payment / receipts / escrow ----
    for i, p in enumerate(ex["payments"]):
        c.check(f"payment[{i}].non_replayable", "PAYMENT_REPLAY" in p["replay"] or p["first"] == [], p)
        c.check(f"payment[{i}].no_execution_authority", p["authorizes_execution"] is False, p)
    for i, r in enumerate(ex["receipts"]):
        b = r["body"]
        c.check(f"receipt[{i}].requires_e8", b["e8_commit"] not in (None, "", "UNKNOWN"), b["e8_commit"])
        c.check(f"receipt[{i}].synthetic_units", b["units"] == "SYNTHETIC TEST UNITS", b["units"])
        c.check(f"receipt[{i}].sig", sig_ok(r["pub"], r["signature_b64"], DOMAINS["RECEIPT"], b), "sig")
    c.check("escrow.not_custodial", ex["escrow"]["custodial"] is False and ex["escrow"]["bank"] is False, ex["escrow"])

    # ---- dispute / arbitration ----
    for s in DISPUTE_STATES:
        c.check(f"dispute.state.{s}", s in DISPUTE_STATES)
    for i, x in enumerate(ex["disputes"]):
        c.check(f"dispute[{i}].legal_judgment", x["legal_judgment"] is False, x)
    c.check("arbitration.not_binding", ex["arbitration"]["legally_binding"] is False, ex["arbitration"])

    # ---- bidding / auction ----
    for i, sel in enumerate(ex["bid_selections"]):
        c.check(f"bid[{i}].governance_gate_first", sel["selected"] == "governed", sel)
    c.check("auction.sealed_only", ex["auction"]["sealed"] is True and ex["auction"]["authorizes"] is False, ex["auction"])

    # ---- subcontract / supply chain / chain proof ----
    for i, s in enumerate(ex["subcontracts"]):
        c.check(f"subcontract[{i}].no_amplification", s["allowed"] is False or
                s.get("amplified") is False, s)
    c.check("supply.no_authority", ex["supply_chain"]["authority"] == "NONE", ex["supply_chain"])
    c.check("chainproof.complete", ex["chain_proof"]["body"]["complete"] is True, ex["chain_proof"])

    # ---- firebreak / internal service / safe mode ----
    c.check("firebreak.no_confiscation", ex["firebreak"]["confiscated_assets"] is False and
            ex["firebreak"]["is_financial_regulator"] is False, ex["firebreak"])
    c.check("firebreak.steps", [s["step"] for s in ex["firebreak"]["steps"]] == list(BREAK_STEPS), "steps")
    for i, x in enumerate(ex["internal_refused"]):
        c.check(f"internal[{i}].cain_self_governance", x["refused"] is True, x)
    c.check("safemode.no_authority_increase", ex["safe_mode"]["authority_increased"] is False, ex["safe_mode"])

    # ---- graphs ----
    for i, n in enumerate(ex["agency_nodes"]):
        c.check(f"agency.node[{i}]", n in AGENCY_NODES, n)
    for i, e in enumerate(ex["agency_edges"]):
        c.check(f"agency.edge[{i}]", e in AGENCY_EDGES, e)

    # ---- MALICIOUS rejection ----
    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 = {"match_unknown_upgraded", "passport_authority", "contract_authority", "payment_replay",
            "subcontract_amplification", "self_review", "budget_no_exhaustion", "safe_mode_authority",
            "receipt_without_e8", "collective_union", "substitution_silent", "compiler_guesses",
            "firebreak_confiscation", "cain_self_override", "discovery_drops_unknown"}
    c.check("malicious.classes", need <= {m["class"] for m in mal["objects"]},
            sorted(need - {m["class"] for m in mal["objects"]}))

    # ---- bench / invariants / mutation ----
    b = load(d, "SECURITY_RESULTS.json")
    c.check("bench.all_held", b["held"] == b["scenarios"], f"{b['held']}/{b['scenarios']}")
    c.check("bench.at_least_3000", b["scenarios"] >= 3000, b["scenarios"])
    c.check("bench.categories", len(b["categories"]) >= 40, len(b["categories"]))
    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.at_least_700", inv["total"] >= 700, inv["total"])
    c.check("invariants.all_hold", inv["passed"] == inv["total"], [r["id"] for r in inv["rows"] if not r["ok"]][:5])
    c.check("invariants.30_laws", all(f"E36-L{i}" in {r["id"] for r in inv["rows"]} for i in range(1, 31)), "laws")
    mut = load(d, "MUTATION_RESULTS.json")
    c.check("mutation.all_killed", mut["killed"] == mut["mutants"] and not mut["survived"], mut["survived"])
    c.check("mutation.at_least_10", mut["mutants"] >= 10, mut["mutants"])

    sc = load(d, "SCALE_RESULTS.json")
    c.check("scale.synthetic_label", "SYNTHETIC" in sc["classification"], sc["classification"])
    got = {(r["dimension"], r["size"]) for r in sc["rows"]}
    for need_row in [("agents", n) for n in (10, 100, 1000, 10000, 100000)] + \
                    [("operations", n) for n in (1000, 10000, 100000, 1000000, 10000000)] + \
                    [("trust_domains", n) for n in (1, 10, 100, 1000)]:
        c.check(f"scale.{need_row[0]}.{need_row[1]}", need_row in got, "missing")

    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"])

    reg = load(d, "REGISTERS.json")
    c.check("registers.settlement_synthetic", reg["settlement"]["units"] == "SYNTHETIC TEST UNITS", reg["settlement"])
    c.check("registers.not_custodial", reg["settlement"]["custodial"] is False and reg["settlement"]["bank"] is False,
            reg["settlement"])
    c.check("registers.no_insurance", reg["settlement"]["insurance"] is False and
            reg["settlement"]["underwriting"] is False, reg["settlement"])
    for m, v in reg["moat_graph"]["moats"].items():
        c.check(f"moat.{m}.not_market", v["market_moat"] == "NOT ESTABLISHED", m)
    lim = load(d, "KNOWN_LIMITATIONS.json")
    c.check("limitations.published", len(lim["limitations"]) >= 8, len(lim["limitations"]))
    cl = load(d, "E36_PUBLIC_CLAIMS.json")
    c.check("claims.present", len(cl["claims"]) >= 5, len(cl["claims"]))

    # ---- hashes + signature ----
    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_e36.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 == "match_unknown_upgraded":
            return o.get("result") == "MATCH" and o.get("expect") == "UNKNOWN"
        if k == "passport_authority":
            return o.get("grants_authority") is True
        if k == "contract_authority":
            return o.get("authority_created") is True
        if k == "payment_replay":
            return o.get("replay_used") is True
        if k == "subcontract_amplification":
            return o.get("amplified") is True
        if k == "self_review":
            return o.get("self_review_accepted") is True
        if k == "budget_no_exhaustion":
            return o.get("exhausted") is False
        if k == "safe_mode_authority":
            return o.get("authority_increased") is True
        if k == "receipt_without_e8":
            return o.get("e8_commit") in (None, "", "UNKNOWN")
        if k == "collective_union":
            return o.get("sum_of_authorities") is True
        if k == "substitution_silent":
            return o.get("silent") is True or o.get("allowed") is True and o.get("failed")
        if k == "compiler_guesses":
            return o.get("ambiguous") is True and o.get("status") == "COMPILED"
        if k == "firebreak_confiscation":
            return o.get("confiscated_assets") is True
        if k == "cain_self_override":
            return o.get("refused") is False or o.get("governed") is False
        if k == "discovery_drops_unknown":
            return o.get("unknown") == [] and o.get("result") == "MATCH"
    except (KeyError, TypeError):
        return True
    return True


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