"""CAIN 42 -- zero-import Independent Provenance Verifier.

Never imports cain_supply_chain_provenance_42.py (production). For every
link marked `independently_recomputable`, this module RECOMPUTES the value
from the live filesystem/git (not from any cached record) and compares.
Links marked NOT independently recomputable are reported as ATTESTED, not
VERIFIED -- the distinction is never blurred.
"""

from __future__ import annotations

import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any, Dict, List

try:
    from cryptography.hazmat.primitives.asymmetric import ed25519
    from cryptography.exceptions import InvalidSignature
    HAS_ED25519 = True
except ImportError:
    HAS_ED25519 = False

KNOWN_ALGORITHMS = {"Ed25519-SHA256"}


class LinkVerdict:
    VERIFIED = "VERIFIED"        # independently recomputed and matches
    MISMATCH = "MISMATCH"        # independently recomputed and DOES NOT match
    ATTESTED = "ATTESTED"        # not independently recomputable this way -- recorded, not verified
    ERROR = "ERROR"


def _canonical_bytes(obj: Any) -> bytes:
    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False, default=str).encode("utf-8")


def _sha256_hex(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def verify_manifest_signature(manifest: Dict[str, Any]) -> Dict[str, Any]:
    required = ("manifest_id", "links", "generated_at", "schema_version", "signature", "algorithm", "parent_public_key_b64")
    missing = [f for f in required if f not in manifest]
    if missing:
        return {"verdict": "INVALID", "reason": f"TRUNCATED_MANIFEST: missing {missing}"}
    if manifest.get("algorithm") not in KNOWN_ALGORITHMS:
        return {"verdict": "INVALID", "reason": f"UNKNOWN_OR_UNSUPPORTED_ALGORITHM: '{manifest.get('algorithm')}'"}
    if not manifest.get("signature") or not manifest.get("parent_public_key_b64"):
        return {"verdict": "INVALID", "reason": "UNSIGNED_MANIFEST"}
    if not HAS_ED25519:
        return {"verdict": "INSUFFICIENT_EVIDENCE", "reason": "ED25519_UNAVAILABLE"}
    d = {"manifest_id": manifest["manifest_id"], "links": manifest["links"], "generated_at": manifest["generated_at"], "schema_version": manifest["schema_version"]}
    digest_hex = _sha256_hex(_canonical_bytes(d))
    try:
        public_key = ed25519.Ed25519PublicKey.from_public_bytes(bytes.fromhex(manifest["parent_public_key_b64"]))
        public_key.verify(bytes.fromhex(manifest["signature"]), bytes.fromhex(digest_hex))
        return {"verdict": "VALID", "reason": "SIGNATURE_VALID"}
    except (InvalidSignature, ValueError) as e:
        return {"verdict": "INVALID", "reason": f"SIGNATURE_INVALID: {type(e).__name__}"}


def verify_links(links: List[Dict[str, Any]], repo_root: str) -> List[Dict[str, Any]]:
    repo_root_path = Path(repo_root)
    results = []
    for link in links:
        stage = link.get("stage")
        claimed_hash = link.get("hash_value")
        if not link.get("independently_recomputable", False):
            results.append({"stage": stage, "identifier": link.get("identifier"), "verdict": LinkVerdict.ATTESTED, "claimed_hash": claimed_hash})
            continue
        try:
            if stage == "SOURCE" and link.get("identifier") == "git_commit":
                actual = subprocess.run(["git", "rev-parse", "HEAD"], cwd=repo_root, capture_output=True, text=True, check=True).stdout.strip()
            elif stage in ("DEPENDENCY_LOCK", "CONFIGURATION"):
                actual = hashlib.sha256((repo_root_path / link["identifier"]).read_bytes()).hexdigest()
            else:
                results.append({"stage": stage, "identifier": link.get("identifier"), "verdict": LinkVerdict.ERROR, "reason": f"no independent recompute method known for stage '{stage}'"})
                continue
            verdict = LinkVerdict.VERIFIED if actual == claimed_hash else LinkVerdict.MISMATCH
            results.append({"stage": stage, "identifier": link.get("identifier"), "verdict": verdict, "claimed_hash": claimed_hash, "recomputed_hash": actual})
        except Exception as e:
            results.append({"stage": stage, "identifier": link.get("identifier"), "verdict": LinkVerdict.ERROR, "reason": f"{type(e).__name__}: {e}"})
    return results


def verify_provenance_manifest(manifest: Dict[str, Any], repo_root: str) -> Dict[str, Any]:
    sig_result = verify_manifest_signature(manifest)
    if sig_result["verdict"] != "VALID":
        return {"overall_verdict": sig_result["verdict"], "signature": sig_result, "links": []}
    link_results = verify_links(manifest.get("links", []), repo_root)
    any_mismatch = any(r["verdict"] == LinkVerdict.MISMATCH for r in link_results)
    any_error = any(r["verdict"] == LinkVerdict.ERROR for r in link_results)
    overall = "INVALID" if any_mismatch else ("PARTIAL" if any_error else "VALID")
    return {"overall_verdict": overall, "signature": sig_result, "links": link_results}
