"""Inhaltsprüfung: gleicht die Karten mit dem Quelltext ab.

Die Stilprüfung fragt „ist das gut geschrieben", diese hier fragt „stimmt das
überhaupt". Ziel ist, dass alle Karten zusammen alles abbilden, was das Programm
kann — und nichts, was es nicht kann.

In drei Schritten, weil ein einzelner nicht funktioniert hat:

1. **Inventar** — das Modell liest nur den Quelltext und listet die Fähigkeiten.
   Ohne die Karten daneben, sonst bestätigt es bloß, was schon dasteht. Jede
   Fähigkeit braucht eine wörtlich zitierte Codezeile; ohne Beleg fällt sie weg.
   Mehrere Durchgänge werden vereinigt: hier zählt Vollständigkeit.
2. **Abdeckung** — je Fähigkeit eine kurze Frage: deckt eine bestehende Funktion
   das ab? Eine Ja/Nein-Frage ist weit stabiler als offenes Suchen. Nur wenn alle
   Stimmen „nein" sagen, entsteht ein Vorschlag.
Geprüft wird nur eine Richtung: was fehlt. Die Gegenrichtung — „diese Funktion hat
keinen Code, weg damit" — ist bewusst nicht eingebaut. Sie ließ sich nicht belegen
(ein Nichtvorhandensein lässt sich nicht zitieren), urteilte von Runde zu Runde
anders und schlug dabei vor, gültige Inhalte zu löschen. Karten dürfen außerdem
Dinge festhalten, die kein Knopf sind — Schreibregeln etwa.
"""

import asyncio
import difflib
import re

import agents
import config
import quellcode

# Ohne Drossel liefen alle Punkte gleichzeitig los und der Provider antwortete
# mit 429. Die ausgefallenen Stimmen sahen dann aus wie „alles abgedeckt".
_schranke = None


def _drossel():
    global _schranke
    if _schranke is None:
        _schranke = asyncio.Semaphore(config.PRUEFUNG_PARALLEL)
    return _schranke


async def _frage(system: str, nachricht: str, temperatur: float) -> str:
    async with _drossel():
        return await agents.frage(system, nachricht, temperatur)


async def _urteil(system: str, nachricht: str, temperatur: float):
    """Eine Stimme als JSON. Unlesbares wird einmal neu gefragt, dann aufgegeben —
    bei 240 Anfragen je Lauf ist ein Ausrutscher normal, ein Abbruch wäre es nicht."""
    for versuch in range(2):
        try:
            return _json(await _frage(system, nachricht, temperatur + 0.1 * versuch))
        except ValueError:
            continue
    return None

ABDECKUNG_SYSTEM = """Du entscheidest, ob eine Stelle im Programm schon von einer
beschriebenen Funktion abgedeckt ist. Antworte ausschließlich mit JSON."""

ABDECKUNG = """An dieser Stelle kann eine Person etwas auslösen:

  {art} in {datei}, Zeile {zeile}

```
{umfeld}
```
{rumpf}

Die Karten des Projekts beschreiben bisher das hier:

{funktionen}

Beschreibt eine dieser Funktionen, was an der Stelle oben passiert?
Wortwahl darf abweichen; entscheidend ist die Sache. Ziel, Regeln und Testschritte
einer Funktion gehören mit zu dem, was sie abdeckt.

Antworte ausschließlich mit JSON:
{{"abgedeckt": true, "funktion": "..."}}
oder
{{"abgedeckt": false, "karte": "...", "titel": "..."}}

- funktion: der bestehende Funktionstitel, wörtlich, wenn abgedeckt
- karte: der Titel der Karte, in die die Fähigkeit thematisch gehört
- titel: wie die neue Funktion heißen soll — Objekt und Verb im Infinitiv,
  höchstens 5 Wörter

Rein technische Aufhänger gelten als abgedeckt: Speichern beim Verlassen eines
Feldes, Abbrechen mit Escape, Gesundheitsprüfungen, interne Weiterleitung.
Im Zweifel abgedeckt. Nur was einer Person wirklich fehlt, soll dazukommen."""

# Achtung: dieser Text geht unformatiert als System-Prompt raus. Doppelte Klammern
# wären hier keine Escapes, sondern landeten wörtlich in der Antwort.
# Sechs Stimmen, fünf müssen „fehlt" sagen.
#
# Einstimmigkeit war zu scharf: gemessen kippt dieselbe Frage auch bei Temperatur 0
# gelegentlich, und eine einzelne Ausreißerstimme löschte damit auch klare Funde.
# Eindeutige Stellen antworten 6:0 oder 0:6, Grenzfälle etwa 3:3 — die Schwelle bei
# fünf trennt beides und übersteht einen Ausrutscher.
URTEIL_TEMPERATUREN = (0.0, 0.2, 0.4, 0.6, 0.8, 1.0)
FEHLT_AB = 5
# Ab dieser Ähnlichkeit gelten zwei Titel als dieselbe Sache
GLEICH = 0.75


def _normal(text: str) -> str:
    return re.sub(r"[^a-zä-ü0-9 ]", "", (text or "").lower()).strip()


def _aehnlich(a: str, b: str) -> float:
    return difflib.SequenceMatcher(None, _normal(a), _normal(b)).ratio()


def _json(antwort: str) -> dict:
    import pruefung  # zur Laufzeit, sonst Ringschluss

    return pruefung._json_lesen(antwort)


def _funktionsliste(features: list) -> str:
    """Die Karten mit allem, was sie sagen.

    Nur die Titel reichten nicht: der Richter musste raten, ob eine Funktion eine
    Stelle abdeckt, und urteilte von Runde zu Runde anders. Ziel, Regeln und
    Testschritte sagen es dagegen ausdrücklich.
    """
    teile = []
    for f in features:
        s = f["sektionen"]
        block = [f'## Karte: {s["titel"]}']
        if s["ziel"]:
            block.append(f'Ziel: {s["ziel"]}')
        for x in s["funktionen"]:
            block.append(f'\n### {x["text"]}  (Karte: {s["titel"]})')
            if x["ziel"]:
                block.append(f'Ziel: {x["ziel"]}')
            for feld in ("regeln", "testen"):
                if x[feld]:
                    zeilen = ", ".join(z.strip("- ").strip()
                                       for z in x[feld].splitlines() if z.strip())
                    block.append(f'{feld.capitalize()}: {zeilen}')
        teile.append("\n".join(block))
    return "\n\n".join(teile) or "—"


async def _abdeckung(punkt: dict, liste: str) -> list:
    rumpf = f'\nDahinter steht:\n\n```\n{punkt["rumpf"]}\n```\n' if punkt["rumpf"] else ""
    nachricht = ABDECKUNG.format(funktionen=liste, art=punkt["art"],
                                 datei=punkt["datei"], zeile=punkt["zeile"],
                                 umfeld=punkt["umfeld"], rumpf=rumpf)
    proben = await asyncio.gather(*(
        _urteil(ABDECKUNG_SYSTEM, nachricht, t) for t in URTEIL_TEMPERATUREN
    ), return_exceptions=True)
    return [p for p in proben if isinstance(p, dict)]


async def luecken(punkte: list, features: list) -> list:
    """Interaktionspunkte, die einstimmig von keiner Funktion abgedeckt sind."""
    liste = _funktionsliste(features)
    karten = {f["sektionen"]["titel"]: f for f in features}
    getroffen = set()  # Funktionen, die eine Stimme als Treffer genannt hat

    async def eine(punkt):
        urteile = await _abdeckung(punkt, liste)
        for u in urteile:
            if u.get("abgedeckt") and u.get("funktion"):
                getroffen.add(str(u["funktion"]).strip())
        if len(urteile) < len(URTEIL_TEMPERATUREN):
            # Nicht verschweigen: eine ausgefallene Stimme sähe sonst aus wie
            # „ist abgedeckt" und der Lauf meldete stillschweigend zu wenig.
            raise RuntimeError(
                f'{punkt["schluessel"]}: nur {len(urteile)} von '
                f"{len(URTEIL_TEMPERATUREN)} Stimmen brauchbar")
        if sum(u.get("abgedeckt") is False for u in urteile) < FEHLT_AB:
            return None
        ziele = [str(u.get("karte") or "").strip() for u in urteile]
        karte = max(set(ziele), key=ziele.count)
        treffer = karten.get(karte) or _naechste_karte(karte, karten)
        if not treffer:
            return None
        titel = [str(u.get("titel") or "").strip() for u in urteile if u.get("titel")]
        if not titel:
            return None
        return {"feature": treffer["id"],
                "titel": max(titel, key=lambda t: sum(_aehnlich(t, x) for x in titel)),
                "beleg": f'{punkt["datei"]}:{punkt["zeile"]}'}

    gefunden = [x for x in await asyncio.gather(*(eine(p) for p in punkte)) if x]
    luecken.getroffen = getroffen
    # Zwei Punkte können auf dieselbe fehlende Funktion zeigen
    raus = []
    for x in gefunden:
        gleich = next((y for y in raus if y["feature"] == x["feature"]
                       and _aehnlich(y["titel"], x["titel"]) > GLEICH), None)
        if gleich:
            gleich["beleg"] += f', {x["beleg"]}'
        else:
            raus.append(x)
    return raus


def _naechste_karte(name: str, karten: dict):
    if not name:
        return None
    treffer = max(karten, key=lambda k: _aehnlich(name, k))
    return karten[treffer] if _aehnlich(name, treffer) > 0.6 else None


def probleme(features: list, fehlend: list) -> list:
    """Aus den Lücken die Ergänzungen an den Funktionslisten ableiten."""
    import pruefung

    raus = []
    for f in features:
        ist = [x["text"] for x in f["sektionen"]["funktionen"]]
        dazu = [x for x in fehlend if x["feature"] == f["id"]]
        if not dazu:
            continue
        # Bestehende Reihenfolge behalten, Neues hinten anhängen: sortieren würde
        # die halbe Liste verschieben und aus einer Ergänzung einen Umbau machen.
        # Angezeigt wird ohnehin alphabetisch.
        neu = list(dict.fromkeys(ist + [x["titel"] for x in dazu]))
        belege = " · ".join(x["beleg"] for x in dazu)
        for p in pruefung._stellen("funktionen", "\n".join(ist), "\n".join(neu),
                                   _grund(dazu), belege):
            p["feature"] = f["id"]
            p["funktion"] = ""
            raus.append(p)
    return raus


def _grund(dazu: list) -> str:
    return (f"{len(dazu)} Fähigkeit ohne Funktion" if len(dazu) == 1
            else f"{len(dazu)} Fähigkeiten ohne Funktion")


async def pruefe(features: list, quelle: dict, quelltext: str):
    """Der ganze Abgleich: Interaktionspunkte, Lücken, Überhang."""
    punkte = quellcode.interaktionen(quelle)
    if not punkte:
        raise RuntimeError("Keine Interaktionspunkte im Quelltext gefunden")
    fehlend = await luecken(punkte, features)
    return probleme(features, fehlend), punkte