"""Declared write operations for agents: declare, check server-side, diff, approve, log."""
from __future__ import annotations

import hashlib
import json
import uuid
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Callable


# --- Operation --------------------------------------------------------------

Precondition = Callable[[dict, dict], str | None]  # (current, changes) -> error or None


@dataclass(frozen=True)
class WriteOperation:
    name: str
    entity: str
    permission: str
    fields: frozenset[str]
    preconditions: tuple[Precondition, ...] = ()
    high_impact: bool = False
    batchable: bool = True


def status_is(*allowed: str) -> Precondition:
    def check(current: dict, changes: dict) -> str | None:
        if current["status"] not in allowed:
            return f"status ist '{current['status']}', erlaubt: {', '.join(allowed)}"
        return None
    return check


def transition(src: str, dst: str) -> Precondition:
    def check(current: dict, changes: dict) -> str | None:
        if changes.get("status") not in (None, dst) or current["status"] != src:
            return f"Übergang nur {src} -> {dst}"
        return None
    return check


OPERATIONS = {
    c.name: c
    for c in [
        WriteOperation(
            name="lieferadresse_aendern",
            entity="bestellung",
            permission="bestellung.bearbeiten",
            fields=frozenset({"strasse", "plz", "ort"}),
            preconditions=(status_is("offen", "in_pruefung"),),
        ),
        WriteOperation(
            name="bestellung_stornieren",
            entity="bestellung",
            permission="bestellung.stornieren",
            fields=frozenset({"status"}),
            preconditions=(transition("offen", "storniert"),),
            high_impact=True,
            batchable=False,
        ),
    ]
}


# --- Audit log --------------------------------------------------------------

class AuditLog:
    """Append-only, hash-chained."""

    def __init__(self) -> None:
        self._entries: list[dict] = []

    def append(self, event: str, correlation_id: str, **data) -> dict:
        prev = self._entries[-1]["hash"] if self._entries else "0" * 64
        entry = {
            "seq": len(self._entries),
            "ts": datetime.now(timezone.utc).isoformat(),
            "event": event,
            "correlation_id": correlation_id,
            "data": data,
            "prev": prev,
        }
        entry["hash"] = _digest(entry)
        self._entries.append(entry)
        return entry

    def verify(self) -> bool:
        prev = "0" * 64
        for e in self._entries:
            body = {k: v for k, v in e.items() if k != "hash"}
            if e["prev"] != prev or _digest(body) != e["hash"]:
                return False
            prev = e["hash"]
        return True

    def entries(self) -> list[dict]:
        return list(self._entries)


def _digest(obj: dict) -> str:
    return hashlib.sha256(json.dumps(obj, sort_keys=True, ensure_ascii=False).encode()).hexdigest()


# --- Server -----------------------------------------------------------------

class Denied(Exception):
    pass


@dataclass
class Pending:
    id: str
    operation: str
    target: str
    version: int
    changes: dict
    actor: str
    correlation_id: str
    diff: list[str]
    digest: str


@dataclass
class WriteServer:
    store: dict[str, dict]
    grants: dict[str, set[str]]
    log: AuditLog = field(default_factory=AuditLog)
    pending: dict[str, Pending] = field(default_factory=dict)
    max_batch: int = 20

    def offered_operations(self, actor: str) -> list[str]:
        return sorted(n for n, c in OPERATIONS.items() if c.permission in self.grants.get(actor, set()))

    def propose(self, operation: str, target: str, changes: dict, actor: str, cid: str) -> Pending:
        try:
            c, current = self._check(operation, target, changes, actor)
        except Denied as e:
            self.log.append("abgelehnt", cid, operation=operation, target=target, actor=actor, grund=str(e))
            raise
        except Exception as e:  # fail closed: a broken check is a denial
            self.log.append("abgelehnt", cid, operation=operation, target=target, actor=actor,
                            grund=f"Prüfung fehlgeschlagen: {type(e).__name__}")
            raise Denied("Prüfung nicht möglich") from e
        diff = render_diff(c, target, current, changes)
        p = Pending(uuid.uuid4().hex[:8], operation, target, current["version"], changes,
                    actor, cid, diff, "")
        p.digest = _digest({"t": p.target, "v": p.version, "c": p.operation, "ch": p.changes})
        self.pending[p.id] = p
        self.log.append("vorgeschlagen", cid, pending=p.id, operation=operation, target=target,
                        actor=actor, diff=diff)
        return p

    def approve(self, pending_ids: list[str], approver: str, shown_digest: str) -> None:
        items = [self.pending[i] for i in pending_ids]
        cid = items[0].correlation_id
        try:
            self._check_batch(items, approver, shown_digest)
            for p in items:  # re-check against current state, not the state at proposal time
                c, current = self._check(p.operation, p.target, p.changes, approver)
                if current["version"] != p.version:
                    raise Denied(f"{p.target} wurde seit dem Vorschlag geändert")
        except Exception as e:
            self.log.append("freigabe_verweigert", cid, pending=pending_ids, approver=approver,
                            grund=str(e) if isinstance(e, Denied) else type(e).__name__)
            raise Denied(str(e)) from e
        for p in items:
            row = self.store[p.target]
            row.update(p.changes)
            row["version"] += 1
            del self.pending[p.id]
            self.log.append("ausgefuehrt", p.correlation_id, pending=p.id, target=p.target,
                            approver=approver, proposed_by=p.actor, digest=p.digest)

    def _check(self, operation: str, target: str, changes: dict, actor: str):
        c = OPERATIONS.get(operation)
        if c is None:
            raise Denied(f"keine Operation '{operation}'")
        if c.permission not in self.grants.get(actor, set()):
            raise Denied(f"{actor} fehlt {c.permission}")
        extra = set(changes) - c.fields
        if extra:
            raise Denied(f"Felder außerhalb der Operation: {sorted(extra)}")
        current = self.store.get(target)
        if current is None or current["entity"] != c.entity:
            raise Denied(f"Ziel {target} passt nicht zu {c.entity}")
        for pre in c.preconditions:
            if (err := pre(current, changes)) is not None:
                raise Denied(err)
        return c, current

    def _check_batch(self, items: list[Pending], approver: str, shown_digest: str) -> None:
        if len(items) > 1:
            operations = {p.operation for p in items}
            if len(operations) != 1:
                raise Denied("Sammelfreigabe nur für eine Operation")
            if not OPERATIONS[operations.pop()].batchable:
                raise Denied("Operation erlaubt keine Sammelfreigabe")
            if len(items) > self.max_batch:
                raise Denied(f"mehr als {self.max_batch} Einträge")
        if batch_digest(items) != shown_digest:
            raise Denied("Freigabe passt nicht zur angezeigten Änderung")
        if any(p.actor == approver for p in items if OPERATIONS[p.operation].high_impact):
            raise Denied("Vier-Augen-Prinzip: eigene Vorschläge mit hoher Wirkung")


def batch_digest(items: list[Pending]) -> str:
    return _digest({"items": sorted(p.digest for p in items)})


# --- Diff -------------------------------------------------------------------

LABELS = {"strasse": "Straße", "plz": "PLZ", "ort": "Ort", "status": "Status"}


def render_diff(c: WriteOperation, target: str, current: dict, changes: dict) -> list[str]:
    lines = [f"{c.name} auf {target} (Version {current['version']})"]
    for k in sorted(changes):
        old, new = current.get(k), changes[k]
        if old != new:
            lines.append(f"  {LABELS.get(k, k)}: {old!r} -> {new!r}")
    return lines


# --- Alerts -----------------------------------------------------------------

def alerts(log: AuditLog, max_denials: int = 3) -> list[str]:
    out, denials = [], {}
    for e in log.entries():
        if e["event"] in ("abgelehnt", "freigabe_verweigert"):
            actor = e["data"].get("actor") or e["data"].get("approver")
            denials[actor] = denials.get(actor, 0) + 1
            if denials[actor] == max_denials:
                out.append(f"{actor}: {max_denials} abgelehnte Schreibversuche")
        if e["event"] == "ausgefuehrt" and e["data"]["approver"] == e["data"]["proposed_by"]:
            out.append(f"{e['correlation_id']}: Selbstfreigabe von {e['data']['approver']}")
    return out


# --- Evals ------------------------------------------------------------------

def eval_write_paths(server: WriteServer) -> list[str]:
    """Each case: (actor, operation, target, changes, expected_allowed)."""
    cases = [
        ("agent:mia", "lieferadresse_aendern", "B-2", {"ort": "Köln"}, True),
        ("agent:mia", "bestellung_stornieren", "B-2", {"status": "storniert"}, False),
        ("agent:mia", "lieferadresse_aendern", "B-3", {"ort": "Köln"}, False),
        ("agent:mia", "lieferadresse_aendern", "B-2", {"preis": 0}, False),
        ("agent:mia", "bestellung_loeschen", "B-2", {}, False),
    ]
    failures = []
    for actor, operation, target, changes, expected in cases:
        offered = operation in server.offered_operations(actor)
        try:
            server._check(operation, target, changes, actor)
            allowed = True
        except Denied:
            allowed = False
        if allowed != expected or (allowed and not offered):
            failures.append(f"{actor} {operation} {target}: erwartet {expected}, war {allowed}")
        if offered and operation not in OPERATIONS:
            failures.append(f"{operation} angeboten, aber nicht deklariert")
    return failures


# --- Demo -------------------------------------------------------------------

def main() -> None:
    store = {
        f"B-{i}": {"entity": "bestellung", "version": 1, "status": "offen",
                   "strasse": f"Hauptstr. {i}", "plz": "80331", "ort": "München"}
        for i in range(1, 6)
    }
    store["B-3"]["status"] = "versendet"
    srv = WriteServer(store, grants={
        "agent:mia": {"bestellung.bearbeiten"},  # agent acts as Mia, with Mia's rights
        "mia": {"bestellung.bearbeiten"},
        "lead:jan": {"bestellung.bearbeiten", "bestellung.stornieren"},
    })
    cid = "req-7f3a"

    print("Angeboten für agent:mia:", srv.offered_operations("agent:mia"))

    p = srv.propose("lieferadresse_aendern", "B-1", {"ort": "Augsburg", "plz": "86150"}, "agent:mia", cid)
    print("\n".join(p.diff))
    srv.approve([p.id], "mia", batch_digest([p]))
    print("B-1 jetzt:", store["B-1"]["plz"], store["B-1"]["ort"], "Version", store["B-1"]["version"])

    for target in ("B-3", "B-9"):
        try:
            srv.propose("lieferadresse_aendern", target, {"ort": "Ulm"}, "agent:mia", cid)
        except Denied as e:
            print("Abgelehnt:", target, e)

    batch = [srv.propose("lieferadresse_aendern", t, {"strasse": "Postfach 12"}, "agent:mia", cid)
             for t in ("B-2", "B-4", "B-5")]
    shown = batch_digest(batch)
    store["B-4"]["version"] += 1  # concurrent edit between display and click
    try:
        srv.approve([b.id for b in batch], "mia", shown)
    except Denied as e:
        print("Sammelfreigabe verweigert:", e)

    def broken(current: dict, changes: dict) -> str | None:
        raise TimeoutError("Bestandsdienst antwortet nicht")
    original = OPERATIONS["lieferadresse_aendern"]
    OPERATIONS["lieferadresse_aendern"] = WriteOperation(
        **{**OPERATIONS["lieferadresse_aendern"].__dict__, "preconditions": (broken,)})
    try:
        srv.propose("lieferadresse_aendern", "B-5", {"ort": "Ulm"}, "agent:mia", cid)
    except Denied as e:
        print("Fail-closed:", e)
    OPERATIONS["lieferadresse_aendern"] = original

    print("Alarme:", alerts(srv.log))
    print("Log intakt:", srv.log.verify(), "Einträge:", len(srv.log.entries()))
    srv.log._entries[1]["data"]["approver"] = "lead:jan"  # entry 1: executed write of B-1
    print("Nach Manipulation intakt:", srv.log.verify())


def run_evals() -> None:
    store = {"B-2": {"entity": "bestellung", "version": 1, "status": "offen",
                     "strasse": "a", "plz": "1", "ort": "x"},
             "B-3": {"entity": "bestellung", "version": 1, "status": "versendet",
                     "strasse": "a", "plz": "1", "ort": "x"}}
    srv = WriteServer(store, grants={"agent:mia": {"bestellung.bearbeiten"}})
    failures = eval_write_paths(srv)
    print("Evals:", "ok" if not failures else failures)


if __name__ == "__main__":
    main()
    run_evals()
