"""sn_verfahrensgebiet/functions/knickpunkt_pruefung.py – Knickpunktbasierte BROR-Prüfung.

Vergleicht die Knickpunkte (Stützpunkte) des BauRaumOderBodenordnungsrecht-
Polygons mit den Punktorten der geladenen ``AX_PunktortTA``-Objekte und
identifiziert:

- **Identische Punkte** (grün): An einem BROR-Knickpunkt liegt ein PunktortTA.
- **Fehlende PunktortTA** (rot): Ein BROR-Knickpunkt hat keinen zugehörigen PunktortTA.
- **Fehlende Knickpunkte** (orange): Ein PunktortTA liegt nahe des BROR-Umrings
  auf einer Flurstücksgrenze, hat aber keinen entsprechenden Knickpunkt im BROR.

**Algorithmus:**

1. BROR-Polygon-Stützpunkte (Knickpunkte) extrahieren.
2. Spatial-Index auf PunktortTA aufbauen.
3. Für jeden Knickpunkt nächsten PunktortTA im Radius von
   :data:`KOORDINATEN_TOLERANZ_M` suchen → grün oder rot.
   Gematchte PunktortTA-Feature-IDs merken.
4. Gepufferter BROR-Umring + Flurstück-Vertex-Set ermitteln.
5. Nicht-gematchte PunktortTA nahe BROR-Umring, die auf einer Flurstücksgrenze
   liegen → orange.

**Rückgabe:** ``(result_layer, identisch, kein_pta, fehlender_knick)``
"""
from __future__ import annotations

from typing import Dict, List, Optional, Set, Tuple

from sn_basis.functions.qgiscore_wrapper import (
    QgsVectorLayer,
    QgsFeature,
    QgsField,
    QgsGeometry,
)
from sn_basis.functions.qt_wrapper import QVariant

# ---------------------------------------------------------------------------
# Konstanten
# ---------------------------------------------------------------------------

#: Koordinatentoleranz für die Knickpunkt ↔ PunktortTA-Übereinstimmung (m).
KOORDINATEN_TOLERANZ_M: float = 0.01

#: Puffer um den BROR-Umring für die Suche nach fehlenden Knickpunkten (m).
BOUNDARY_PUFFER_M: float = 0.5

#: Rundungsgenauigkeit für Vertex-Koordinaten im Flurstück-Set (Dezimalstellen).
_VERTEX_ROUND = 3

ERGEBNIS_LAYER_NAME = "Knickpunktprüfung"
FELD_TYP = "typ"
WERT_IDENTISCH = "identisch"
WERT_KEIN_PTA = "kein_pta"
WERT_FEHLENDER_KNICK = "fehlender_knick"


# ---------------------------------------------------------------------------
# Interne Hilfsfunktionen
# ---------------------------------------------------------------------------

def _extrahiere_knickpunkte(bror_layer) -> List[object]:
    """Extrahiert alle Stützpunkte (Knickpunkte) des BROR-Polygons.

    Doppelte Start/End-Punkte eines Rings werden dedupliziert. Gibt eine
    flache Liste von ``QgsPointXY``-Objekten zurück.

    Parameters
    ----------
    bror_layer :
        BauRaumOderBodenordnungsrecht-Polygon-Layer.

    Returns
    -------
    List[QgsPointXY]
        Alle eindeutigen Stützpunkte; leer bei Fehler.
    """
    try:
        from qgis.core import QgsPointXY  # type: ignore[import]

        bror_feats = [
            f for f in bror_layer.getFeatures()
            if f.geometry() and not f.geometry().isEmpty()
        ]
        if not bror_feats:
            return []

        union_geom = QgsGeometry.unaryUnion([f.geometry() for f in bror_feats])
        if union_geom is None or union_geom.isEmpty():
            return []

        punkte: List[object] = []
        seen: Set[Tuple[float, float]] = set()

        def _add_ring(vertices):
            # Letzter Punkt = erster Punkt (Ring geschlossen) → überspringen
            ring_pts = list(vertices)
            n = len(ring_pts)
            if n >= 2:
                # Prüfen ob letzter Punkt identisch mit erstem
                last = n - 1
                if (
                    abs(ring_pts[last].x() - ring_pts[0].x()) < 1e-9
                    and abs(ring_pts[last].y() - ring_pts[0].y()) < 1e-9
                ):
                    ring_pts = ring_pts[:-1]
            for pt in ring_pts:
                key = (round(pt.x(), _VERTEX_ROUND), round(pt.y(), _VERTEX_ROUND))
                if key not in seen:
                    seen.add(key)
                    punkte.append(pt)

        geom_type = union_geom.wkbType()
        # Polygon oder MultiPolygon
        if union_geom.isMultipart():
            for poly in union_geom.asMultiPolygon():
                for ring in poly:
                    _add_ring([QgsPointXY(x, y) for x, y in ring])
        else:
            for ring in union_geom.asPolygon():
                _add_ring([QgsPointXY(x, y) for x, y in ring])

        return punkte

    except Exception:
        return []


def _erstelle_ergebnis_layer(crs_authid: str) -> object:
    """Erzeugt den leeren Punkt-Ergebnislayer mit Feld ``typ``.

    Parameters
    ----------
    crs_authid :
        CRS-Kennung, z.B. ``"EPSG:25833"``.

    Returns
    -------
    QgsVectorLayer
        Leerer Memory-Layer vom Typ Point.
    """
    layer = QgsVectorLayer(
        f"Point?crs={crs_authid}", ERGEBNIS_LAYER_NAME, "memory"
    )
    pr = layer.dataProvider()
    pr.addAttributes([QgsField(FELD_TYP, QVariant.String)])
    layer.updateFields()
    return layer


def _setze_kategorien_symbologie(layer) -> None:
    """Wendet Kategoriesymbologie an: grün/rot/orange Punkte.

    - ``identisch`` → grün
    - ``kein_pta`` → rot
    - ``fehlender_knick`` → orange

    Wird bei fehlendem QGIS-Kontext still ignoriert.
    """
    try:
        from qgis.core import (  # type: ignore[import]
            QgsCategorizedSymbolRenderer,
            QgsRendererCategory,
            QgsMarkerSymbol,
        )

        def _marker(color: str, size: str = "2") -> object:
            return QgsMarkerSymbol.createSimple(
                {"color": color, "size": size, "outline_style": "no"}
            )

        categories = [
            QgsRendererCategory(
                WERT_IDENTISCH,
                _marker("0,180,0,255"),
                "identisch (Knickpunkt mit PunktortTA)",
            ),
            QgsRendererCategory(
                WERT_KEIN_PTA,
                _marker("220,0,0,255"),
                "kein PunktortTA an Knickpunkt",
            ),
            QgsRendererCategory(
                WERT_FEHLENDER_KNICK,
                _marker("255,128,0,255"),
                "fehlender Knickpunkt (PunktortTA ohne BROR-Knickpunkt)",
            ),
        ]
        renderer = QgsCategorizedSymbolRenderer(FELD_TYP, categories)
        layer.setRenderer(renderer)
    except Exception:
        pass  # Kein QGIS-Kontext (Tests) → Standarddarstellung behalten


def _baue_pta_index(punktort_layer) -> Tuple[object, Dict[int, object]]:
    """Baut einen QgsSpatialIndex und eine ID→Geometrie-Map für PunktortTA.

    Parameters
    ----------
    punktort_layer :
        Geladener ``AX_PunktortTA``-Layer.

    Returns
    -------
    Tuple[QgsSpatialIndex, Dict[int, QgsGeometry]]
        Index und Feature-ID-zu-Geometrie-Dict.
    """
    from qgis.core import QgsSpatialIndex  # type: ignore[import]

    index = QgsSpatialIndex()
    geom_map: Dict[int, object] = {}
    for feat in punktort_layer.getFeatures():
        geom = feat.geometry()
        if geom and not geom.isEmpty():
            index.insertFeature(feat)
            geom_map[feat.id()] = geom
    return index, geom_map


def _baue_flst_vertex_set(
    flst_layer,
    bror_buffer_geom,
) -> Set[Tuple[float, float]]:
    """Erstellt ein Set gerundeter (x, y)-Koordinaten aller Flurstück-Vertices
    innerhalb des gepufferten BROR-Umrings.

    Parameters
    ----------
    flst_layer :
        Flurstücke-Layer.
    bror_buffer_geom :
        Gepufferter BROR-Umring (Polygon-Geometrie).

    Returns
    -------
    Set[Tuple[float, float]]
        Gerundete Vertex-Koordinaten.
    """
    vertex_set: Set[Tuple[float, float]] = set()
    if flst_layer is None:
        return vertex_set

    try:
        for feat in flst_layer.getFeatures():
            geom = feat.geometry()
            if geom is None or geom.isEmpty():
                continue
            try:
                # Nur Flurstücke berücksichtigen, die den Puffer berühren
                if not geom.intersects(bror_buffer_geom):
                    continue
                boundary = geom.convertToType(1)  # 1 = Line
                if boundary is None or boundary.isEmpty():
                    continue
                if boundary.isMultipart():
                    parts = boundary.asMultiPolyline()
                else:
                    parts = [boundary.asPolyline()]
                for line in parts:
                    for pt in line:
                        vertex_set.add(
                            (round(pt.x(), _VERTEX_ROUND), round(pt.y(), _VERTEX_ROUND))
                        )
            except Exception:
                continue
    except Exception:
        pass
    return vertex_set


# ---------------------------------------------------------------------------
# Öffentliche API
# ---------------------------------------------------------------------------

def knickpunkt_pruefung(
    bror_layer,
    punktort_layer,
    flst_layer,
    progress=None,
    knickpunkte: Optional[List] = None,
) -> Tuple[Optional[object], int, int, int]:
    """Knickpunktbasierte BROR-Prüfung.

    Vergleicht BROR-Knickpunkte mit ``AX_PunktortTA``-Objekten und ermittelt
    fehlende Knickpunkte anhand von Flurstücksgrenzen.

    Parameters
    ----------
    bror_layer :
        BauRaumOderBodenordnungsrecht-Polygon-Layer.
    punktort_layer :
        Geladener ``AX_PunktortTA``-Layer (Ergebnis aus ``grenzpunkt_alkis``).
    flst_layer :
        Flurstücke-Layer für die Orange-Prüfung. Kann ``None`` sein.
    progress :
        Optionaler ``ProgressDialog`` für Fortschrittsanzeige.
    knickpunkte :
        Vorberechnete Knickpunktliste (optional). Wenn ``None``, werden die
        Knickpunkte aus ``bror_layer`` extrahiert.

    Returns
    -------
    Tuple[Optional[QgsVectorLayer], int, int, int]
        ``(result_layer, identisch_count, kein_pta_count, fehlender_knick_count)``

        - ``result_layer``: Punkt-Layer mit grünen/roten/orangen Punkten,
          oder ``None`` bei Abbruch oder fehlgeschlagener Verarbeitung.
        - ``identisch_count``: Knickpunkte mit passendem PunktortTA (grün).
        - ``kein_pta_count``: Knickpunkte ohne passenden PunktortTA (rot).
        - ``fehlender_knick_count``: PunktortTA ohne BROR-Knickpunkt (orange).
    """

    def _canceled() -> bool:
        return progress is not None and progress.is_canceled()

    def _schritt(label: str, wert: int) -> None:
        if progress is not None:
            progress.set_label(label)
            progress.set_value(wert)

    # ------------------------------------------------------------------
    # Schritt 0: Knickpunkte ermitteln
    # ------------------------------------------------------------------
    _schritt("Knickpunktprüfung: Knickpunkte extrahieren …", 0)

    if knickpunkte is None:
        knickpunkte = _extrahiere_knickpunkte(bror_layer)

    if not knickpunkte:
        return None, 0, 0, 0

    n = len(knickpunkte)
    crs_authid = bror_layer.crs().authid()

    if _canceled():
        return None, 0, 0, 0

    # ------------------------------------------------------------------
    # Schritt 1: Spatial-Index für PunktortTA aufbauen
    # ------------------------------------------------------------------
    _schritt("Knickpunktprüfung: PunktortTA-Index aufbauen …", 1)

    if punktort_layer is None:
        return None, 0, 0, 0

    try:
        pta_index, geom_map = _baue_pta_index(punktort_layer)
    except Exception:
        return None, 0, 0, 0

    if _canceled():
        return None, 0, 0, 0

    # ------------------------------------------------------------------
    # Schritte 2…n+1: Jeden Knickpunkt mit PunktortTA vergleichen
    # ------------------------------------------------------------------
    try:
        from qgis.core import QgsRectangle  # type: ignore[import]
    except ImportError:
        return None, 0, 0, 0

    ergebnis_layer = _erstelle_ergebnis_layer(crs_authid)
    pr = ergebnis_layer.dataProvider()
    feats_to_add: List[object] = []

    identisch_count = 0
    kein_pta_count = 0
    matched_pta_ids: Set[int] = set()

    for i, knick_pt in enumerate(knickpunkte):
        if _canceled():
            return None, 0, 0, 0

        _schritt(f"Knickpunktprüfung: Knickpunkt {i + 1}/{n} prüfen …", i + 2)

        x, y = knick_pt.x(), knick_pt.y()
        t = KOORDINATEN_TOLERANZ_M
        suchbox = QgsRectangle(x - t, y - t, x + t, y + t)
        kandidaten = pta_index.intersects(suchbox)

        gefunden = False
        for fid in kandidaten:
            pta_geom = geom_map.get(fid)
            if pta_geom is None:
                continue
            pta_pt = pta_geom.asPoint()
            dist = ((pta_pt.x() - x) ** 2 + (pta_pt.y() - y) ** 2) ** 0.5
            if dist <= KOORDINATEN_TOLERANZ_M:
                gefunden = True
                matched_pta_ids.add(fid)
                break

        feat = QgsFeature()
        try:
            from qgis.core import QgsPointXY  # type: ignore[import]
            feat.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
        except Exception:
            continue
        feat.setAttributes([WERT_IDENTISCH if gefunden else WERT_KEIN_PTA])
        feats_to_add.append(feat)

        if gefunden:
            identisch_count += 1
        else:
            kein_pta_count += 1

    if _canceled():
        return None, 0, 0, 0

    # ------------------------------------------------------------------
    # Schritt n+2: Fehlende Knickpunkte (orange) ermitteln
    # ------------------------------------------------------------------
    _schritt("Knickpunktprüfung: Fehlende Knickpunkte ermitteln …", n + 2)

    fehlender_knick_count = 0

    # BROR-Umring ermitteln und puffern
    try:
        bror_feats = [
            f for f in bror_layer.getFeatures()
            if f.geometry() and not f.geometry().isEmpty()
        ]
        bror_union = QgsGeometry.unaryUnion([f.geometry() for f in bror_feats])
        bror_boundary = bror_union.convertToType(1) if bror_union else None
        bror_buffer_geom = (
            bror_boundary.buffer(BOUNDARY_PUFFER_M, 8) if bror_boundary else None
        )
    except Exception:
        bror_buffer_geom = None

    if bror_buffer_geom is not None and flst_layer is not None:
        flst_vertex_set = _baue_flst_vertex_set(flst_layer, bror_buffer_geom)

        for feat in punktort_layer.getFeatures():
            if _canceled():
                break
            if feat.id() in matched_pta_ids:
                continue
            geom = feat.geometry()
            if geom is None or geom.isEmpty():
                continue
            try:
                if not geom.within(bror_buffer_geom):
                    continue
                pta_pt = geom.asPoint()
                key = (round(pta_pt.x(), _VERTEX_ROUND), round(pta_pt.y(), _VERTEX_ROUND))
                if key in flst_vertex_set:
                    orange_feat = QgsFeature()
                    orange_feat.setGeometry(geom)
                    orange_feat.setAttributes([WERT_FEHLENDER_KNICK])
                    feats_to_add.append(orange_feat)
                    fehlender_knick_count += 1
            except Exception:
                continue

    if _canceled():
        return None, 0, 0, 0

    # ------------------------------------------------------------------
    # Schritt n+3: Ergebnislayer fertigstellen
    # ------------------------------------------------------------------
    _schritt("Knickpunktprüfung: Ergebnislayer erstellen …", n + 3)

    pr.addFeatures(feats_to_add)
    ergebnis_layer.updateExtents()
    _setze_kategorien_symbologie(ergebnis_layer)

    return ergebnis_layer, identisch_count, kein_pta_count, fehlender_knick_count