"""CAIN-A75-046 offline verifier (rules embedded verbatim). CAIN-A75-046 ontology-and-policy rules. Standard library only, no CAIN imports: embedded verbatim in the offline verifier.

A regulated-industry agent grounds its decisions in a business ontology (explicit relationships between entities). The
package claims every decision rested on a governed ontology version. The review recomputes it:

  versions    every version's content hash equals SHA-256 of its canonical relationship set recomputed here; each version
              chains to the one before it (id and hash); each has a named human owner and strictly later effective time
  review      every relationship marked regulated that is new or changed in a version was reviewed by a named human other
              than the owner, before the version took effect
  decisions   every decision names a version and that version's hash; the version was the one in effect at decision time;
              every relationship the decision relied on exists in that version; regulated decisions rely only on reviewed
              (or inherited, previously reviewed) regulated relationships
  drift       when a later version removes or changes a relationship an open decision relied on, the decision has a
              re-evaluation under that later version, made after it took effect
  claims      every boolean the package asserts matches what this review computed

Verdict: SOUND, else UNSOUND with every failing check named. Malformed input is UNSOUND.
It reviews the ontology and decision record; it does not judge whether the relationships are true in the business.
"""
from __future__ import annotations

import hashlib
import json
import math
import re

_ID = re.compile(r"^[A-Za-z0-9_.:\-/]{1,120}$")


class Bad(ValueError):
    pass


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


def rel_key(r):
    return f"{r.get('subject')}|{r.get('relation')}|{r.get('object')}"


def version_hash(relationships):
    rows = sorted(({"subject": r.get("subject"), "relation": r.get("relation"), "object": r.get("object"),
                    "regulated": bool(r.get("regulated")), "attrs": r.get("attrs") or {}} for r in relationships),
                  key=lambda x: (x["subject"], x["relation"], x["object"]))
    return hashlib.sha256(_canon(rows)).hexdigest()


def _num(v, what, lo=0.0, hi=1e15):
    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or not (lo <= v <= hi):
        raise Bad(f"{what} must be a finite number in [{lo}, {hi}]")
    return float(v)


def _id(v, what):
    if not isinstance(v, str) or not _ID.match(v):
        raise Bad(f"{what} must be an id")
    return v


def _human(p):
    return isinstance(p, str) and p.startswith("human:") and len(p) > 6


def _body(r):
    return _canon({"regulated": bool(r.get("regulated")), "attrs": r.get("attrs") or {}})


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

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

    try:
        if not isinstance(record, dict) or record.get("schema") != "cain42.a75.ontology.review.v1":
            raise Bad("not a cain42.a75.ontology.review.v1 record")
        versions = record.get("versions")
        if not isinstance(versions, list) or not versions:
            raise Bad("versions must be a non-empty list")
        V, order, prev, prev_rels = {}, [], None, {}
        reviewed_ok = {}  # version id -> set of rel keys whose regulated content is reviewed (incl. inherited)
        for v in versions:
            if not isinstance(v, dict):
                raise Bad("a version must be an object")
            vid = _id(v.get("id"), "version.id")
            if vid in V:
                raise Bad(f"duplicate version {vid}")
            rels = v.get("relationships")
            if not isinstance(rels, list) or not rels:
                raise Bad(f"{vid}.relationships must be a non-empty list")
            R = {}
            for r in rels:
                if not isinstance(r, dict) or not all(isinstance(r.get(k), str) and r.get(k) for k in ("subject", "relation", "object")):
                    raise Bad(f"{vid}: a relationship needs subject, relation and object")
                k = rel_key(r)
                if k in R:
                    raise Bad(f"{vid}: duplicate relationship {k}")
                R[k] = r
            eff = _num(v.get("effective_at"), f"{vid}.effective_at")
            h = version_hash(rels)
            c(f"{vid}.hash", v.get("sha256") == h, f"stated hash matches recomputed {h[:12]}")
            c(f"{vid}.owner", _human(v.get("owner")), f"owner {v.get('owner')!r} is a named human")
            if prev is None:
                c(f"{vid}.chain", v.get("previous") in (None, ""), "first version has no predecessor")
            else:
                c(f"{vid}.chain", v.get("previous") == prev["id"] and v.get("previous_sha256") == version_hash(prev["relationships"]),
                  f"chains to {prev['id']}")
                c(f"{vid}.effective_order", eff > _num(prev.get("effective_at"), "effective_at"), "takes effect after its predecessor")
            reviews = v.get("reviews") if isinstance(v.get("reviews"), list) else []
            inherited = reviewed_ok.get(prev["id"], set()) if prev else set()
            ok_keys = set()
            for k, r in sorted(R.items()):
                if not r.get("regulated"):
                    continue
                unchanged = k in prev_rels and _body(prev_rels[k]) == _body(r) and k in inherited
                if unchanged:
                    ok_keys.add(k)
                    continue
                rv = [x for x in reviews if isinstance(x, dict) and x.get("relationship") == k]
                good = [x for x in rv if _human(x.get("by")) and x.get("by") != v.get("owner") and x.get("decision") == "approve"
                        and _num(x.get("at"), f"{vid}.review.at") <= eff + 1e-9]
                c(f"{vid}.review.{k}", bool(good), f"regulated relationship reviewed independently before effect ({len(good)})")
                if good:
                    ok_keys.add(k)
            reviewed_ok[vid] = ok_keys
            V[vid] = {"v": v, "R": R, "eff": eff, "hash": h}
            order.append(vid)
            summary["versions"][vid] = {"relationships": len(R), "regulated_reviewed": len(ok_keys), "sha256": h}
            prev, prev_rels = v, R

        def in_effect(t):
            cur = None
            for vid in order:
                if V[vid]["eff"] <= t + 1e-9:
                    cur = vid
            return cur

        decisions = record.get("decisions")
        if not isinstance(decisions, list) or not decisions:
            raise Bad("decisions must be a non-empty list")
        reevals = record.get("reevaluations") if isinstance(record.get("reevaluations"), list) else []
        D = {}
        for d in decisions:
            if not isinstance(d, dict):
                raise Bad("a decision must be an object")
            did = _id(d.get("id"), "decision.id")
            if did in D:
                raise Bad(f"duplicate decision {did}")
            D[did] = d
            at = _num(d.get("decided_at"), f"{did}.decided_at")
            vid = d.get("ontology_version")
            relied = d.get("relied_on")
            if not isinstance(relied, list) or not relied:
                raise Bad(f"{did}.relied_on must be a non-empty list")
            c(f"{did}.version_known", vid in V, f"version {vid!r}")
            if vid not in V:
                continue
            c(f"{did}.version_hash", d.get("ontology_sha256") == V[vid]["hash"], "bound to the version's recomputed hash")
            c(f"{did}.version_in_effect", in_effect(at) == vid, f"{vid} in effect at {at} (actual {in_effect(at)!r})")
            missing = [k for k in relied if k not in V[vid]["R"]]
            c(f"{did}.relied_exist", not missing, f"missing {missing}" if missing else "all relied relationships exist")
            if d.get("regulated"):
                unreviewed = [k for k in relied if k in V[vid]["R"] and V[vid]["R"][k].get("regulated") and k not in reviewed_ok[vid]]
                nonreg = [k for k in relied if k in V[vid]["R"] and not V[vid]["R"][k].get("regulated")]
                c(f"{did}.regulated_grounding", not unreviewed and not nonreg,
                  f"unreviewed {unreviewed}, unregulated {nonreg}" if (unreviewed or nonreg) else "reviewed regulated relationships only")
            # drift: later versions that change what this decision relied on
            needs = []
            if d.get("status", "open") == "open":
                base = V[vid]["R"]
                for later in order[order.index(vid) + 1:]:
                    LR = V[later]["R"]
                    changed = [k for k in relied if k in base and (k not in LR or _body(LR[k]) != _body(base[k]))]
                    if changed:
                        needs.append(later)
                        ok = any(isinstance(e, dict) and e.get("decision_id") == did and e.get("ontology_version") == later
                                 and e.get("ontology_sha256") == V[later]["hash"]
                                 and _num(e.get("at"), f"{did}.reevaluation.at") >= V[later]["eff"] - 1e-9
                                 and _human(e.get("by")) for e in reevals)
                        c(f"{did}.reevaluated.{later}", ok, f"{later} changed {changed}")
            summary["decisions"][did] = {"version": vid, "needs_reevaluation": needs}

        claims = record.get("claims") if isinstance(record.get("claims"), dict) else {}

        def all_ok(pred):
            return all(x["ok"] for x in checks if pred(x["id"]))

        computed = {
            "ontology_versioned": all_ok(lambda i: i.split(".")[-1] in ("hash", "owner", "chain", "effective_order")),
            "regulated_changes_reviewed": all_ok(lambda i: ".review." in i),
            "decisions_bound_to_version": all_ok(lambda i: any(i.endswith(s) for s in (".version_known", ".version_hash", ".version_in_effect", ".relied_exist", ".regulated_grounding"))),
            "open_decisions_reevaluated": all_ok(lambda i: ".reevaluated." in i),
        }
        for key in sorted(claims):
            c(f"claims.{key}", key in computed and claims[key] == computed[key], f"claimed {claims[key]!r}, computed {computed.get(key)!r}")
        summary["computed"] = computed
    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.ontology.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-046, {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))
