"""Call-Schicht über agents.py: Template-Rendering, JSON-Parsen, Infra-Behandlung,
Hedge, Panels, Ledger, Budget.

Fehlerklassen bewusst getrennt (Lektion 1/2/68):
- Inhaltsfehler (ungültiges JSON, leere Antwort) → begrenzte Restarts, dann None.
- Infra-Fehler (429/Timeout/Netz) → eigener Zähler mit Backoff, erschöpft → LaufPause
  (fail-closed: der Lauf pausiert fortsetzbar, statt mit Teilergebnis weiterzulaufen)."""

import asyncio
import logging
import time

import agents
import jsonx
import ledger
import prompts
from config import HEDGE_NACH_S, INFRA_BACKOFF_BASE, INFRA_MAX_RETRIES, timeout_fuer

log = logging.getLogger("creator2.llm")

MAX_RESTARTS = 2  # inhaltliche Neuversuche pro Call


class LaufPause(Exception):
    """Infrastruktur erschöpft — Lauf pausieren, nicht weiterrechnen."""


class Kontext:
    """Ein Lauf: wandert durch alle Ebenen, trägt Ledger-Zuordnung."""

    def __init__(self, run_id: int, topic: str, provider: str):
        self.run_id = run_id
        self.topic = topic
        self.provider = provider
        self.ebene = ""


_INFRA_MARKER = ("429", "rate limit", "rate_limit", "timeout", "timed out", "connection",
                 "network", "overloaded", "unavailable", "database is locked")


def _ist_infra(err: str) -> bool:
    e = err.lower()
    return any(m in e for m in _INFRA_MARKER)


async def _roher_call(key: str, prompt: str, timeout: int, ctx: Kontext,
                      role: str, caps: str) -> agents.AgentErgebnis:
    """Ein Agent-Call mit Stall-Hedge: läuft der Slot max(HEDGE_NACH_S, timeout/2)
    ohne Ergebnis, startet genau EIN Zwilling; das erste valide Ergebnis gewinnt."""
    schwelle = max(HEDGE_NACH_S, timeout / 2) if HEDGE_NACH_S > 0 else 0

    async def einer(k: str):
        return await agents.run_agent(k, prompt, timeout, provider=ctx.provider,
                                      role=role, capabilities=caps)

    haupt = asyncio.ensure_future(einer(key))
    if not schwelle:
        return await haupt
    fertig, _ = await asyncio.wait({haupt}, timeout=schwelle)
    if fertig:
        return haupt.result()
    zwilling = asyncio.ensure_future(einer(f"{key}-h"))
    try:
        for aufgabe in asyncio.as_completed([haupt, zwilling]):
            res = await aufgabe
            if res.ok:
                return res
        return res  # beide fertig, keins ok → letztes Ergebnis zur Diagnose
    finally:
        for t in (haupt, zwilling):
            if not t.done():
                t.cancel()


async def call(ctx: Kontext, *, stage: str, template: str, werte: dict,
               role: str = "judge", caps: str = "none", schritt: str | None = None,
               n: int = 0, item: str = "", erwartet=dict):
    """Ein LLM-Call → geparstes JSON (erwartet: dict|list) oder roher Text (erwartet=str).
    None nur nach erschöpften inhaltlichen Restarts. Ledger + Budget immer."""
    prompt, thash = prompts.render(template, **werte)
    timeout = timeout_fuer(schritt or stage, n)
    infra_rest = INFRA_MAX_RETRIES
    inhalt_rest = MAX_RESTARTS
    versuch = 0
    while True:
        versuch += 1
        key = f"{ctx.topic}-{ctx.ebene}-{stage}-{item or 'x'}-{versuch}"
        start = time.monotonic()
        status, tokens, err, wait_ms = "error", None, "", 0
        try:
            res = await _roher_call(key, prompt, timeout, ctx, role, caps)
            tokens, err = res.tokens, res.err
            wait_ms = int(res.wait_s * 1000)
            if res.ok:
                if erwartet is str:
                    status = "ok"
                    return res.text
                daten = jsonx.parse(res.text)
                if daten is not None and isinstance(daten, erwartet):
                    status = "ok"
                    return daten
                status, err = "parse", f"unparsbar/falscher Typ: {res.text[:200]}"
            elif _ist_infra(res.err):
                status = "infra"
            else:
                status = "error"
                err = res.err
        except asyncio.TimeoutError:
            status = "infra"
            err = "timeout"
        finally:
            ledger.log_call(ctx.run_id, ebene=ctx.ebene, stage=stage, item=item,
                            template=template, template_hash=thash, role=role,
                            provider=ctx.provider, status=status,
                            dur_ms=int((time.monotonic() - start) * 1000),
                            wait_ms=wait_ms,
                            tokens=tokens, meta={"err": err[:300]} if err else None)
            ledger.budget_pruefen(ctx.run_id)
        if status == "infra":
            infra_rest -= 1
            if infra_rest < 0:
                raise LaufPause(f"{stage}: Infrastruktur erschöpft ({err})")
            pause = INFRA_BACKOFF_BASE * 2 ** (INFRA_MAX_RETRIES - infra_rest - 1)
            agents.drossel_melden(pause)  # global: auch Timeouts/CLI-429 bremsen alle
            log.warning("%s: Infra-Fehler (%s), Pause %.0fs", key, err[:80], pause)
            await asyncio.sleep(pause)
            continue
        inhalt_rest -= 1
        if inhalt_rest < 0:
            log.warning("%s: inhaltlich erschöpft (%s)", key, err[:120])
            return None
        log.info("%s: Neuversuch (%s)", key, err[:80])


async def alle(coros) -> list:
    """gather-Variante, die bei der ersten Exception (LaufPause/Budget) die
    Geschwister ABBRICHT — sonst brennen Hunderte laufende Repair-Tasks weiter."""
    tasks = [asyncio.ensure_future(c) for c in coros]
    try:
        return await asyncio.gather(*tasks)
    except BaseException:
        for t in tasks:
            if not t.done():
                t.cancel()
        raise


async def panel(ctx: Kontext, groesse: int, **kw) -> list:
    """`groesse` unabhängige Calls, alle Ergebnisse (None-gefiltert). Fällt genau eine
    Stimme eines 2er-Panels aus, ersetzt EIN Ersatz-Richter (Lektion 20), dann
    entscheidet der Aufrufer über Konsens."""
    item = kw.get("item", "")
    stimmen = await asyncio.gather(*(call(ctx, **{**kw, "item": f"{item}-p{i + 1}"})
                                     for i in range(groesse)))
    gueltig = [s for s in stimmen if s is not None]
    if len(gueltig) == groesse - 1 and groesse >= 2:
        ersatz = await call(ctx, **{**kw, "item": f"{item}-pE"})
        if ersatz is not None:
            gueltig.append(ersatz)
    return gueltig