#!/usr/bin/env python3
"""E26 clean-room settlement verifier. ZERO CAIN imports.

    python3 verifier.py <E26_SETTLEMENT_PROOF.json>

Independently reconstructs the settlement root, lineage hash and certificate hash, re-checks authority
conservation, quorum, epistemic classification, observation provenance and double-entry accounting,
and verifies Ed25519 signatures. Exit 0 = verified, 1 = failure.
"""
from __future__ import annotations

import base64
import hashlib
import json
import sys

try:
    from cryptography.exceptions import InvalidSignature
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
except Exception:  # pragma: no cover
    Ed25519PublicKey = None

REQUIRED_LINEAGE_KINDS = ("PRINCIPAL", "IDENTITY", "INTENT", "POLICY", "AUTHORIZATION", "STATE",
                          "CAPABILITY", "ACTION", "EXECUTION", "OBSERVATION", "OUTCOME",
                          "CONSEQUENCE", "ADAPTATION", "SETTLEMENT")


def canon(d) -> bytes:
    return json.dumps(d, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")


def sha(d) -> str:
    return hashlib.sha256(canon(d)).hexdigest()


def _verify_sig(pub_b64: str, payload: dict, sig_b64: str) -> bool:
    if Ed25519PublicKey is None:
        return False
    try:
        Ed25519PublicKey.from_public_bytes(base64.b64decode(pub_b64)).verify(
            base64.b64decode(sig_b64), canon(payload))
        return True
    except (InvalidSignature, ValueError, KeyError):
        return False


def verify(proof: dict) -> list:
    problems = []
    s = proof.get("settlement", {})
    if not s:
        return ["settlement missing"]
    if sha(s) != proof.get("settlement_root"):
        problems.append("settlement root mismatch")

    # epistemic safety
    if s.get("outcome_layer") != "OBSERVED":
        problems.append(f"settlement outcome layer is {s.get('outcome_layer')!r}, not OBSERVED")

    # authority conservation
    before, granted, after = set(s.get("authority_before", [])), set(s.get("authority_granted", [])), set(s.get("authority_after", []))
    if not after <= (before | granted):
        problems.append(f"authority expanded: {sorted(after - (before | granted))}")

    # quorum
    qc = s.get("quorum_certificate", {})
    if not qc.get("valid") or int(qc.get("valid_signers", 0)) < int(qc.get("threshold", 1)):
        problems.append("quorum certificate not valid")

    # lineage
    nodes = proof.get("lineage_nodes", [])
    if sha(nodes) != proof.get("lineage_hash"):
        problems.append("lineage hash mismatch")
    kinds = {n.get("kind") for n in nodes}
    for k in REQUIRED_LINEAGE_KINDS:
        if k not in kinds:
            problems.append(f"lineage missing kind {k}")

    # certificate
    env = proof.get("certificate", {})
    body = env.get("certificate")
    if body is None:
        problems.append("execution certificate missing")
    else:
        if sha(body) != env.get("payload_hash"):
            problems.append("certificate payload hash mismatch")
        if not _verify_sig(env.get("public_key_b64", ""), body, env.get("signature_b64", "")):
            problems.append("certificate signature invalid")
        if body.get("settlement_root") != proof.get("settlement_root"):
            problems.append("certificate does not bind the settlement root")

    # observation provenance
    for rec in proof.get("observations", []):
        obs = {k: v for k, v in rec.get("obs", {}).items()}
        sig = rec.get("sig", "")
        payload = {k: v for k, v in obs.items() if k != "signature_b64"}
        if sig and not _verify_sig(rec.get("pub", ""), payload, sig):
            problems.append(f"observation signature invalid for {obs.get('node_id')}")

    # accounting
    acc = proof.get("accounting", {})
    if acc and not (int(acc.get("credits", 0)) == int(acc.get("debits", 0)) + int(acc.get("remaining", 0)) and int(acc.get("remaining", 0)) >= 0):
        problems.append("double-entry accounting not conserved")

    # invariants / adversarial counts
    inv = proof.get("invariants", {})
    if inv and inv.get("passed") != inv.get("total"):
        problems.append("invariant failures present")
    return problems


def main(argv: list) -> int:
    if len(argv) < 2:
        print("usage: verifier.py <E26_SETTLEMENT_PROOF.json>", file=sys.stderr)
        return 2
    proof = json.load(open(argv[1], encoding="utf-8"))
    problems = verify(proof)
    if problems:
        print("E26 PROOF FAILED:")
        for p in problems:
            print("  -", p)
        return 1
    print("E26 SETTLEMENT PROOF VERIFIED (independent reconstruction)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv))
