#!/usr/bin/env python3
"""E24 clean-room Frontier substrate verifier. ZERO CAIN imports.

    python3 verifier.py <E24_SUBSTRATE_PROOF.json>

Independently recomputes the domain-separated Frontier state root and re-checks envelope attenuation,
authority conservation, composition-graph validity, matrix results and invariant counts.
Exit 0 = verified, 1 = failure.
"""
from __future__ import annotations

import hashlib
import json
import sys

DOMAIN = "CainE24.frontier-state.v1"
DIMENSIONS = ("identity", "authorization", "policy", "risk", "capability", "evidence",
              "execution", "provenance", "transaction", "recovery", "reputation", "environment")


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 _leaf(name, root) -> str:
    return sha({"domain": DOMAIN, "dimension": name, "root": root})


def global_root(dims: dict) -> str:
    leaves = sorted(_leaf(n, dims.get(n)) for n in DIMENSIONS)
    aggregate = sha({"dimensions": [dims.get(n) for n in DIMENSIONS]})
    return sha({"leaves": leaves, "aggregate": aggregate})


def verify(proof: dict) -> list:
    problems = []

    sr = proof.get("state_root", {})
    if global_root(sr.get("dimensions", {})) != sr.get("global_root"):
        problems.append("Frontier state root recomputation mismatch")

    parent = proof.get("envelope", {}).get("parent", proof.get("envelope", {}))
    child = proof.get("child_envelope", {})
    if parent and child:
        if not set(child.get("requested_capability", [])) <= set(parent.get("requested_capability", [])):
            problems.append("envelope expanded capability")
        if not set(child.get("resource", [])) <= set(parent.get("resource", [])):
            problems.append("envelope expanded resource")
        if child.get("tenant") != parent.get("tenant"):
            problems.append("envelope changed tenant")

    graph = proof.get("graph", {})
    if not graph.get("ok", False):
        problems.append("composition graph has violations")

    chain = proof.get("authority_chain", {})
    if not chain.get("conserved", False):
        problems.append("authority conservation violated")

    matrix = proof.get("matrix", {})
    if matrix and not (matrix.get("succeeded") == matrix.get("executed") and matrix.get("authority_conserved")):
        problems.append("matrix execution/conservation mismatch")

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

    if not proof.get("registry_count") == 20:
        problems.append("registry does not cover 20 products")
    return problems


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


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