"""Prüflogik des Plugins „dedup“ — die vier Prüfungen laut Fachanforderung:

a) **Verlags-Konflikt** — dasselbe Spiel ist bereits unter anderem
   Verlag/Vertrieb geführt. Ergebnis enthält eine Verlagsauswahl.
b) **Titel-Varianten** — dasselbe Spiel mit unterschiedlichem Titel; die
   deutsche Version wird bevorzugt (Heuristik über deutsche Titel-Indikatoren,
   ergänzt um BGG Alternate-Names, falls ein Hilfsclient verfügbar ist).
c) **Spiel oder Vorgänger bereits besprochen** — abgeschlossene Einträge der
   Planungsliste bilden das „besprochen“-Korpus; Vorgänger werden über die
   BGG `boardgameexpansion`-Relation erkannt und zusätzlich fuzzy auf Titel
   gematcht (rapidfuzz).
d) **Titel schon in Planungsliste eines anderen Rezensenten.**

Die Daten der anderen Plugins (neuheiten, planung) liest dieses Plugin
lesend über die gemeinsame SQLAlchemy-Metadata (`Base.metadata.tables`) —
so entstehen keine Import-Abhängigkeiten zwischen Plugin-Paketen. Fehlt eine
Tabelle (Plugin nicht geladen), entfällt die jeweilige Teilprüfung einfach.
"""
from __future__ import annotations

import logging
import re
import unicodedata
from collections.abc import Iterable
from dataclasses import dataclass, field

from sqlalchemy import select
from sqlalchemy.exc import SQLAlchemyError

from redaktionskern.db import Base

try:
    from rapidfuzz import fuzz
except ImportError:  # pragma: no cover - rapidfuzz ist eine harte Abhängigkeit
    fuzz = None

_logger = logging.getLogger("plugins.dedup")

#: Fuzzy-Schwelle für „gemeintes Spiel“ (rapidfuzz token_sort_ratio 0–100).
TITEL_SCHWELLE = 85

#: Statuswert des planung-Plugins für „bereits besprochen“ (bewusst als
#: Literal, damit keine Import-Abhängigkeit zwischen den Plugins entsteht).
STATUS_ABGESCHLOSSEN = "abgeschlossen"

#: Funktionswörter, die stark auf einen deutschen Spieltitel hindeuten.
DEUTSCHE_INDIKATOREN = frozenset({
    "der", "die", "das", "den", "dem", "des",
    "ein", "eine", "einen", "einem", "einer", "eines",
    "und", "für", "von", "vom", "zu", "zum", "zur",
    "im", "am", "beim", "auf", "mit", "aus",
})

#: Typische Begriffe deutscher Spieltitel (+2 Punkte je Treffer).
DEUTSCHE_SPIELWOERTER = frozenset({
    "abenteuer", "berg", "blitz", "burg", "dorf", "drache", "drachen",
    "erde", "feuer", "gärten", "haus", "himmel", "insel", "jagd",
    "kaiser", "könig", "könige", "königreich", "land", "länder",
    "meister", "mond", "norden", "osten", "pfad", "reich", "ritter",
    "schiff", "schloss", "see", "spiel", "spiele", "spielen",
    "stadt", "stern", "süden", "turm", "wald", "weg", "welt",
    "westen", "wiese", "wilder", "wüste", "zauber", "zeit",
})

#: Wörter, die auf einen englischen Titeltitel hindeuten (−1 Punkt je Treffer).
ENGLISCHE_INDIKATOREN = frozenset({
    "the", "of", "and", "game", "games", "card", "cards", "dice", "board",
})

_UM_LAUTE = frozenset("äöüßÄÖÜ")
_WORT_MUSTER = re.compile(r"[^\W\d_]+", re.UNICODE)


# ---------------- Titel-Heuristik ----------------

def normalisiere(text: str) -> str:
    """Vereinheitlicht einen Titel für Vergleiche (Groß-/Satzzeichen egal)."""
    text = unicodedata.normalize("NFC", text or "")
    text = text.casefold()
    text = re.sub(r"[^\w\s]+", " ", text, flags=re.UNICODE)
    return re.sub(r"\s+", " ", text).strip()


def titel_aehnlich(a: str, b: str, schwelle: int = TITEL_SCHWELLE) -> bool:
    """True, wenn zwei Titel dasselbe Spiel meinen (exakt oder fuzzy).

    Nach der Normalisierung zählt `fuzz.token_set_ratio`: Wortreihenfolge
    und Füllwörter sind egal, damit „Die Siedler von Catan“ und
    „Siedler von Catan, Die“ zusammenpassen, „Catan Erweiterung“ und
    „Catan Grundspiel“ aber nicht.
    """
    if not a or not b:
        return False
    na, nb = normalisiere(a), normalisiere(b)
    if not na or not nb:
        return False
    if na == nb:
        return True
    if fuzz is None:  # pragma: no cover
        return False
    return fuzz.token_set_ratio(na, nb) >= schwelle


def deutsch_score(titel: str) -> int:
    """Heuristik-Score: > 0 spricht für einen deutschen Titel.

    Umlaute/ß zählen am stärksten (+3), deutsche Funktionswörter +1,
    typische deutsche Spielbegriffe +2, englische Indikatoren −1.
    """
    if not titel:
        return 0
    score = 0
    if any(zeichen in _UM_LAUTE for zeichen in titel):
        score += 3
    woerter = {wort.casefold() for wort in _WORT_MUSTER.findall(titel)}
    score += sum(1 for wort in woerter if wort in DEUTSCHE_INDIKATOREN)
    score += sum(2 for wort in woerter if wort in DEUTSCHE_SPIELWOERTER)
    score -= sum(1 for wort in woerter if wort in ENGLISCHE_INDIKATOREN)
    return score


def ist_deutscher_titel(titel: str) -> bool:
    return deutsch_score(titel) > 0


def bevorzuge_deutschen_titel(kandidaten: Iterable[str]) -> str | None:
    """Wählt aus Kandidaten den deutschesten Titel (bei Gleichstand den ersten)."""
    bester: str | None = None
    bester_score = 0
    for kandidat in kandidaten:
        kandidat = (kandidat or "").strip()
        if not kandidat:
            continue
        score = deutsch_score(kandidat)
        if bester is None or score > bester_score:
            bester, bester_score = kandidat, score
    return bester


def _verlags_schluessel(verlag: str) -> str:
    """Vergleichsschlüssel für Verlage („Kosmos“ == „kosmos “)."""
    return normalisiere(verlag)


# ---------------- Prüfergebnis ----------------

#: Anzeigenamen der Konflikt-Arten (deutsche UI).
KONFLIKT_ANZEIGE: dict[str, str] = {
    "verlag": "Verlags-Konflikt",
    "titel": "Titel-Variante",
    "besprochen": "Bereits besprochen",
    "planung": "Schon in Planung",
}


@dataclass(frozen=True)
class TitelKonflikt:
    """Ein einzelner Befund der Prüfung."""

    art: str  # Schlüssel aus KONFLIKT_ANZEIGE
    beschreibung: str
    details: dict = field(default_factory=dict)

    def als_dict(self) -> dict:
        return {"art": self.art, "beschreibung": self.beschreibung, "details": self.details}

    @property
    def anzeige(self) -> str:
        return KONFLIKT_ANZEIGE.get(self.art, self.art)


@dataclass
class PruefErgebnis:
    """Strukturiertes Ergebnis einer dedup-Prüfung."""

    titel: str
    verlag: str | None = None
    bgg_id: int | None = None
    konflikte: list[TitelKonflikt] = field(default_factory=list)
    #: Verlage zur Auswahl bei einem Verlags-Konflikt (welcher wird geführt?).
    verlags_optionen: list[str] = field(default_factory=list)
    #: Empfohlener (deutschester) Titel, falls Titel-Varianten bekannt sind.
    titel_empfehlung: str | None = None

    @classmethod
    def ohne_befund(cls, titel: str, verlag: str | None = None, bgg_id: int | None = None):
        return cls(titel=titel, verlag=verlag, bgg_id=bgg_id)

    @property
    def hat_konflikte(self) -> bool:
        return bool(self.konflikte)

    @property
    def hat_verlagskonflikt(self) -> bool:
        return any(konflikt.art == "verlag" for konflikt in self.konflikte)

    def als_liste(self) -> list[dict]:
        return [konflikt.als_dict() for konflikt in self.konflikte]

    def als_text(self) -> str:
        if not self.konflikte:
            return "Keine Treffer."
        zeilen = [f"• [{k.anzeige}] {k.beschreibung}" for k in self.konflikte]
        if (
            self.titel_empfehlung
            and normalisiere(self.titel_empfehlung) != normalisiere(self.titel)
        ):
            zeilen.append(f"• Empfohlener Titel: „{self.titel_empfehlung}“")
        return "\n".join(zeilen)


# ---------------- Datenzugriff (fremde Plugin-Tabellen, nur lesend) ----------------

def _lade_zeilen(db, tabellenname: str, spalten: tuple[str, ...]) -> list[dict]:
    """Liest Zeilen einer Plugin-Tabelle über die gemeinsame Metadata.

    Fehlt die Tabelle (Plugin nicht geladen bzw. Migration nicht gelaufen),
    wird eine leere Liste zurückgegeben — die jeweilige Teilprüfung entfällt.
    """
    tabelle = Base.metadata.tables.get(tabellenname)
    if tabelle is None:
        return []
    try:
        zeilen = db.execute(select(*(tabelle.c[name] for name in spalten))).all()
    except SQLAlchemyError as exc:
        _logger.warning("dedup: Tabelle '%s' nicht lesbar (%s) — Teilprüfung übersprungen.", tabellenname, exc)
        return []
    return [dict(zip(spalten, zeile._tuple())) for zeile in zeilen]


def _lade_benutzernamen(db) -> dict[int, str]:
    benutzer = Base.metadata.tables.get("users")
    namen: dict[int, str] = {}
    if benutzer is None:
        return namen
    try:
        for zeile in db.execute(
            select(benutzer.c.id, benutzer.c.display_name, benutzer.c.username)
        ).all():
            id_wert, anzeige, username = zeile._tuple()
            namen[id_wert] = anzeige or username or f"Benutzer {id_wert}"
    except SQLAlchemyError:  # pragma: no cover - defensive
        pass
    return namen


def _rezensent_name(zeile: dict, namen: dict[int, str]) -> str:
    id_wert = zeile.get("rezensent_id")
    if id_wert is None:
        return "unbekannt"
    return namen.get(id_wert, f"Benutzer {id_wert}")


def _gleiches_spiel(zeile: dict, titel: str, bgg_id: int | None) -> bool:
    """Match über eindeutige BGG-ID, sonst fuzzy über den Titel."""
    fremd_bgg = zeile.get("bgg_id")
    if bgg_id is not None and fremd_bgg is not None and int(fremd_bgg) == int(bgg_id):
        return True
    return titel_aehnlich(titel, zeile.get("titel") or "")


# ---------------- Hauptprüfung ----------------

def fuehre_pruefung_durch(
    session_factory,
    bgg_hilfsclient,
    *,
    titel: str,
    verlag: str | None = None,
    bgg_id: int | None = None,
    user_id: int | None = None,
) -> PruefErgebnis:
    """Führt alle vier Prüfungen durch und liefert ein PruefErgebnis.

    `bgg_hilfsclient` darf None sein (BGG-Zusatzdaten deaktiviert) — dann
    entfallen Alternate-Names und Vorgänger-Relationen, die Heuristik und
    der Fuzzy-Match arbeiten weiter.
    `user_id` ist der Eintragende: eigene Planungseinträge lösen keinen
    „schon in Planung“-Konflikt aus.
    """
    titel = (titel or "").strip()
    verlag = (verlag or "").strip() or None
    id_wert = int(bgg_id) if bgg_id else None
    ergebnis = PruefErgebnis.ohne_befund(titel, verlag, id_wert)
    if not titel:
        return ergebnis

    with session_factory() as db:
        neuheiten = _lade_zeilen(db, "neuheiten", ("id", "titel", "verlag", "bgg_id"))
        planungen = _lade_zeilen(
            db, "planungsliste", ("id", "titel", "verlag", "bgg_id", "status", "rezensent_id")
        )
        namen = _lade_benutzernamen(db)

    alternativen: list[str] = []
    vorgaenger: list[tuple[int, str]] = []
    if id_wert is not None and bgg_hilfsclient is not None:
        try:
            alternativen = list(bgg_hilfsclient.alternativen(id_wert))
        except Exception as exc:  # Zusatzdaten dürfen die Prüfung nie blockieren
            _logger.warning("dedup: BGG-Alternativen nicht verfügbar (%s)", exc)
        try:
            vorgaenger = list(bgg_hilfsclient.vorgaenger(id_wert))
        except Exception as exc:
            _logger.warning("dedup: BGG-Vorgänger nicht verfügbar (%s)", exc)

    # Kandidaten = Einträge zum selben Spiel (Neuheiten + Planungsliste).
    kandidaten = [
        zeile for zeile in (*neuheiten, *planungen)
        if _gleiches_spiel(zeile, titel, id_wert)
    ]

    # a) Verlags-Konflikt: gleiches Spiel unter anderem Verlag/Vertrieb.
    bekannte_verlage: dict[str, str] = {}
    for zeile in kandidaten:
        kandidat_verlag = (zeile.get("verlag") or "").strip()
        if kandidat_verlag:
            bekannte_verlage.setdefault(_verlags_schluessel(kandidat_verlag), kandidat_verlag)
    abweichend = [
        name for schluessel, name in bekannte_verlage.items()
        if verlag and schluessel != _verlags_schluessel(verlag)
    ]
    if abweichend or len(bekannte_verlage) > 1:
        optionen = list(bekannte_verlage.values())
        if verlag and _verlags_schluessel(verlag) not in bekannte_verlage:
            optionen.append(verlag)
        ergebnis.verlags_optionen = optionen
        ergebnis.konflikte.append(TitelKonflikt(
            art="verlag",
            beschreibung=(
                "Gleiches Spiel ist bereits unter anderem Verlag geführt: "
                + ", ".join(sorted(bekannte_verlage.values()))
                + ". Bitte wählen, welcher Verlag geführt wird."
            ),
            details={"eigener_verlag": verlag, "bekannte_verlage": list(bekannte_verlage.values())},
        ))

    # b) Titel-Varianten → deutsche Version bevorzugen.
    varianten = [
        zeile["titel"] for zeile in kandidaten
        if normalisiere(zeile.get("titel") or "") != normalisiere(titel)
    ]
    ergebnis.titel_empfehlung = bevorzuge_deutschen_titel(
        [titel, *varianten, *alternativen]
    )
    if varianten and ergebnis.titel_empfehlung \
            and normalisiere(ergebnis.titel_empfehlung) != normalisiere(titel):
        ergebnis.konflikte.append(TitelKonflikt(
            art="titel",
            beschreibung=(
                f"Gleiches Spiel unter anderem Titel bekannt — empfohlen: "
                f"„{ergebnis.titel_empfehlung}“."
            ),
            details={
                "empfehlung": ergebnis.titel_empfehlung,
                "varianten": sorted(set(varianten)),
                "bgg_alternativen": alternativen[:10],
            },
        ))

    # c) Spiel oder Vorgänger bereits besprochen (Planungsstatus „abgeschlossen“).
    besprochen = [z for z in planungen if z.get("status") == STATUS_ABGESCHLOSSEN]
    for zeile in besprochen:
        if _gleiches_spiel(zeile, titel, id_wert):
            wer = _rezensent_name(zeile, namen)
            ergebnis.konflikte.append(TitelKonflikt(
                art="besprochen",
                beschreibung=f"„{zeile['titel']}“ wurde bereits besprochen ({wer}).",
                details={"planungseintrag": zeile["id"], "titel": zeile["titel"], "rezensent": wer},
            ))
    for fremd_id, fremd_titel in vorgaenger:
        for zeile in besprochen:
            zeilen_bgg = zeile.get("bgg_id")
            passt = (
                (fremd_id and zeilen_bgg is not None and int(zeilen_bgg) == fremd_id)
                or titel_aehnlich(fremd_titel, zeile.get("titel") or "")
            )
            if passt:
                wer = _rezensent_name(zeile, namen)
                ergebnis.konflikte.append(TitelKonflikt(
                    art="besprochen",
                    beschreibung=(
                        f"Vorgänger „{fremd_titel}“ wurde bereits besprochen ({wer}) — "
                        "Erweiterung prüfen, ob sie noch Redaktionsstoff bietet."
                    ),
                    details={
                        "vorgaenger_bgg_id": fremd_id,
                        "vorgaenger_titel": fremd_titel,
                        "planungseintrag": zeile["id"],
                    },
                ))

    # d) Titel schon in der Planungsliste eines anderen Rezensenten.
    for zeile in planungen:
        if user_id is not None and zeile.get("rezensent_id") == user_id:
            continue
        if _gleiches_spiel(zeile, titel, id_wert):
            wer = _rezensent_name(zeile, namen)
            status = zeile.get("status") or ""
            ergebnis.konflikte.append(TitelKonflikt(
                art="planung",
                beschreibung=(
                    f"„{zeile['titel']}“ ist bereits in der Planungsliste "
                    f"von {wer} (Status: {status})."
                ),
                details={
                    "planungseintrag": zeile["id"],
                    "rezensent": wer,
                    "status": status,
                },
            ))

    return ergebnis