"""CAIN-A75-026 offline verifier (rules embedded verbatim). CAIN-A75-026 WORM evidence rules. Standard library only, no CAIN imports: embedded verbatim in the offline verifier.

A deliverable pack is only evidence if a recipient can see that nothing was removed or edited after export. The review recomputes
a WORM (write-once, read-many) export record:

  export       a named human operator, the exporting system, a format, a creation time and a retention time after creation; a
               legal hold is recorded as an explicit boolean, never inferred
  chain        records are numbered contiguously from 1, have unique ids, are non-decreasing in time, and each one's prev_sha256
               equals the previous record's recomputed record_sha256; the first record starts at the domain genesis
  digests      every record's record_sha256 is recomputed from its own fields, and its subject_sha256 is a SHA-256
  manifest     the manifest states the count, first and last sequence and a root over the record hashes, and those match
  verification the stated recomputed root, checked count and tamper list match what this review recomputed; no record is listed as
               tampered and none was removed
  claims       every boolean the record asserts matches what this review computed

Verdict: SOUND, else UNSOUND with every failing check named. Malformed input is UNSOUND. It reviews the export record; it does not
read the storage system and cannot prove that a record never existed. It proves the package changed or did not change.
"""
from __future__ import annotations

import hashlib
import json
import math
import re

_HEX = re.compile(r"^[0-9a-f]{64}$")
SCHEMA = "cain42.a75.wormevidence.review.v1"
GENESIS = hashlib.sha256(b"cain42.a75.wormevidence.genesis").hexdigest()
MAX_RECORDS = 10000


class Bad(ValueError):
    pass


def _hex(v):
    return isinstance(v, str) and bool(_HEX.match(v))


def _who(v, kinds=("human", "agent", "tool", "org")):
    return isinstance(v, str) and ":" in v and v.split(":", 1)[0] in kinds and bool(v.split(":", 1)[1])


def _num(v):
    return isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v)


def canon(o):
    return json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode()


def record_digest(r):
    body = {k: r.get(k) for k in ("seq", "id", "at", "kind", "subject_sha256", "prev_sha256")}
    return hashlib.sha256(canon(body)).hexdigest()


def root_of(digests):
    return hashlib.sha256("".join(digests).encode()).hexdigest()


def evaluate(record):
    checks, summary = [], {}

    def c(cid, ok, detail=""):
        checks.append({"id": cid, "ok": bool(ok), "detail": detail})

    try:
        if not isinstance(record, dict) or record.get("schema") != SCHEMA:
            raise Bad(f"not a {SCHEMA} record")
        exp, recs, man, ver = record.get("export"), record.get("records"), record.get("manifest"), record.get("verification")
        if not isinstance(exp, dict) or not isinstance(recs, list) or not recs or len(recs) > MAX_RECORDS \
                or not isinstance(man, dict) or not isinstance(ver, dict):
            raise Bad(f"export, 1 to {MAX_RECORDS} records, manifest and verification are required")
        created = exp.get("created_at")
        c("export.operator", _who(exp.get("operator"), ("human",)), f"operator {exp.get('operator')!r}")
        c("export.system", isinstance(exp.get("system"), str) and bool(exp.get("system")), f"system {exp.get('system')!r}")
        c("export.format", exp.get("format") == "cain.worm.v1", f"format {exp.get('format')!r}")
        c("export.created", _num(created) and created > 0, f"created_at {created!r}")
        c("export.retention", _num(exp.get("retention_until")) and _num(created) and exp["retention_until"] > created,
          f"retention {exp.get('retention_until')!r} after {created!r}")
        c("export.legal_hold", isinstance(exp.get("legal_hold"), bool), f"legal_hold {exp.get('legal_hold')!r}")

        ids, prev, digests, times = set(), GENESIS, [], []
        for i, r in enumerate(recs):
            if not isinstance(r, dict) or not isinstance(r.get("id"), str) or not r["id"]:
                raise Bad(f"record {i} needs an id")
            if r["id"] in ids:
                raise Bad(f"record id {r['id']!r} is used twice")
            ids.add(r["id"])
            k = f"record.{r['id']}"
            c(f"{k}.sequence", r.get("seq") == i + 1, f"seq {r.get('seq')!r}, expected {i + 1}")
            c(f"{k}.subject", _hex(r.get("subject_sha256")), f"subject {str(r.get('subject_sha256'))[:16]}")
            c(f"{k}.time", _num(r.get("at")) and (not times or r["at"] >= times[-1]),
              f"at {r.get('at')!r}" + (f", previous {times[-1]!r}" if times else ""))
            d = record_digest(r)
            c(f"{k}.digest", _hex(r.get("record_sha256")) and r.get("record_sha256") == d,
              f"stated {str(r.get('record_sha256'))[:16]}, recomputed {d[:16]}")
            c(f"{k}.link", r.get("prev_sha256") == prev, f"prev {str(r.get('prev_sha256'))[:16]}, expected {prev[:16]}")
            if _num(r.get("at")):
                times.append(r["at"])
            prev = d
            digests.append(d)

        root = root_of(digests)
        c("manifest.count", man.get("count") == len(recs) and not isinstance(man.get("count"), bool),
          f"stated {man.get('count')!r}, recomputed {len(recs)}")
        c("manifest.first_seq", man.get("first_seq") == recs[0].get("seq"), f"stated {man.get('first_seq')!r}")
        c("manifest.last_seq", man.get("last_seq") == recs[-1].get("seq"), f"stated {man.get('last_seq')!r}")
        c("manifest.root", _hex(man.get("root_sha256")) and man.get("root_sha256") == root,
          f"stated {str(man.get('root_sha256'))[:16]}, recomputed {root[:16]}")

        tampered = ver.get("tampered")
        c("verification.root", ver.get("recomputed_root_sha256") == root, f"stated {str(ver.get('recomputed_root_sha256'))[:16]}")
        c("verification.checked", ver.get("entries_checked") == len(recs) and not isinstance(ver.get("entries_checked"), bool),
          f"stated {ver.get('entries_checked')!r}, recomputed {len(recs)}")
        c("verification.no_tampering", isinstance(tampered, list) and tampered == [], f"tampered {tampered!r}")
        c("verification.chain_complete", ver.get("chain_complete") is True, f"chain_complete {ver.get('chain_complete')!r}")

        computed = {"export_well_formed": all(x["ok"] for x in checks if x["id"].startswith("export.")),
                    "chain_intact": all(x["ok"] for x in checks if x["id"].endswith((".sequence", ".digest", ".link", ".time", ".subject"))),
                    "manifest_matches": all(x["ok"] for x in checks if x["id"].startswith("manifest.")),
                    "verification_passed": all(x["ok"] for x in checks if x["id"].startswith("verification."))}
        claims = record.get("claims") if isinstance(record.get("claims"), dict) else {}
        for k in sorted(claims):
            c(f"claims.{k}", k in computed and claims[k] == computed[k], f"claimed {claims[k]!r}, computed {computed.get(k)!r}")
        summary.update({"computed": computed, "records": len(recs), "root_sha256": root,
                        "first_seq": recs[0].get("seq"), "last_seq": recs[-1].get("seq"),
                        "retention_until": exp.get("retention_until"), "legal_hold": exp.get("legal_hold")})
    except Bad as e:
        checks.append({"id": "input.well_formed", "ok": False, "detail": str(e)})
        return "UNSOUND", checks, summary
    except Exception as e:  # noqa: BLE001
        checks.append({"id": "input.error", "ok": False, "detail": f"{type(e).__name__}: {e}"[:200]})
        return "UNSOUND", checks, summary
    return ("SOUND" if all(x["ok"] for x in checks) else "UNSOUND"), checks, summary


# ---------------------------------------------------------------------------- offline verifier (no CAIN imports)
# Every name below is prefixed _kit_verifier_ / _b64 / _hl / _json / _sys so it cannot shadow a name in the rules above.
import base64 as _b64, hashlib as _hl, json as _json, sys as _sys
_KIT_VERIFIER_GENESIS = _hl.sha256(b"cain42.a75.wormevidence.genesis").hexdigest()


def _kit_verifier_canon(o):
    return _json.dumps(o, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode()


def _kit_verifier_sha(o):
    return _hl.sha256(_kit_verifier_canon(o)).hexdigest()


def _kit_verifier_main(argv):
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
    if len(argv) < 2:
        print("usage: verify_offline.py run.json --pinned-key BASE64"); return 2
    run = _json.load(open(argv[1]))
    pin = argv[argv.index("--pinned-key") + 1] if "--pinned-key" in argv else None
    problems, prev, recs = [], _KIT_VERIFIER_GENESIS, run.get("records") or []
    for i, r in enumerate(recs):
        body = {k: v for k, v in r.items() if k not in ("record_hash", "signature_b64")}
        if _kit_verifier_sha(body) != r.get("record_hash"): problems.append(f"record {i}: record_hash does not match")
        if body.get("subject_sha256") != _kit_verifier_sha(body.get("subject")): problems.append(f"record {i}: subject_sha256 does not match")
        if pin and r.get("public_key_b64") != pin: problems.append(f"record {i}: different key than the pinned one")
        try:
            Ed25519PublicKey.from_public_bytes(_b64.b64decode(pin or r.get("public_key_b64"))).verify(
                _b64.b64decode(r.get("signature_b64", "")), str(r.get("record_hash")).encode())
        except Exception:
            problems.append(f"record {i}: signature does not verify")
        if r.get("prev_record_hash") != prev: problems.append(f"record {i}: chain link broken")
        v, checks, _ = evaluate(r.get("subject"))
        if v != r.get("verdict") or checks != r.get("checks"):
            problems.append(f"record {i}: re-running the rules gives {v}, the record says {r.get('verdict')}")
        prev = r.get("record_hash")
    if run.get("run_hash") != _kit_verifier_sha([r.get("record_hash") for r in recs]): problems.append("run_hash does not match")
    for p in problems: print("  -", p)
    if not pin: print("WARNING: no --pinned-key given; the signature was checked against the key inside the file")
    print("VERDICT:", "VERIFIED" if not problems else "TAMPERED OR INVALID", f"(CAIN-A75-026, {len(recs)} record(s), verdicts {run.get('verdicts')})")
    return 0 if not problems else 1


if __name__ == "__main__":
    _sys.exit(_kit_verifier_main(_sys.argv))
