src/amrl_otc.py

"""OTC auf Kassenrezept nachschlagen (AM-RL Anlage I).

Nicht verschreibungspflichtige Arzneimittel sind nach § 34 Absatz 1 Satz 1 SGB V
von der Versorgung ausgeschlossen.  Ausnahmsweise verordnungsfähig sind sie,
wenn sie bei der Behandlung schwerwiegender Erkrankungen als Therapiestandard
gelten — und welche das sind, führt Anlage I auf.  In der Offizin ist das ein
häufiger Retaxgrund: OTC auf Kassenrezept ist die Ausnahme.

**Hier trägt die Negativauskunft — anders als bei Anlage VIIa.** § 12 Absatz 10
der Richtlinie sagt es ausdrücklich: die Absätze 1 bis 9 regeln *abschließend*,
unter welchen Voraussetzungen nicht verschreibungspflichtige Arzneimittel zu
Lasten der GKV verordnungsfähig sind.  Ein „steht nicht in Anlage I" ist deshalb
eine Auskunft und nicht bloß ein fehlender Treffer.  Genau deshalb ist es auch
ein Lookup: ein Vektor-Retrieval liefert immer die k ähnlichsten Chunks und kann
Abwesenheit prinzipiell nicht belegen.

**Der Eintrag ist Stoff *und* Indikation, und beide gehören zusammen.**
Lactulose ist nicht verordnungsfähig, sondern „nur zur Senkung der enteralen
Ammoniakresorption bei Leberversagen im Zusammenhang mit der hepatischen
Enzephalopathie".  Der Befund zitiert die Bedingung deshalb vollständig und
subsumiert nicht — ob sie im Fall vorliegt, ist eine ärztliche Feststellung und
keine Listenauskunft.  Dieselbe Zurückhaltung wie bei Everolimus in Teil B.

**Vier Wege führen an der Liste vorbei**, und ein Befund, der sie verschweigt,
ist falsch.  Alle vier stehen in § 12 der Richtlinie, nicht in der Anlage:

    Absatz 12   Der Ausschluss gilt überhaupt nicht für Kinder bis zum
                vollendeten 12. Lebensjahr und Jugendliche mit
                Entwicklungsstörungen bis zum vollendeten 18. Lebensjahr.
    Absatz 7    Begleitmedikation, wenn die Fachinformation des
                Hauptarzneimittels sie voraussetzt.
    Absatz 8    Behandlung schwerwiegender unerwünschter Arzneimittelwirkungen
                eines verordnungsfähigen Arzneimittels.
    Absatz 6    Anthroposophie und Homöopathie für die in Anlage I gelisteten
                Indikationsgebiete.

Die Zustände:

    gelistet               Stoff steht in Anlage I — mit seiner Bedingung
    gruppe_gelistet        die Anlage führt eine Stoffgruppe, kein Einzelpräparat
                           (Abführmittel, Antihistaminika); ob das konkrete
                           Präparat dazugehört, ist am Fall zu prüfen
    nicht_gelistet         die Auskunft, die ein Retrieval nicht geben kann
"""

from __future__ import annotations

import json
import logging
import re
from dataclasses import dataclass, field
from datetime import date, datetime
from pathlib import Path
from typing import Any, Dict, List, Optional, Sequence, Tuple

# Geteilt statt ein viertes Mal geschrieben: dieselbe Standangabe, dieselbe
# Frist, dieselbe Endungsheuristik für einen Wirkstoffnamen.
from amrl_substitution import VERALTET_AB_TAGEN, _stand_iso, wirkstoff_kandidat

logger = logging.getLogger(__name__)

_CACHE: Dict[str, Dict[str, Any]] = {}

# Die Frage muss von der Verordnungsfähigkeit handeln. Regelbasiert wie in den
# übrigen Listenmodulen: eine Substring-Prüfung entscheidet das exakt.
OTC_SIGNALE: tuple[str, ...] = (
    "otc",
    "kassenrezept",
    "zu lasten der",
    "verordnungsfähig",
    "verordnungsfaehig",
    "verordnungsausschluss",
    "erstattungsfähig",
    "erstattungsfaehig",
    "erstattung",
    "rezeptpflichtig",
    "verschreibungspflichtig",
    "apothekenpflichtig",
    "grüne rezept",
    "grünes rezept",
    "privatrezept",
    "selbstzahler",
    "auf kasse",
)

# Die Anlage beim Namen genannt. Als Substring wäre „anlage i" auch in
# „Anlage III" enthalten — und die regelt Verordnungseinschränkungen, nicht die
# OTC-Ausnahmen.
RE_ANLAGE_I = re.compile(r"\banlage\s+i\b(?!i)")

# Einträge, die eine Stoffgruppe führen und kein Einzelpräparat. Die Zuordnung
# eines konkreten Präparats zur Gruppe ist eine pharmakologische Feststellung,
# die die Anlage nicht trifft — der Befund sagt das, statt sie zu treffen.
GRUPPENEINTRAEGE: frozenset[str] = frozenset(
    {"1", "4", "5", "6", "7", "8", "9", "21", "22", "27", "37", "43", "46"}
)


@dataclass(frozen=True)
class Eintrag:
    nr: str
    stoffangabe: str
    text: str
    spiegelstriche: Tuple[str, ...]
    begriffe: Tuple[str, ...]
    varianten: Tuple[str, ...]
    seite: Optional[int]

    @property
    def ist_gruppe(self) -> bool:
        return self.nr in GRUPPENEINTRAEGE

    def volltext(self) -> str:
        if not self.spiegelstriche:
            return self.text
        return self.text + "\n" + "\n".join(f"    - {s}" for s in self.spiegelstriche)


@dataclass
class Befund:
    status: str
    gefragter_stoff: Optional[str] = None
    treffer: List[Eintrag] = field(default_factory=list)
    stand: str = ""
    stand_iso: str = ""
    veraltet: bool = False
    alter_tage: Optional[int] = None
    fundstelle: str = ""
    url: str = ""
    grund: str = ""

    @property
    def ist_belastbar(self) -> bool:
        return self.status in {"gelistet", "gruppe_gelistet", "nicht_gelistet"}

    def to_dict(self) -> Dict[str, Any]:
        return {
            "status": self.status,
            "gefragter_stoff": self.gefragter_stoff,
            "treffer": [
                {"nr": e.nr, "stoffangabe": e.stoffangabe, "seite": e.seite} for e in self.treffer
            ],
            "stand": self.stand,
            "veraltet": self.veraltet,
            "alter_tage": self.alter_tage,
            "fundstelle": self.fundstelle,
            "url": self.url,
            "grund": self.grund,
        }


# ---------------------------------------------------------------------------
# Daten
# ---------------------------------------------------------------------------

def load_liste(path: Path) -> Dict[str, Any]:
    key = str(path)
    if key in _CACHE:
        return _CACHE[key]

    data: Dict[str, Any] = {}
    try:
        if path.exists():
            data = json.loads(path.read_text(encoding="utf-8"))
    except Exception as exc:  # noqa: BLE001 - ein defekter Snapshot darf keine Antwort verhindern.
        logger.warning("OTC-Liste nicht lesbar: %s (%s)", path, exc)
        data = {}

    _CACHE[key] = data
    return data


def _eintraege(daten: Dict[str, Any]) -> List[Eintrag]:
    out: List[Eintrag] = []
    for roh in daten.get("eintraege") or []:
        if roh.get("unbesetzt"):
            continue
        out.append(
            Eintrag(
                nr=str(roh.get("nr") or ""),
                stoffangabe=str(roh.get("stoffangabe") or ""),
                text=str(roh.get("text") or ""),
                spiegelstriche=tuple(str(s) for s in roh.get("spiegelstriche") or []),
                begriffe=tuple(str(b) for b in roh.get("begriffe") or []),
                varianten=tuple(str(v) for v in roh.get("varianten") or []),
                seite=roh.get("seite"),
            )
        )
    return out


# ---------------------------------------------------------------------------
# Erkennung in der Frage
# ---------------------------------------------------------------------------

def _norm(text: str) -> str:
    return " ".join(str(text or "").lower().split())


def begriffsindex(eintraege: Sequence[Eintrag]) -> List[Tuple[str, Eintrag]]:
    """(Suchbegriff, Eintrag), längste zuerst.

    Die Reihenfolge trägt: „Wasserlösliche Vitamine" darf nicht vom kürzeren
    „Vitamin" verdeckt werden, und „Eisen-(II)-Verbindungen" nicht von „Eisen".
    """
    paare = [(b, e) for e in eintraege for b in (*e.begriffe, *e.varianten) if b]
    return sorted(paare, key=lambda p: -len(p[0]))


def erkannte_eintraege(question: str, eintraege: Sequence[Eintrag]) -> Tuple[Optional[str], List[Eintrag]]:
    """(erkannter Begriff, Einträge dazu) — mehrere, wenn der Stoff mehrfach steht.

    Calciumverbindungen stehen in Nummer 11 und 12 mit verschiedenen
    Bedingungen, Magnesiumverbindungen in 28 und 29, Folsäure in 19 und 44. Nur
    einen davon zu zeigen unterschlüge eine Verordnungsmöglichkeit.
    """
    haystack = _norm(question)
    for begriff, _ in begriffsindex(eintraege):
        if re.search(rf"(?<![\wäöüß]){re.escape(_norm(begriff))}(?![\wäöüß])", haystack):
            passend = [
                e
                for e in eintraege
                if any(_norm(b) == _norm(begriff) for b in (*e.begriffe, *e.varianten))
            ]
            return begriff, passend
    return None, []


def fragt_nach_verordnungsfaehigkeit(question: str) -> bool:
    haystack = _norm(question)
    if RE_ANLAGE_I.search(haystack):
        return True
    return any(signal in haystack for signal in OTC_SIGNALE)


# ---------------------------------------------------------------------------
# Prüfung
# ---------------------------------------------------------------------------

def pruefe(
    question: str = "",
    *,
    path: Path,
    stoff: Optional[str] = None,
    heute: Optional[date] = None,
) -> Befund:
    daten = load_liste(path)
    alle = _eintraege(daten)
    if not alle:
        return Befund(status="nicht_pruefbar", grund="snapshot_fehlt_oder_leer")

    quelle = daten.get("quelle") or {}
    stand = str(quelle.get("stand") or "")
    fundstelle = str(quelle.get("dokument") or "AM-RL Anlage I")
    url = str(quelle.get("url") or "")

    if not stand:
        return Befund(status="nicht_pruefbar", grund="stand_unbekannt", fundstelle=fundstelle, url=url)

    stand_iso = _stand_iso(stand)
    alter_tage: Optional[int] = None
    veraltet = False
    if stand_iso:
        try:
            alter_tage = max(0, ((heute or date.today()) - datetime.strptime(stand_iso, "%Y-%m-%d").date()).days)
            veraltet = alter_tage > VERALTET_AB_TAGEN
        except ValueError:
            alter_tage = None

    def _fertig(befund: Befund) -> Befund:
        befund.stand = stand
        befund.stand_iso = stand_iso
        befund.alter_tage = alter_tage
        befund.veraltet = veraltet
        befund.fundstelle = fundstelle
        befund.url = url
        return befund

    # Ohne Bezug zur Verordnungsfähigkeit gar nichts: „Wie dosiere ich Iodid?"
    # nennt einen gelisteten Stoff, will aber keine OTC-Auskunft.
    if not fragt_nach_verordnungsfaehigkeit(question) and stoff is None:
        return _fertig(Befund(status="nicht_pruefbar", grund="keine_verordnungsfrage"))

    if stoff:
        begriff, treffer = stoff, [
            e for e in alle if any(_norm(b) == _norm(stoff) for b in (*e.begriffe, *e.varianten))
        ]
    else:
        begriff, treffer = erkannte_eintraege(question, alle)

    if treffer:
        gruppe = all(e.ist_gruppe for e in treffer)
        return _fertig(
            Befund(
                status="gruppe_gelistet" if gruppe else "gelistet",
                gefragter_stoff=begriff,
                treffer=treffer,
            )
        )

    # Keine Negativauskunft ins Blaue: „nicht in Anlage I" ist nur dann eine
    # Aussage, wenn überhaupt ein Stoff genannt wurde. Sonst wäre es eine
    # Aussage über eine Frage, die keinen nennt.
    kandidat = begriff or wirkstoff_kandidat(question)
    if not kandidat:
        return _fertig(Befund(status="nicht_pruefbar", grund="kein_stoff_erkannt"))

    return _fertig(
        Befund(status="nicht_gelistet", gefragter_stoff=kandidat, grund="nicht_in_anlage_i")
    )


# ---------------------------------------------------------------------------
# Darstellung
# ---------------------------------------------------------------------------

_EINLEITUNG = "OTC-Verordnungsfähigkeit — deterministische Listenprüfung"

# Die vier Wege an der Liste vorbei. Sie stehen in § 12 der Richtlinie und nicht
# in der Anlage; ein Befund, der nur die Liste wiedergibt, ist ohne sie falsch.
_AUSSERHALB = (
    "Unabhängig von dieser Liste bleibt verordnungsfähig, was § 12 der Richtlinie "
    "gesondert regelt: für versicherte Kinder bis zum vollendeten 12. Lebensjahr und "
    "Jugendliche mit Entwicklungsstörungen bis zum vollendeten 18. Lebensjahr gilt der "
    "Ausschluss überhaupt nicht (Absatz 12); dazu kommen Begleitmedikation, die die "
    "Fachinformation des Hauptarzneimittels voraussetzt (Absatz 7), die Behandlung "
    "schwerwiegender unerwünschter Arzneimittelwirkungen (Absatz 8) und Arzneimittel der "
    "Anthroposophie und Homöopathie für die hier gelisteten Indikationsgebiete (Absatz 6)."
)
_GRUPPENVORBEHALT = (
    "Die Anlage führt hier eine Stoffgruppe und kein einzelnes Präparat. Ob das konkrete "
    "Arzneimittel darunter fällt, ist am Fall zu prüfen — die Liste sagt es nicht."
)


def _eintrag_block(eintrag: Eintrag) -> str:
    zeilen = [f"  Nummer {eintrag.nr}: {eintrag.text}"]
    for strich in eintrag.spiegelstriche:
        zeilen.append(f"    – {strich}")
    return "\n".join(zeilen)


def befund_block(befund: Befund) -> str:
    if not befund.ist_belastbar:
        return ""

    zeilen: List[str] = [f"{_EINLEITUNG} ({befund.fundstelle}, Stand {befund.stand}):"]

    if befund.status in {"gelistet", "gruppe_gelistet"}:
        anzahl = len(befund.treffer)
        wo = (
            "in einem Eintrag, nur unter der dort genannten Indikation"
            if anzahl == 1
            else f"in {anzahl} Einträgen, jeweils nur unter der dort genannten Indikation"
        )
        zeilen.append(
            f"{befund.gefragter_stoff} steht in Anlage I — {wo}. Die Verordnung zu Lasten der "
            "GKV ist an diese Bedingung gebunden; ob sie im Fall vorliegt, ist eine ärztliche "
            "Feststellung."
        )
        for eintrag in befund.treffer:
            zeilen.append(_eintrag_block(eintrag))
        if befund.status == "gruppe_gelistet":
            zeilen.append(_GRUPPENVORBEHALT)
    else:  # nicht_gelistet
        zeilen.append(
            f"Anlage I führt {befund.gefragter_stoff} nicht. Nicht verschreibungspflichtige "
            "Arzneimittel sind nach § 34 Absatz 1 Satz 1 SGB V von der Versorgung "
            "ausgeschlossen, und § 12 Absatz 10 der Richtlinie regelt abschließend, wann "
            "ausnahmsweise verordnet werden darf. Ist das Arzneimittel nicht "
            "verschreibungspflichtig, kommt eine Verordnung zu Lasten der GKV danach nicht "
            "in Betracht."
        )

    zeilen.append(_AUSSERHALB)

    if befund.veraltet:
        zeilen.append(
            f"Achtung Aktualität: Dieser Auszug ist {befund.alter_tage} Tage alt. Vor einer "
            "Entscheidung ist die geltende Fassung abzugleichen."
        )
    if befund.url:
        zeilen.append(f"Quelle: {befund.url}")

    return "\n".join(zeilen)


def verdikt(befund: Befund) -> str:
    """Die Antwort in einem Satz — nur wenn die Frage entschieden werden konnte."""
    if befund.status == "gelistet":
        nummern = ", ".join(e.nr for e in befund.treffer)
        return (
            f"{befund.gefragter_stoff} ist in Anlage I der AM-RL geführt (Nummer {nummern}) und "
            f"damit zu Lasten der GKV verordnungsfähig, aber nur unter der dort genannten "
            f"Indikation (Listenprüfung oben, Stand {befund.stand})."
        )
    if befund.status == "gruppe_gelistet":
        nummern = ", ".join(e.nr for e in befund.treffer)
        return (
            f"Anlage I der AM-RL führt {befund.gefragter_stoff} als Stoffgruppe (Nummer "
            f"{nummern}) und nur unter der dort genannten Indikation; ob das konkrete Präparat "
            f"darunter fällt, ist am Fall zu prüfen (Listenprüfung oben, Stand {befund.stand})."
        )
    if befund.status == "nicht_gelistet":
        # Der Vorbehalt der Verschreibungspflicht ist kein Hedging, sondern der
        # Anwendungsbereich: Anlage I entscheidet nur über nicht
        # verschreibungspflichtige Arzneimittel. Ibuprofen gibt es als beides,
        # und ein pauschales „nicht verordnungsfähig" wäre für die 600 mg falsch.
        return (
            f"{befund.gefragter_stoff} steht nicht in Anlage I der AM-RL. Soweit das "
            f"Arzneimittel nicht verschreibungspflichtig ist, kommt eine Verordnung zu Lasten "
            f"der GKV damit nicht in Betracht — vorbehaltlich der Sonderfälle des § 12 AM-RL, "
            f"insbesondere bei Kindern bis 12 Jahren (Listenprüfung oben, Stand {befund.stand})."
        )
    return ""