import asyncio
import json
import re
import uuid
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path

from agents import run_agent, kill_process
from config import (
    DEFAULT_PROVIDER,
    TEMPLATES_DIR,
    TIMEOUTS,
    MAX_CONCURRENT_GENERATIONS,
)
from database import update_guide
from paths import bausteine_path, guide_content_path, project_dir

_semaphore = asyncio.Semaphore(MAX_CONCURRENT_GENERATIONS)
_cancelled: set[str] = set()


async def cancel_guide(guide_id: str) -> bool:
    _cancelled.add(guide_id)
    kill_process(guide_id)
    now = datetime.now(timezone.utc).isoformat()
    await update_guide(guide_id, status="error", progress=None, error_msg="Abgebrochen", updated_at=now)
    return True


async def _set_progress(guide_id: str, progress: str) -> None:
    now = datetime.now(timezone.utc).isoformat()
    await update_guide(guide_id, progress=progress, updated_at=now)


def _prompt(name: str, **kwargs) -> str:
    template = (TEMPLATES_DIR / "Prompt" / f"{name}.md").read_text(encoding="utf-8")
    return template.format(**kwargs)


def _extra(instructions: str) -> str:
    return f"\n\nZUSÄTZLICHE ANWEISUNGEN VOM NUTZER:\n{instructions}\n" if instructions else ""


def _log(topic: str, msg: str) -> None:
    print(f"[generator] {topic}: {msg}", flush=True)


def _claude_error(label: str, returncode: int, stdout: str, stderr: str) -> str:
    stderr = (stderr or "").strip()
    if stderr:
        return f"{label}: {stderr[:1000]}"
    tail = (stdout or "").strip()[-500:]
    if tail:
        return f"{label} (exit {returncode}, stderr leer): …{tail}"
    return f"{label} (exit {returncode}, ohne Ausgabe)"


def _gather_error(label: str, results: list) -> str:
    for r in results:
        if isinstance(r, BaseException):
            return f"{label}: {type(r).__name__}: {r}"
        returncode, stdout, stderr = r
        if returncode != 0:
            return _claude_error(label, returncode, stdout, stderr)
    return f"{label}: kein verwertbares Ergebnis"


async def _fail(guide_id: str, msg: str) -> None:
    now = datetime.now(timezone.utc).isoformat()
    await update_guide(guide_id, status="error", progress=None, error_msg=msg, updated_at=now)


def _timeout(step: str, n: int = 0) -> int:
    base, per = TIMEOUTS[step]
    return base + per * n


_MAX_RESTARTS = 2


async def _race(topic: str, label: str, slots: list[dict], quorum: int, timeout: int, provider: str, on_update=None, cancelled=None) -> list | None:
    """Startet alle Slots parallel und sammelt `quorum` gültige Ergebnisse.

    Slot-Spec: {key, prompt, role, capabilities, payload}. `payload(result)`
    prüft die Gültigkeit und liefert das Slot-Ergebnis oder None.
    Fehler/Timeout/ungültig → Slot-Neustart (max. _MAX_RESTARTS). Sobald das
    Quorum steht, werden die übrigen Agenten gekillt. None = Quorum verfehlt.
    `cancelled()` → True bricht ab (keine Restarts, Rückgabe None).
    """
    attempts = {i: 0 for i in range(len(slots))}
    tasks: dict[asyncio.Task, int] = {}

    def spawn(i: int) -> None:
        slot = slots[i]
        task = asyncio.create_task(run_agent(
            slot["key"], slot["prompt"], timeout,
            provider=provider, role=slot["role"], capabilities=slot["capabilities"],
        ))
        tasks[task] = i

    for i in range(len(slots)):
        spawn(i)

    results: list = []
    try:
        while tasks:
            if cancelled and cancelled():
                return None
            done, _ = await asyncio.wait(tasks.keys(), return_when=asyncio.FIRST_COMPLETED)
            for task in done:
                i = tasks.pop(task)
                payload, err = None, None
                try:
                    result = task.result()
                    if result[0] != 0:
                        err = _claude_error("Fehler", *result)
                    else:
                        payload = slots[i]["payload"](result)
                        if payload is None:
                            err = "Ergebnis ungültig/nicht parsebar"
                except asyncio.TimeoutError:
                    err = f"Timeout nach {timeout}s"
                except Exception as e:
                    err = f"{type(e).__name__}: {e}"

                if payload is not None:
                    results.append(payload)
                    if on_update:
                        on_update(len(results))
                    if len(results) >= quorum:
                        return results
                    continue

                _log(topic, f"{label} {i + 1} (Versuch {attempts[i] + 1}): {err}")
                attempts[i] += 1
                if attempts[i] <= _MAX_RESTARTS and not (cancelled and cancelled()):
                    spawn(i)
        _log(topic, f"{label}: Quorum {quorum} nicht erreicht ({len(results)} gültig)")
        return None
    finally:
        for task, i in tasks.items():
            kill_process(slots[i]["key"])
            task.cancel()
        if tasks:
            await asyncio.gather(*tasks.keys(), return_exceptions=True)


# --- Bausteine-Pipeline: 4x Recherche (3 nötig) → 2x Auswahl (1) → 4x Einordnung (3) → 2x Final (1) ---

_bausteine_progress: dict[str, str] = {}
_bausteine_errors: dict[str, str] = {}
_bausteine_cancelled: set[str] = set()
_bausteine_step: dict[str, int] = {}

BAUSTEINE_STEPS = ("Recherche", "Auswahl", "Prüfung", "Einordnung", "Verifikation", "Sortierung")


def cancel_bausteine(topic: str) -> bool:
    if topic not in _bausteine_progress:
        return False
    _bausteine_cancelled.add(topic)
    kill_process(f"bausteine-{topic}-")
    return True

_CATEGORIES = ("KERN", "WICHTIG", "REST")


def _resume_step(topic: str) -> int:
    """Erster noch offener Schritt anhand der persistierten Zwischendateien."""
    final_path = bausteine_path(topic)
    stem, parent = final_path.stem, final_path.parent
    if sum((parent / f"{stem}.recherche-{i}.md").exists() for i in (1, 2, 3, 4)) < 3:
        return 0
    if not any((parent / f"{stem}.auswahl-{i}.md").exists() for i in (1, 2)):
        return 1
    if not (parent / f"{stem}.auswahl-check.md").exists():
        return 2
    if sum((parent / f"{stem}.einordnung-{i}.md").exists() for i in (1, 2, 3)) < 3:
        return 3
    if not (parent / f"{stem}.final-check.md").exists():
        return 4
    return 5


def _sortierung_path(topic: str):
    final_path = bausteine_path(topic)
    return final_path.parent / f"{final_path.stem}.sortierung.md"


def bausteine_status(topic: str) -> dict:
    ready = bausteine_path(topic).exists()
    generating = topic in _bausteine_progress
    partial = False
    if generating:
        current = _bausteine_step.get(topic)
        states = [
            "pending" if current is None else "done" if i < current else "active" if i == current else "pending"
            for i in range(len(BAUSTEINE_STEPS))
        ]
    elif ready:
        states = ["done"] * len(BAUSTEINE_STEPS)
        if not _sortierung_path(topic).exists():
            states[-1] = "pending"
    else:
        nxt = _resume_step(topic)
        partial = nxt > 0
        states = ["done" if i < nxt else "pending" for i in range(len(BAUSTEINE_STEPS))]
    return {
        "ready": ready,
        "generating": generating,
        "progress": _bausteine_progress.get(topic),
        "error": _bausteine_errors.get(topic),
        "partial": partial,
        "steps": [{"label": label, "state": s} for label, s in zip(BAUSTEINE_STEPS, states)],
    }


def active_bausteine() -> list[dict]:
    return [{"topic": t, "progress": p} for t, p in _bausteine_progress.items()]


def reset_bausteine(topic: str) -> None:
    final_path = bausteine_path(topic)
    final_path.unlink(missing_ok=True)
    for i in (1, 2, 3, 4):
        (final_path.parent / f"{final_path.stem}.recherche-{i}.md").unlink(missing_ok=True)
        (final_path.parent / f"{final_path.stem}.einordnung-{i}.md").unlink(missing_ok=True)
    for i in (1, 2):
        (final_path.parent / f"{final_path.stem}.auswahl-{i}.md").unlink(missing_ok=True)
    (final_path.parent / f"{final_path.stem}.auswahl-check.md").unlink(missing_ok=True)
    (final_path.parent / f"{final_path.stem}.final-check.md").unlink(missing_ok=True)
    (final_path.parent / f"{final_path.stem}.sortierung.md").unlink(missing_ok=True)
    _bausteine_errors.pop(topic, None)


def _build_recherche_prompt(topic: str, out_path: Path, instructions: str = "", project: Path | None = None) -> str:
    if project:
        source = _prompt("Bausteine-Quelle-Projekt", project=project)
    else:
        source = _prompt("Bausteine-Quelle-Thema", topic=topic)
    return _prompt(
        "Bausteine-Recherche",
        topic=topic, source=source, bausteine_path=out_path, extra=_extra(instructions),
    )


def _parse_auswahl(text: str) -> dict[int, str]:
    """Parst die konsolidierte Liste: `N. Titel — Kurzbeschreibung` pro Zeile."""
    entries: dict[int, str] = {}
    last = None
    for line in text.splitlines():
        m = re.match(r"\s*(\d+)[.)]\s+(.*\S)", line)
        if m:
            last = int(m.group(1))
            entries[last] = m.group(2)
        elif last is not None and line.strip():
            entries[last] += " " + line.strip()
    return entries


def _parse_einordnung(text: str) -> dict[int, str]:
    """Parst eine Einordnung (`KERN:` gefolgt von `N Titel`-Zeilen) zu Nummer→Kategorie."""
    mapping: dict[int, str] = {}
    current = None
    for line in text.splitlines():
        s = line.strip().lstrip("-*# ").strip()
        if not s:
            continue
        m = re.match(r"(KERN|WICHTIG|REST)\b[:\s]*(.*)$", s, re.IGNORECASE)
        if m:
            current = m.group(1).upper()
            for num in re.findall(r"\b\d+\b", m.group(2)):
                mapping.setdefault(int(num), current)
            continue
        if current:
            m = re.match(r"(\d+)\b", s)
            if m:
                mapping.setdefault(int(m.group(1)), current)
    return mapping


def _build_final_bausteine(topic: str, entries: dict[int, str], mapping: dict[int, str], order: dict[str, list[int]] | None = None) -> str:
    """Baut die finale Baustein-Datei aus konsolidierter Liste + finaler Zuordnung.

    `order` (Kategorie → Nummern in Lernreihenfolge) sortiert innerhalb der
    Kategorien; nicht gelistete Nummern hängen in Originalreihenfolge hinten an.
    """
    grouped: dict[str, list[int]] = {c: [] for c in _CATEGORIES}
    for num in sorted(entries):
        cat = mapping.get(num)
        if cat is None:
            _log(topic, f"Baustein {num} fehlt in finaler Einordnung → REST")
            cat = "REST"
        grouped[cat].append(num)
    unknown = sorted(set(mapping) - set(entries))
    if unknown:
        _log(topic, f"finale Einordnung enthält unbekannte Nummern (ignoriert): {unknown}")
    if order:
        for cat in _CATEGORIES:
            wanted = set(grouped[cat])
            seq = [n for n in order.get(cat, []) if n in wanted]
            grouped[cat] = seq + [n for n in grouped[cat] if n not in seq]
    parts = []
    for cat in _CATEGORIES:
        lines = "\n".join(f"{i}. {entries[num]}" for i, num in enumerate(grouped[cat], 1))
        parts.append(f"## {cat}\n{lines}")
    return "\n\n".join(parts) + "\n"


def _file_payload(path: Path):
    """Gültig, wenn die Slot-Datei existiert und nummerierte Einträge enthält."""
    if not path.exists():
        return None
    text = path.read_text(encoding="utf-8")
    return text if _parse_auswahl(text) else None


def _auswahl_payload(path: Path):
    if not path.exists():
        return None
    text = path.read_text(encoding="utf-8")
    entries = _parse_auswahl(text)
    return (text, entries) if entries else None


def _parse_auswahl_check(text: str):
    """Parst die Auswahl-Prüfung: NACHTRÄGE (neue Einträge) + STREICHEN (Nummern)."""
    additions: list[str] = []
    removals: set[int] = set()
    mode = None
    seen_marker = False
    for line in text.splitlines():
        s = line.strip().lstrip("-*# ").strip()
        if not s:
            continue
        u = s.upper().rstrip(":")
        if u.startswith("NACHTR"):
            mode = "add"
            seen_marker = True
            continue
        if u.startswith("STREICH"):
            mode = "del"
            seen_marker = True
            continue
        if u == "OK":
            seen_marker = True
            continue
        if mode == "add":
            additions.append(s)
        elif mode == "del":
            m = re.match(r"(\d+)\b", s)
            if m:
                removals.add(int(m.group(1)))
    if not seen_marker:
        return None  # Antwort hat das Format nicht getroffen
    return {"add": additions, "remove": removals}


def _majority(mappings: list[dict[int, str]], entries: dict[int, str]) -> tuple[dict[int, str], list[int]]:
    """Mehrheitsentscheid über die Einordnungen; ohne Mehrheit → Streitfall."""
    mapping: dict[int, str] = {}
    disputes: list[int] = []
    for num in entries:
        votes = [m[num] for m in mappings if num in m]
        if not votes:
            disputes.append(num)
            continue
        cat, count = Counter(votes).most_common(1)[0]
        if count >= 2:
            mapping[num] = cat
        else:
            disputes.append(num)
    return mapping, disputes


def _einordnung_block(mapping: dict[int, str], entries: dict[int, str]) -> str:
    parts = []
    for cat in _CATEGORIES:
        nums = [n for n in sorted(entries) if mapping.get(n) == cat]
        lines = "\n".join(f"{n} {_titel(entries[n])}" for n in nums)
        parts.append(f"{cat}:\n{lines}" if lines else f"{cat}:")
    return "\n".join(parts)


async def _run_sortierung(topic: str, entries: dict[int, str], mapping: dict[int, str], provider: str, cancelled) -> dict[str, list[int]] | None:
    """Sortiert innerhalb der Kategorien; schreibt bei Erfolg den Marker und liefert die Reihenfolge."""
    slots = [{
        "key": f"bausteine-{topic}-sortierung-1",
        "prompt": _prompt("Bausteine-Sortierung", topic=topic, einordnung=_einordnung_block(mapping, entries)),
        "role": "quick", "capabilities": "none",
        "payload": (lambda result: (result[1].strip(), _parse_einordnung(result[1])) if _parse_einordnung(result[1]) else None),
    }]
    res = await _race(topic, "Sortierung", slots, 1, _timeout("sortierung", len(entries)), provider, cancelled=cancelled)
    if res is None:
        return None
    raw, sort_mapping = res[0]
    _sortierung_path(topic).write_text(raw, encoding="utf-8")
    return {cat: [num for num, c in sort_mapping.items() if c == cat] for cat in _CATEGORIES}


async def generate_bausteine(topic: str, instructions: str = "", provider: str = DEFAULT_PROVIDER) -> None:
    if topic in _bausteine_progress:
        return
    _bausteine_progress[topic] = "Wartend…"
    _bausteine_errors.pop(topic, None)

    final_path = bausteine_path(topic)
    project = project_dir(topic) if project_dir(topic).is_dir() else None
    stem = final_path.stem
    recherche_paths = [final_path.parent / f"{stem}.recherche-{i}.md" for i in (1, 2, 3, 4)]
    auswahl_paths = [final_path.parent / f"{stem}.auswahl-{i}.md" for i in (1, 2)]
    einordnung_paths = [final_path.parent / f"{stem}.einordnung-{i}.md" for i in (1, 2, 3)]
    auswahl_check_path = final_path.parent / f"{stem}.auswahl-check.md"
    final_check_path = final_path.parent / f"{stem}.final-check.md"
    sortierung_path = _sortierung_path(topic)
    slot_files = [*recherche_paths, *auswahl_paths, *einordnung_paths, auswahl_check_path, final_check_path, sortierung_path]

    def set_p(msg: str, step: int | None = None) -> None:
        _bausteine_progress[topic] = msg
        if step is not None:
            _bausteine_step[topic] = step

    def is_cancelled() -> bool:
        return topic in _bausteine_cancelled

    def abgebrochen() -> None:
        _bausteine_errors[topic] = "Abgebrochen — Fortschritt bleibt erhalten"

    try:
        async with _semaphore:
            # Fertig, aber ohne Sortier-Marker (ältere Pipeline-Version): nur die Sortierung nachholen.
            if final_path.exists() and not sortierung_path.exists():
                cats = _parse_kategorien(final_path.read_text(encoding="utf-8"))
                entries, mapping = {}, {}
                i = 0
                for cat in _CATEGORIES:
                    for text in cats.get(cat, []):
                        i += 1
                        entries[i] = text
                        mapping[i] = cat
                if entries:
                    set_p("Sortiere Bausteine…", step=5)
                    order = await _run_sortierung(topic, entries, mapping, provider, is_cancelled)
                    if is_cancelled():
                        abgebrochen()
                        return
                    if order is None:
                        _bausteine_errors[topic] = "Sortierung fehlgeschlagen"
                        return
                    final_path.write_text(_build_final_bausteine(topic, entries, mapping, order), encoding="utf-8")
                return

            # „Neu erstellen": fertige (sortierte) Bausteine → kompletter Frischstart.
            # Sonst sind Slot-Dateien Reste eines Abbruchs/Fehlers → Resume, fertige Schritte überspringen.
            if final_path.exists():
                for p_alt in slot_files:
                    p_alt.unlink(missing_ok=True)

            # Schritt 1: 4 Recherche-Agenten, 3 gültige nötig — vorhandene Slot-Dateien zählen
            recherchen = []
            offen = []
            for i, path in enumerate(recherche_paths, 1):
                text = _file_payload(path)
                if text is not None and len(recherchen) < 3:
                    recherchen.append(text)
                else:
                    offen.append((i, path))
            vorhanden = len(recherchen)
            set_p(f"Recherche läuft ({vorhanden}/3 gültig)…", step=0)
            if vorhanden < 3:
                caps = "files" if project else "full"
                slots = [
                    {
                        "key": f"bausteine-{topic}-recherche-{i}",
                        "prompt": _build_recherche_prompt(topic, path, instructions, project),
                        "role": "quick", "capabilities": caps,
                        "payload": (lambda result, p=path: _file_payload(p)),
                    }
                    for i, path in offen
                ]
                neue = await _race(
                    topic, "Recherche", slots, 3 - vorhanden, _timeout("recherche"), provider,
                    on_update=lambda c: set_p(f"Recherche läuft ({vorhanden + c}/3 gültig)…"),
                    cancelled=is_cancelled,
                )
                if is_cancelled():
                    abgebrochen()
                    return
                if neue is None:
                    _bausteine_errors[topic] = "Recherche fehlgeschlagen (Quorum nicht erreicht)"
                    return
                recherchen += neue

            # Schritt 2: 2 Auswahl-Agenten, der erste gewinnt — vorhandene gültige Datei wird übernommen
            n_est = max(len(_parse_auswahl(t)) for t in recherchen)
            results_block = "\n\n".join(f"### Recherche {i}\n\n{text}" for i, text in enumerate(recherchen, 1))
            bestehende = next((res for p in auswahl_paths if (res := _auswahl_payload(p)) is not None), None)
            if bestehende is not None:
                flat, entries = bestehende
            else:
                set_p("Konsolidiere Recherche…", step=1)
                slots = [
                    {
                        "key": f"bausteine-{topic}-auswahl-{i}",
                        "prompt": _prompt("Bausteine-Auswahl", topic=topic, results=results_block, out_path=path),
                        "role": "fast", "capabilities": "files",
                        "payload": (lambda result, p=path: _auswahl_payload(p)),
                    }
                    for i, path in enumerate(auswahl_paths, 1)
                ]
                auswahl = await _race(topic, "Auswahl", slots, 1, _timeout("auswahl", n_est), provider, cancelled=is_cancelled)
                if is_cancelled():
                    abgebrochen()
                    return
                if auswahl is None:
                    _bausteine_errors[topic] = "Auswahl fehlgeschlagen (kein gültiges Ergebnis)"
                    return
                flat, entries = auswahl[0]

            # Schritt 2b: Auswahl-Prüfung (nicht fatal) — gespeicherte Antwort wird erneut angewendet
            set_p("Prüfe Auswahl…", step=2)
            raw_check = auswahl_check_path.read_text(encoding="utf-8") if auswahl_check_path.exists() else None
            patch = _parse_auswahl_check(raw_check) if raw_check is not None else None
            if patch is None:
                slots = [{
                    "key": f"bausteine-{topic}-auswahlcheck-1",
                    "prompt": _prompt("Bausteine-Auswahl-Check", topic=topic, results=results_block, auswahl=flat),
                    "role": "fast", "capabilities": "none",
                    "payload": (lambda result: (result[1].strip(), _parse_auswahl_check(result[1])) if _parse_auswahl_check(result[1]) is not None else None),
                }]
                checks = await _race(topic, "Auswahl-Check", slots, 1, _timeout("auswahl_check", len(entries)), provider, cancelled=is_cancelled)
                if is_cancelled():
                    abgebrochen()
                    return
                if checks is None:
                    _log(topic, "Auswahl-Check fehlgeschlagen — fahre ohne Korrekturen fort")
                else:
                    raw_check, patch = checks[0]
                    auswahl_check_path.write_text(raw_check, encoding="utf-8")
            if patch is not None:
                if patch["remove"]:
                    _log(topic, f"Auswahl-Check streicht Duplikate: {sorted(patch['remove'])}")
                    entries = {n: t for n, t in entries.items() if n not in patch["remove"]}
                if patch["add"]:
                    _log(topic, f"Auswahl-Check ergänzt {len(patch['add'])} Bausteine")
                if patch["remove"] or patch["add"]:
                    texts = [t for _, t in sorted(entries.items())] + patch["add"]
                    entries = {i: t for i, t in enumerate(texts, 1)}
                    flat = "\n".join(f"{i}. {t}" for i, t in entries.items())

            # Schritt 3: 4 Einordnungs-Agenten, 3 gültige nötig — gespeicherte Stimmen einlesen
            n = len(entries)
            einordnungen = []
            for path in einordnung_paths:
                if path.exists():
                    text = path.read_text(encoding="utf-8")
                    parsed = _parse_einordnung(text)
                    if parsed:
                        einordnungen.append((text, parsed))
            einordnungen = einordnungen[:3]
            vorhanden = len(einordnungen)
            set_p(f"Einordnung läuft ({vorhanden}/3 gültig)…", step=3)
            if vorhanden < 3:
                slots = [
                    {
                        "key": f"bausteine-{topic}-einordnung-{i}",
                        "prompt": _prompt("Bausteine-Einordnung", topic=topic, bausteine=flat),
                        "role": "quick", "capabilities": "none",
                        "payload": (lambda result: (result[1].strip(), _parse_einordnung(result[1])) if _parse_einordnung(result[1]) else None),
                    }
                    for i in range(vorhanden + 1, 5)
                ]
                neue = await _race(
                    topic, "Einordnung", slots, 3 - vorhanden, _timeout("einordnung", n), provider,
                    on_update=lambda c: set_p(f"Einordnung läuft ({vorhanden + c}/3 gültig)…"),
                    cancelled=is_cancelled,
                )
                if is_cancelled():
                    abgebrochen()
                    return
                if neue is None:
                    _bausteine_errors[topic] = "Einordnung fehlgeschlagen (Quorum nicht erreicht)"
                    return
                for path, (text, _) in zip(einordnung_paths[vorhanden:], neue):
                    path.write_text(text, encoding="utf-8")
                einordnungen += neue

            # Schritt 4: Python-Mehrheitsentscheid + Verifikations-Agent — gespeicherte Antwort wird erneut angewendet
            set_p("Verifiziere Einordnung…", step=4)
            mapping, disputes = _majority([m for _, m in einordnungen], entries)
            if disputes:
                _log(topic, f"Keine Mehrheit bei: {disputes}")
            raw_final = final_check_path.read_text(encoding="utf-8") if final_check_path.exists() else None
            if raw_final is not None and not (_parse_einordnung(raw_final) or "OK" in raw_final.upper()):
                raw_final = None
            if raw_final is None:
                streit_block = "\n".join(f"{num} {entries[num]}" for num in disputes) or "(keine)"
                final_prompt = _prompt(
                    "Bausteine-Einordnung-Final",
                    topic=topic,
                    einordnung=_einordnung_block(mapping, entries),
                    streitfaelle=streit_block,
                )
                slots = [
                    {
                        "key": f"bausteine-{topic}-final-{i}",
                        "prompt": final_prompt,
                        "role": "fast", "capabilities": "none",
                        "payload": (lambda result: result[1].strip() if (_parse_einordnung(result[1]) or "OK" in result[1].upper()) else None),
                    }
                    for i in (1, 2)
                ]
                finals = await _race(topic, "Final", slots, 1, _timeout("final", n), provider, cancelled=is_cancelled)
                if is_cancelled():
                    abgebrochen()
                    return
                if finals is None:
                    _log(topic, "Final-Verifikation fehlgeschlagen — Mehrheitsentscheid bleibt unverändert")
                else:
                    raw_final = finals[0]
                    final_check_path.write_text(raw_final, encoding="utf-8")
            if raw_final is not None:
                overrides = {num: cat for num, cat in _parse_einordnung(raw_final).items() if num in entries}
                korrekturen = {num: cat for num, cat in overrides.items() if mapping.get(num) != cat and num not in disputes}
                if korrekturen:
                    _log(topic, f"Final-Verifikation korrigiert: {korrekturen}")
                mapping.update(overrides)
            for num in disputes:
                if num not in mapping:
                    _log(topic, f"Streitfall {num} unentschieden → WICHTIG")
                    mapping[num] = "WICHTIG"

            # Schritt 5: Sortierung innerhalb der Kategorien (einfach → komplex, nicht fatal)
            set_p("Sortiere Bausteine…", step=5)
            order = await _run_sortierung(topic, entries, mapping, provider, is_cancelled)
            if is_cancelled():
                abgebrochen()
                return
            if order is None:
                _log(topic, "Sortierung fehlgeschlagen — Originalreihenfolge bleibt (Nachholen über ▶)")
            final_path.write_text(_build_final_bausteine(topic, entries, mapping, order), encoding="utf-8")
    except Exception as e:
        _bausteine_errors[topic] = str(e)[:2000]
    finally:
        # Kein Datei-Cleanup: Zwischendateien bleiben für Resume bzw. Nachvollziehbarkeit.
        # Aufräumen passiert nur explizit über reset_bausteine().
        _bausteine_progress.pop(topic, None)
        _bausteine_step.pop(topic, None)
        _bausteine_cancelled.discard(topic)


# --- Guide-Generierung: Bausteine → (Plan) → Writer → JSON ---

# Welche Baustein-Kategorien jedes Format abdeckt.
FORMAT_COVERAGE = {
    "MiniGuide": ("KERN",),
    "Guide": ("KERN", "WICHTIG"),
    "FullGuide": ("KERN", "WICHTIG", "REST"),
}

# Parallele Writer pro Format (OnePager hat einen eigenen Weg).
WRITER_COUNT = {"MiniGuide": 1, "Guide": 2, "FullGuide": 4}


def _parse_kategorien(text: str) -> dict[str, list[str]]:
    """Parst die finale Baustein-Datei (## KERN/WICHTIG/REST mit nummerierten Einträgen)."""
    cats: dict[str, list[str]] = {}
    current = None
    for line in text.splitlines():
        s = line.strip()
        m = re.match(r"#+\s*(KERN|WICHTIG|REST)\b", s, re.IGNORECASE)
        if m:
            current = m.group(1).upper()
            cats.setdefault(current, [])
            continue
        m = re.match(r"(\d+)[.)]\s+(.*\S)", s)
        if m and current:
            cats[current].append(m.group(2))
    return cats


def _titel(entry: str) -> str:
    return entry.split(" — ")[0].strip() or entry


def _parse_gliederung(text: str, valid: set[int], topic: str) -> list[dict]:
    """Parst die Gliederung (`KAPITEL: Titel` + `N Titel`-Zeilen) → [{"title", "nums"}]."""
    chapters: list[dict] = []
    seen: set[int] = set()
    for line in text.splitlines():
        s = line.strip().lstrip("-*# ").strip()
        if not s:
            continue
        m = re.match(r"KAPITEL\s*:\s*(.+)", s, re.IGNORECASE)
        if m:
            chapters.append({"title": m.group(1).strip(), "nums": []})
            continue
        m = re.match(r"(\d+)\b", s)
        if m and chapters:
            num = int(m.group(1))
            if num in valid and num not in seen:
                chapters[-1]["nums"].append(num)
                seen.add(num)
    missing = sorted(valid - seen)
    if missing:
        _log(topic, f"Gliederung: Bausteine {missing} fehlen → Kapitel 'Weitere Themen'")
        chapters.append({"title": "Weitere Themen", "nums": missing})
    return [c for c in chapters if c["nums"]]


def _split_chunks(chapters: list[dict], n: int) -> list[list[dict]]:
    """Teilt Kapitel in bis zu n zusammenhängende Chunks, balanciert nach Section-Anzahl."""
    n = max(1, min(n, len(chapters)))
    chunks: list[list[dict]] = []
    current: list[dict] = []
    count = 0
    remaining_total = sum(len(c["nums"]) for c in chapters)
    remaining_chunks = n
    for ch in chapters:
        current.append(ch)
        count += len(ch["nums"])
        if remaining_chunks > 1 and count >= remaining_total / remaining_chunks:
            chunks.append(current)
            remaining_total -= count
            remaining_chunks -= 1
            current = []
            count = 0
    if current:
        chunks.append(current)
    return chunks


def _zuteilung_text(chunk: list[dict], entries: dict[int, str]) -> str:
    lines = []
    for ch in chunk:
        lines.append(f"KAPITEL: {ch['title']}")
        lines.extend(f"{num} {entries[num]}" for num in ch["nums"])
    return "\n".join(lines)


_FRAGMENT_KAPITEL_RE = re.compile(r"<!--\s*kapitel\s*:\s*(.*?)\s*-->", re.IGNORECASE)
_FRAGMENT_SECTION_RE = re.compile(r"<!--\s*section\s*:\s*(\d+)\s*(?:\|\s*(.*?))?\s*-->", re.IGNORECASE)


def _parse_fragment(text: str) -> list[dict]:
    """Parst eine Writer-Datei → [{"kapitel", "num", "title", "md"}] in Datei-Reihenfolge."""
    sections: list[dict] = []
    kapitel = None
    current = None
    for line in text.splitlines():
        s = line.strip()
        m = _FRAGMENT_KAPITEL_RE.match(s)
        if m:
            kapitel = m.group(1)
            current = None
            continue
        m = _FRAGMENT_SECTION_RE.match(s)
        if m:
            current = {"kapitel": kapitel, "num": int(m.group(1)), "title": (m.group(2) or "").strip(), "md": []}
            sections.append(current)
            continue
        if current is not None:
            current["md"].append(line)
    for sec in sections:
        sec["md"] = "\n".join(sec["md"]).strip()
    return sections


def _section_json(sec: dict, entries: dict[int, str]) -> dict:
    return {"num": sec["num"], "title": sec["title"] or _titel(entries[sec["num"]]), "md": sec["md"]}


async def _generate_onepager(
    guide_id: str, topic: str, instructions: str, provider: str,
    project: Path | None, content_path: Path, fragment_paths: list[Path],
) -> list[dict] | None:
    def is_cancelled() -> bool:
        return guide_id in _cancelled

    # Schritt 1: Recherche — eigene Faktenbasis, unabhängig von den Bausteinen
    await _set_progress(guide_id, "Recherchiere…")
    recherche_path = content_path.parent / f"{content_path.stem}.recherche.md"
    fragment_paths.append(recherche_path)
    recherche_path.unlink(missing_ok=True)
    if project:
        source = _prompt("OnePager-Quelle-Projekt", project=project)
    else:
        source = _prompt("OnePager-Quelle-Thema", topic=topic)
    slots = [{
        "key": f"{guide_id}-recherche",
        "prompt": _prompt("OnePager-Recherche", topic=topic, source=source, out_path=recherche_path, extra=_extra(instructions)),
        "role": "quick", "capabilities": "files" if project else "full",
        "payload": (lambda result: recherche_path.read_text(encoding="utf-8") if recherche_path.exists() else None),
    }]
    res = await _race(topic, "OnePager-Recherche", slots, 1, _timeout("onepager_recherche"), provider, cancelled=is_cancelled)
    if is_cancelled():
        return None
    if res is None:
        await _fail(guide_id, "OnePager-Recherche fehlgeschlagen")
        return None
    recherche = res[0]

    # Schritt 2: Bauen — Karten nur aus der Faktenbasis
    await _set_progress(guide_id, "Baue OnePager…")
    slots = [{
        "key": f"{guide_id}-bauen",
        "prompt": _prompt("OnePager-Bauen", topic=topic, recherche=recherche, extra=_extra(instructions)),
        "role": "fast", "capabilities": "none",
        "payload": (lambda result: _parse_auswahl(result[1]) or None),
    }]
    res = await _race(topic, "OnePager-Bauen", slots, 1, _timeout("onepager_bauen"), provider, cancelled=is_cancelled)
    if is_cancelled():
        return None
    if res is None:
        await _fail(guide_id, "OnePager-Bau fehlgeschlagen")
        return None
    cards = res[0]

    # Schritt 3: Verifizieren — OK oder vollständig korrigierte Liste (nicht fatal)
    await _set_progress(guide_id, "Verifiziere OnePager…")
    karten_block = "\n".join(f"{i}. {t}" for i, t in cards.items())
    slots = [{
        "key": f"{guide_id}-verify",
        "prompt": _prompt("OnePager-Verifikation", topic=topic, recherche=recherche, karten=karten_block),
        "role": "fast", "capabilities": "none",
        "payload": (lambda result: result[1].strip() if (_parse_auswahl(result[1]) or "OK" in result[1].upper()) else None),
    }]
    res = await _race(topic, "OnePager-Verifikation", slots, 1, _timeout("onepager_verify"), provider, cancelled=is_cancelled)
    if is_cancelled():
        return None
    if res is None:
        _log(topic, "OnePager-Verifikation fehlgeschlagen — ungeprüfte Version wird verwendet")
    else:
        corrected = _parse_auswahl(res[0])
        if corrected:
            _log(topic, "OnePager-Verifikation hat Korrekturen geliefert")
            cards = corrected

    sections = [
        {"num": i, "title": _titel(text), "md": text.split(" — ", 1)[1].strip() if " — " in text else text}
        for i, text in cards.items()
    ]
    return [{"title": topic, "sections": sections}]


async def _generate_sections(
    guide_id: str, topic: str, format_name: str, entries: dict[int, str],
    facts: str, instructions: str, provider: str,
    content_path: Path, fragment_paths: list[Path],
) -> list[dict] | None:
    spec = (TEMPLATES_DIR / "Format" / "Section.md").read_text(encoding="utf-8")
    bausteine_block = "\n".join(f"{i}. {t}" for i, t in entries.items())

    if format_name == "MiniGuide":
        # Ein Writer, gliedert selbst in Kapitel
        plan = None
        zuteilungen = [bausteine_block]
        chunk_sizes = [len(entries)]
    else:
        await _set_progress(guide_id, "Plane Gliederung…")
        returncode, stdout, stderr = await run_agent(
            f"{guide_id}-plan",
            _prompt("Guide-Plan", topic=topic, format_name=format_name, bausteine=bausteine_block, extra=_extra(instructions)),
            _timeout("plan", len(entries)), provider=provider, role="guide", capabilities="none",
        )
        if guide_id in _cancelled:
            return None
        if returncode != 0:
            await _fail(guide_id, _claude_error("Plan-Fehler", returncode, stdout, stderr))
            return None
        plan = _parse_gliederung(stdout, set(entries), topic)
        if not plan:
            await _fail(guide_id, "Gliederung nicht parsebar")
            return None
        chunks = _split_chunks(plan, WRITER_COUNT[format_name])
        zuteilungen = [_zuteilung_text(chunk, entries) for chunk in chunks]
        chunk_sizes = [sum(len(c["nums"]) for c in chunk) for chunk in chunks]

    writer_count = len(zuteilungen)
    await _set_progress(guide_id, f"Schreibe Sections ({writer_count} Writer)…" if writer_count > 1 else "Schreibe Sections…")
    paths = [content_path.parent / f"{content_path.stem}.chunk-{i}.md" for i in range(1, writer_count + 1)]
    fragment_paths.extend(paths)
    results = await asyncio.gather(*[
        run_agent(
            f"{guide_id}-w{i}",
            _prompt(
                "Guide-Writer",
                topic=topic, format_name=format_name, zuteilung=zuteilung,
                facts=facts, spec=spec, out_path=path, extra=_extra(instructions),
            ),
            _timeout("writer", size), provider=provider, role="guide", capabilities="full",
        )
        for i, (zuteilung, path, size) in enumerate(zip(zuteilungen, paths, chunk_sizes), 1)
    ], return_exceptions=True)
    if guide_id in _cancelled:
        return None
    for i, (r, p) in enumerate(zip(results, paths), 1):
        if isinstance(r, BaseException):
            _log(topic, f"Writer {i}: {type(r).__name__}: {r}")
        elif r[0] != 0:
            _log(topic, f"Writer {i}: {_claude_error('Fehler', *r)}")
        elif not p.exists():
            _log(topic, f"Writer {i}: keine Ausgabedatei erstellt")
    fragments: list[dict] = []
    for p in paths:
        if p.exists():
            fragments.extend(_parse_fragment(p.read_text(encoding="utf-8")))
    if not fragments:
        await _fail(guide_id, _gather_error("Writer-Fehler", list(results)))
        return None

    await _set_progress(guide_id, "Setze zusammen…")
    chapters: list[dict] = []
    if plan is None:
        # MiniGuide: Kapitel aus den Fragment-Markern in Datei-Reihenfolge
        seen: set[int] = set()
        for sec in fragments:
            if sec["num"] not in entries or sec["num"] in seen:
                continue
            seen.add(sec["num"])
            title = sec["kapitel"] or topic
            if not chapters or chapters[-1]["title"] != title:
                chapters.append({"title": title, "sections": []})
            chapters[-1]["sections"].append(_section_json(sec, entries))
        missing = sorted(set(entries) - seen)
    else:
        by_num = {sec["num"]: sec for sec in fragments if sec["num"] in entries}
        for ch in plan:
            sections = [_section_json(by_num[num], entries) for num in ch["nums"] if num in by_num]
            if sections:
                chapters.append({"title": ch["title"], "sections": sections})
        missing = sorted(set(entries) - set(by_num))
    if missing:
        _log(topic, f"Sections fehlen in der Writer-Ausgabe: {missing}")
    if not chapters:
        await _fail(guide_id, "Keine Sections in der Writer-Ausgabe gefunden")
        return None
    return chapters


async def generate_guide(guide_id: str, topic: str, format_name: str, instructions: str = "", provider: str = DEFAULT_PROVIDER) -> None:
    async with _semaphore:
        now = datetime.now(timezone.utc).isoformat()
        await update_guide(guide_id, status="generating", progress="Starte…", updated_at=now)

        content_path = guide_content_path(topic, format_name)
        project = project_dir(topic) if project_dir(topic).is_dir() else None
        fragment_paths: list[Path] = []

        try:
            if guide_id in _cancelled:
                return

            if format_name == "OnePager":
                chapters = await _generate_onepager(guide_id, topic, instructions, provider, project, content_path, fragment_paths)
            else:
                cats = _parse_kategorien(bausteine_path(topic).read_text(encoding="utf-8"))
                selected: list[str] = []
                for cat in FORMAT_COVERAGE[format_name]:
                    selected.extend(cats.get(cat, []))
                if not selected:
                    await _fail(guide_id, "Keine passenden Bausteine gefunden")
                    return
                entries = {i: text for i, text in enumerate(selected, 1)}
                facts = _prompt("Guide-Fakten-Projekt", project=project) if project else _prompt("Guide-Fakten-Thema")
                chapters = await _generate_sections(
                    guide_id, topic, format_name, entries,
                    facts, instructions, provider, content_path, fragment_paths,
                )
            if chapters is None or guide_id in _cancelled:
                return

            content_path.write_text(
                json.dumps({"topic": topic, "format": format_name, "chapters": chapters}, ensure_ascii=False, indent=1),
                encoding="utf-8",
            )

            now = datetime.now(timezone.utc).isoformat()
            await update_guide(guide_id, status="done", progress=None, updated_at=now)

        except asyncio.TimeoutError:
            await _fail(guide_id, "Timeout bei der Generierung")
        except FileNotFoundError:
            await _fail(guide_id, "Bausteine fehlen")
        except Exception as e:
            await _fail(guide_id, str(e)[:2000])
        finally:
            _cancelled.discard(guide_id)
            for p in fragment_paths:
                p.unlink(missing_ok=True)


# --- Tutor-Chat ---

def _build_guide_chat_prompt(topic: str, format_name: str, section: str, outline: str, messages: list[dict]) -> str:
    transcript = "\n".join(
        f"{'Nutzer' if m.get('role') == 'user' else 'Assistent'}: {m.get('content', '')}"
        for m in messages
    )
    return _prompt(
        "Chat",
        topic=topic, format_name=format_name,
        outline_block=outline.strip() or "(keine)",
        section_block=section.strip() or "(kein Abschnitt erkannt)",
        transcript=transcript,
    )


async def chat_with_guide(topic: str, format_name: str, section: str, outline: str, messages: list[dict], provider: str = DEFAULT_PROVIDER) -> str:
    try:
        prompt = _build_guide_chat_prompt(topic, format_name, section, outline, messages)
        returncode, stdout, stderr = await run_agent(
            "chat-" + str(uuid.uuid4()), prompt, 240, provider=provider, role="fast", capabilities="none"
        )
        if returncode != 0:
            return "Entschuldigung, das hat nicht geklappt. Bitte versuche es erneut."
        reply = stdout.strip()
        return reply or "Entschuldigung, ich habe keine Antwort erhalten."
    except Exception:
        return "Entschuldigung, das hat nicht geklappt. Bitte versuche es erneut."