#!/usr/bin/env python3
"""Clean-room verifier for a CAIN Authority Object proof. ZERO CAIN imports.

    python3 authority_verifier.py <AUTHORITY_PROOF.json>

Independently checks that an Authority Object is authentic (hash), attenuated against its parent,
bound to the expected governance epoch / policy / trust / risk, temporally valid, not revoked, backed
by a valid quorum certificate, and evidenced. Exit 0 = verified.
"""
from __future__ import annotations

import hashlib
import json
import sys


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 _subset(child, parent) -> bool:
    return set(child) <= set(parent)


def verify(proof: dict) -> list:
    problems = []
    a = proof.get("authority", {})
    ctx = proof.get("context", {})
    parent = proof.get("parent")
    rev = proof.get("revocation", {})

    if sha(a) != proof.get("authority_hash"):
        problems.append("authority object hash mismatch (authenticity)")

    if parent:
        for dim in ("authority_scope", "resource_scope", "action_scope"):
            if not _subset(a.get(dim, []), parent.get(dim, [])):
                problems.append(f"authority widens parent in {dim}")
        if a.get("tenant_scope") != parent.get("tenant_scope"):
            problems.append("authority changed tenant vs parent")
        if a.get("principal_id") != parent.get("principal_id"):
            problems.append("authority changed principal vs parent")
        if a.get("valid_until", 0) > parent.get("valid_until", 0):
            problems.append("authority outlives parent")
        if a.get("governance_epoch", 0) < parent.get("governance_epoch", 0):
            problems.append("authority epoch regresses vs parent")

    if a.get("governance_epoch") != ctx.get("current_governance_epoch"):
        problems.append("governance epoch mismatch")
    if a.get("policy_version") != ctx.get("current_policy_version"):
        problems.append("policy version invalidated")
    if a.get("trust_state_hash") != ctx.get("current_trust_state_hash"):
        problems.append("trust state mismatch")
    if a.get("risk_state_hash") != ctx.get("current_risk_state_hash"):
        problems.append("risk state mismatch")

    now = ctx.get("now", 0)
    if not (a.get("valid_from", 0) <= now <= a.get("valid_until", 0)):
        problems.append("authority not temporally valid")

    if rev.get("emergency_halt"):
        problems.append("emergency halt active (fail closed)")
    if a.get("authority_id") in set(rev.get("revoked", [])):
        problems.append("authority revoked")
    if a.get("revocation_state"):
        problems.append("authority revocation_state set")

    if a.get("quorum_certificate_hash") not in set(ctx.get("valid_quorum_hashes", [])):
        problems.append("quorum certificate not valid")

    if not a.get("evidence_root"):
        problems.append("evidence missing")
    return problems


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


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