"""Finite-state observability checks and tamper-evident event persistence.

Inspired by the user's PIPS/RCCD/SPWSE design goals. These are independently
specified finite constructions, not assertions that neural summaries preserve
all causally relevant information.
"""
from dataclasses import dataclass, asdict
import hashlib
import json
from pathlib import Path
import numpy as np
from .replay import canonical_json
from .certificates import compaction_value_bound


@dataclass(frozen=True)
class QuotientCertificate:
    reward_error: float
    transition_tv: float
    exact: bool
    states: int
    quotient_states: int
    horizon: int
    value_error_bound: float
    kernel_digest: str
    scope: str = "enumerated finite MDP; policies constant on quotient fibers"


def certify_quotient(reward, transition, mapping, *, horizon: int) -> tuple[QuotientCertificate, np.ndarray, np.ndarray]:
    """Construct a representative quotient and check every (state,action).

    reward[S,A], transition[S,A,S], mapping[S] with contiguous labels.
    No statistical/generalization claim follows when these arrays are merely
    fitted models instead of trusted exact transition tables.
    """
    r, p, f = np.asarray(reward, dtype=float), np.asarray(transition, dtype=float), np.asarray(mapping)
    if r.ndim != 2 or p.shape != (*r.shape, r.shape[0]) or f.shape != (len(r),):
        raise ValueError("invalid finite MDP shapes")
    if f.dtype.kind not in "iu" or (f < 0).any() or not np.array_equal(np.unique(f), np.arange(f.max()+1)):
        raise ValueError("mapping must use contiguous nonnegative integer labels")
    if not np.isfinite(r).all() or not np.isfinite(p).all() or (p < 0).any() or not np.allclose(p.sum(-1), 1, atol=1e-12, rtol=0):
        raise ValueError("invalid finite MDP values")
    z = int(f.max()+1)
    agg = np.stack([p[..., f == j].sum(-1) for j in range(z)], -1)
    representatives = [int(np.flatnonzero(f == j)[0]) for j in range(z)]
    rq, pq = r[representatives], agg[representatives]
    er = float(np.abs(r-rq[f]).max())
    ep = float((0.5*np.abs(agg-pq[f]).sum(-1)).max())
    span = float(np.max(r)-np.min(r))
    bound = compaction_value_bound(horizon, er, ep, span)
    h = hashlib.sha256()
    for a in (r, p, f.astype(np.int64)):
        h.update(canonical_json({"shape": a.shape, "dtype": a.dtype.str}))
        h.update(np.ascontiguousarray(a).tobytes())
    cert = QuotientCertificate(er, ep, er == 0 and ep == 0, len(r), z, horizon, bound, h.hexdigest())
    return cert, rq, pq


class EventLog:
    """Append-only in-memory hash chain. No arbitrary tool execution capability."""
    def __init__(self):
        self.events: list[dict] = []

    def append(self, kind: str, payload: dict, *, capability_hash: str) -> str:
        if not kind or not capability_hash or not isinstance(payload, dict):
            raise ValueError("event kind, dict payload and capability hash required")
        # JSON roundtrip isolates future caller mutation and excludes NaN/objects.
        payload = json.loads(canonical_json(payload))
        parent = self.events[-1]["digest"] if self.events else "0"*64
        body = {"index": len(self.events), "kind": kind, "payload": payload,
                "capability_hash": capability_hash, "parent": parent}
        digest = hashlib.sha256(canonical_json(body)).hexdigest()
        self.events.append(dict(body, digest=digest))
        return digest

    def verify(self) -> None:
        parent = "0"*64
        for i, event in enumerate(self.events):
            body = {k: v for k, v in event.items() if k != "digest"}
            if body.get("index") != i or body.get("parent") != parent:
                raise ValueError("event ordering/parent mismatch")
            digest = hashlib.sha256(canonical_json(body)).hexdigest()
            if digest != event.get("digest"):
                raise ValueError("event digest mismatch")
            parent = digest

    def save(self, path: str | Path):
        self.verify()
        Path(path).write_text("\n".join(canonical_json(e).decode() for e in self.events)+"\n", encoding="utf-8")

    @classmethod
    def load(cls, path: str | Path) -> "EventLog":
        obj = cls()
        obj.events = [json.loads(s) for s in Path(path).read_text(encoding="utf-8").splitlines() if s]
        obj.verify()
        return obj


def potential_returns(rewards, potentials, *, gamma: float = 1.):
    """Return shaped rewards and return-to-go; requires zero terminal potential.

    Potentials are prefix-predictable. For gamma=1 and terminal-only rewards,
    the result is R - Phi_t: an action-independent baseline, not free new
    reward information. Adversarial/action-dependent potentials can bias it.
    """
    r, phi = np.asarray(rewards, dtype=float), np.asarray(potentials, dtype=float)
    if r.ndim != 1 or phi.shape != (len(r)+1,) or not np.isfinite(r).all() or not np.isfinite(phi).all():
        raise ValueError("finite rewards[T] and potentials[T+1] required")
    if not 0 <= gamma <= 1 or not np.isfinite(gamma) or phi[-1] != 0:
        raise ValueError("gamma in [0,1] and exactly zero terminal potential required")
    shaped = r + gamma*phi[1:] - phi[:-1]
    rtg = np.empty_like(r)
    carry = 0.
    for t in range(len(r)-1, -1, -1):
        carry = shaped[t] + gamma*carry
        rtg[t] = carry
    return shaped, rtg