"""Verfügbarkeit je Backend mit Circuit-Breaker (persistent).

closed: normal. Nach failure_threshold aufeinanderfolgenden Fehlern -> open
für open_seconds (Backend gilt als nicht verfügbar). Danach half_open: ein
Versuch ist erlaubt; Erfolg schließt, Fehler öffnet sofort wieder.
Nur Fehler aus HEALTH_FAILURE_CODES zählen; Policy- oder Clearance-
Ablehnungen sagen nichts über die Gesundheit des Backends.
"""
from __future__ import annotations

import time
from dataclasses import dataclass
from pathlib import Path
from typing import Callable

from .state import LockedJsonFile

HEALTH_FAILURE_CODES = frozenset({
    "TIMEOUT", "START_FAILED", "CRASHED", "NONZERO_EXIT", "OUTPUT_LIMIT", "STDIN_FAILED",
    "MODEL_FAILED", "INVALID_JSONL", "INVALID_EVENT", "INVALID_UTF8", "INCOMPLETE_TURN",
    "EMPTY_RESPONSE", "TOOL_EVENT_SEEN", "ADAPTER_EXCEPTION", "INVALID_ADAPTER_RESULT",
    "DELIVERY_FAILED", "WORKSPACE_UNAVAILABLE",
})


@dataclass(frozen=True)
class HealthState:
    status: str  # closed | open | half_open
    failures: int
    open_until: float
    last_error: str | None


class HealthRegistry:
    def __init__(self, path: Path, failure_threshold: int, open_seconds: int,
                 clock: Callable[[], float] = time.time):
        self._file = LockedJsonFile(path)
        self._threshold = failure_threshold
        self._open_seconds = open_seconds
        self._clock = clock

    def _state_from(self, entry: dict, now: float) -> HealthState:
        failures = int(entry.get("failures", 0))
        open_until = float(entry.get("open_until", 0.0))
        last_error = entry.get("last_error")
        if open_until > now:
            return HealthState("open", failures, open_until, last_error)
        if failures >= self._threshold:
            return HealthState("half_open", failures, open_until, last_error)
        return HealthState("closed", failures, open_until, last_error)

    def state(self, backend: str) -> HealthState:
        entry = self._file.read_snapshot().get("backends", {}).get(backend, {})
        return self._state_from(entry, self._clock())

    def is_available(self, backend: str) -> bool:
        return self.state(backend).status != "open"

    def record_success(self, backend: str) -> None:
        with self._file.transaction() as data:
            data.setdefault("backends", {})[backend] = {"failures": 0, "open_until": 0.0, "last_error": None}

    def record_failure(self, backend: str, code: str) -> bool:
        """Verbucht einen Fehler. Rückgabe: True, wenn der Code zählt."""
        if code not in HEALTH_FAILURE_CODES:
            return False
        now = self._clock()
        with self._file.transaction() as data:
            entry = data.setdefault("backends", {}).setdefault(
                backend, {"failures": 0, "open_until": 0.0, "last_error": None})
            entry["failures"] = int(entry.get("failures", 0)) + 1
            entry["last_error"] = code
            if entry["failures"] >= self._threshold:
                entry["open_until"] = now + self._open_seconds
        return True
