Plugin_SN_Plan41/ui/tab_a_logic.py

"""
sn_plan41/ui/tab_a_logic.py – Fachlogik für Tab A (Daten)
"""

from __future__ import annotations
from sn_basis.functions.sys_wrapper import get_plugin_root, join_path, file_exists

from typing import Any, Dict, List, Optional
from collections.abc import Mapping as _Mapping
import os
import datetime
import json
import tempfile

from sn_basis.functions.qgiscore_wrapper import (
    QgsVectorFileWriter,
    QgsVectorLayer,
    QgsProject,
    QgsGeometry,
    QgsFeature,
    QgsField,
    QgsFeatureRequest,
    QgsCoordinateReferenceSystem,

)

from sn_basis.functions.variable_wrapper import (
    get_variable,
    set_variable,
)
from sn_basis.functions.ly_existence_wrapper import layer_exists
from sn_basis.functions.ly_metadata_wrapper import get_layer_type
from sn_basis.functions.qt_wrapper import QVariant
from sn_basis.functions.dialog_wrapper import create_progress_dialog
from sn_basis.functions.message_wrapper import info, warning, error


# Prüfer-Typen
from sn_basis.modules.Pruefmanager import Pruefmanager
from sn_basis.modules.linkpruefer import Linkpruefer
from sn_basis.modules.stilpruefer import Stilpruefer
from sn_basis.modules.Dateipruefer import Dateipruefer  
from sn_basis.modules.layerpruefer import Layerpruefer
from sn_basis.modules.LayerLoader import LayerLoader
from sn_basis.modules.Datenschreiber import Datenschreiber

from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
from sn_basis.modules.DataGrabber import DataGrabber, SourceType, SourceDict
from sn_basis.modules.Datenabruf import Datenabruf

Row = Dict[str, Any]
DataDict = Dict[str, List[Row]]

class TabALogic:
    """
    Kapselt die Fachlogik von Tab A. Verfahrens-DB wird **nicht** bei Pfad-Auswahl,
    sondern erst beim ersten Layer-Schreiben angelegt.
    """

    def __init__(self, pruefmanager: Pruefmanager, link_pruefer: Linkpruefer, stil_pruefer: Stilpruefer) -> None:
        self.pruefmanager = pruefmanager
        self.link_pruefer = link_pruefer
        self.stil_pruefer = stil_pruefer
        self.data_grabber: Optional[DataGrabber] = None
    def _log(self, msg: str) -> None:
        print(f"[TabALogic] {msg}")

    # -------------------------------
    # Verfahrens-Datenbank (Pfad-Management)
    # -------------------------------

    def load_verfahrens_db(self) -> Optional[str]:
        """Lädt den gespeicherten Verfahrens-DB-Pfad (Datei muss nicht existieren)."""
        path = get_variable("verfahrens_db", scope="project")
        return path or None

    def set_verfahrens_db(self, path: Optional[str]) -> None:
        """Speichert den Verfahrens-DB-Pfad (Datei wird später angelegt)."""
        if path:
            set_variable("verfahrens_db", path, scope="project")
        else:
            set_variable("verfahrens_db", "", scope="project")

    # -------------------------------
    # Layer → Verfahrens-DB schreiben (alte Logik!)
    # -------------------------------

    def write_layer_to_verfahrens_db(
        self,
        source_layer: QgsVectorLayer,
        zielpfad: str,
        layer_name: str,
    ) -> bool:
        """
        Schreibt einen Layer in die Verfahrens-DB.
        Legt GPKG **bei Bedarf neu an** (wie puffer_setzen im alten Code).
        
        Args:
            source_layer: Layer zum Exportieren (z.B. aus DataGrabber)
            zielpfad: Vom Dateiprüfer geprüfter Ziel-GPKG-Pfad
            layer_name: Name des Layers in der GPKG
            
        Returns:
            True wenn erfolgreich
        """
        if not zielpfad or not source_layer or not source_layer.isValid():
            return False

        # Optionen wie im alten puffer_setzen
        opts = QgsVectorFileWriter.SaveVectorOptions()
        opts.driverName = "GPKG"
        opts.fileEncoding = "UTF-8"
        opts.layerName = layer_name

        # Alte Logik: bei neuem Pfad komplett neue GPKG, sonst Layer überschreiben
        if not os.path.exists(zielpfad):
            opts.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
        else:
            opts.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer

        transform_context = QgsProject.instance().transformContext()

        error = QgsVectorFileWriter.writeAsVectorFormatV3(
            source_layer,
            zielpfad,
            transform_context,
            opts,
        )

        if error != QgsVectorFileWriter.NoError:
            print(f"Fehler beim Schreiben nach {zielpfad}: {error}")
            return False

        # Pfad jetzt auch als "Verfahrens-DB" merken
        self.set_verfahrens_db(zielpfad)
        return True

    # -------------------------------
    # Lokale Linkliste
    # -------------------------------

    def load_linkliste(self) -> Optional[str]:
        path = get_variable("linkliste", scope="project")
        if path and file_exists(path):
            return path
        return None

    def set_linkliste(self, path: Optional[str]) -> None:
        if path:
            set_variable("linkliste", path, scope="project")
        else:
            set_variable("linkliste", "", scope="project")

    # -------------------------------
    # Verfahrensgebiet-Layer
    # -------------------------------

    def save_verfahrensgebiet_layer(self, layer: QgsVectorLayer) -> None:
        """Speichert die Verfahrensgebiet-Layer-ID, unter Annahme, dass der Layer prevalidiert ist."""
        layer_id = layer.id() if layer is not None else ""
        set_variable("verfahrensgebiet_layer", layer_id or "", scope="project")

    def load_verfahrensgebiet_layer_id(self) -> Optional[str]:
        value = get_variable("verfahrensgebiet_layer", scope="project")
        return value or None

    def is_valid_verfahrensgebiet_layer(self, layer) -> bool:
        if not layer_exists(layer):
            return False

        layer_type = get_layer_type(layer)
        return layer_type == "vector"

    # === PIPELINE ===
    def _on_run_pipeline(
        self,
        source: str,
        linkliste: str | None,
        raumfilter: str,
        progress: Optional[Any] = None,
    ) -> Optional[Dict[str, Any]]:
        """Pipeline starten; Linkliste wird ausgelesen und geprüft, dann Datenabruf ausgeführt."""
        self._log("Pipeline startet")

        if not self.pruefmanager or not self.data_grabber:
            self._log("Fehler: Pruefmanager oder DataGrabber fehlt")
            return None

        # 1) Verfahrens-DB prüfen und als aktive DB setzen
        datei_ergebnis = Dateipruefer(
            source,
            basis_pfad="",
            leereingabe_erlaubt=False,
            standarddatei=None,
            temporaer_erlaubt=True,
            verfahrens_db_modus=True,
        ).pruefe()

        datei_ergebnis = self.pruefmanager.verarbeite(datei_ergebnis)
        if not datei_ergebnis.ok:
            self._log("Verfahrens-DB-Pruefung fehlgeschlagen")
            return None

        final_pfad = str(datei_ergebnis.kontext or source)
        self.set_verfahrens_db(final_pfad)

        # Nach bestätigter Entscheidung: sofort Fortschrittsdialog zeigen
        if progress is None:
            progress = create_progress_dialog(1, "Fachdaten laden", "Prüfe Eingaben...")
        else:
            progress.set_total(1)
            progress.set_value(0)
            progress.set_label("Prüfe Eingaben...")

        # 2) Linkliste auflösen, falls leer Standardlinkliste verwenden
        linkliste_final = self._resolve_linkliste(linkliste)
        if linkliste_final is None:
            self._log("Linkliste kann nicht aufgelöst werden")
            return None
        else:
            self._log(f"Linkliste final: '{linkliste_final}'")  
        # 3) Raumfilter prüfen
        raumfilter_layer = self._resolve_raumfilter(raumfilter, final_pfad)
        if raumfilter in ("Verfahrensgebiet", "Pufferlayer") and raumfilter_layer is None:
            self._log(f"Raumfilter '{raumfilter}' nicht verfügbar")
            return None

        # 4) Lade-Status initialisieren (funktioniert ab Bestätigung überschreiben/anhängen)
        if progress is None:
            # placeholder mit 1; tatsächliche Gesamtzahl kennt DataGrabber später
            progress = create_progress_dialog(1, "Fachdaten laden", "Prüfe Eingaben...")
        else:
            progress.set_total(1)
            progress.set_value(0)
            progress.set_label("Prüfe Eingaben...")

        # 5) Daten aus Linkliste laden und prüfen
        source_dict, grabber_summary = self.data_grabber.run(linkliste_final)
        self._log(f"DataGrabber: {grabber_summary.meldung} [{grabber_summary.aktion}]")

        # DEBUG: detaillierter Status
        print("[TabALogic] ... Debug: source_dict keys:", list(source_dict.keys()))
        print("[TabALogic] ... Debug: rows count:", len(source_dict.get("rows", [])))
        if source_dict.get("rows"):
            for i, row in enumerate(source_dict.get("rows", []), start=1):
                print(f"[TabALogic] ... Debug: row {i}: {row}")

        if not source_dict.get("rows"):
            self._log("Keine validen Linkliste-Einträge für Datenabruf")
            print("[TabALogic] ... STOP: rows:", len(source_dict.get("rows", [])))
            return None

        total_rows = len(source_dict.get("rows", []))
        if progress is not None:
            if hasattr(progress, "set_total"):
                progress.set_total(max(total_rows, 1))
            elif hasattr(progress, "setMaximum"):
                progress.setMaximum(max(total_rows, 1))
            else:
                progress.total = max(total_rows, 1)
            progress.set_value(0)
            progress.set_label("Lade Daten...")

        if not grabber_summary.ok:
            self._log("Warnung: DataGrabber meldet fehlerhafte Zeilen, fahre mit Validierungsdaten fort")

        # 5) Datenabruf (aus validierten Zeilen)
        datenabruf = Datenabruf(self.pruefmanager)
        result_dict, datenabruf_results = datenabruf.datenabruf(
            result_dict=source_dict,
            raumfilter=raumfilter,
            verfahrensgebiet_layer=raumfilter_layer,
            speicherort=final_pfad,
            pruef_ergebnisse=[grabber_summary],
            progress=progress,
        )

        self._log("Datenabruf abgeschlossen")

        pipeline_context = {
            "source": final_pfad,
            "linkliste": linkliste_final,
            "raumfilter": raumfilter_layer,
            "raumfilter_name": raumfilter,
            "source_dict": source_dict,
            "result_dict": result_dict,
            "datenabruf_results": datenabruf_results,
        }

        # 6) Lade Dienste in das Projekt aus result_dict
        load_summary = self._load_dienste_aus_result_dict(source_dict, pipeline_context, progress=progress)

        if progress is not None:
            progress.set_value(total_rows)
            progress.set_label("Pipeline abgeschlossen. Bitte OK klicken, um den Dialog zu schließen.")

        # 7) Log-Datei schreiben
        self._write_markdown_log(final_pfad, source_dict, pipeline_context, load_summary)

        print("=" * 60 + "\n")
        return pipeline_context

    def _load_dienste_aus_result_dict(self, source_dict: DataDict, pipeline_context: Dict[str, Any], progress: Optional[Any] = None) -> Dict[str, Any]:
        """Lädt Dienste (aus Linkliste) ins Projekt und persistiert optional mit Datenschreiber."""
        rows = source_dict.get("rows", [])
        total = len(rows)
        loaded_count = 0
        skipped_outside = 0
        aborted = False
        if not rows:
            self._log("Keine Dienste zum Laden")
            return

        final_pfad = pipeline_context.get("source") or ""
        use_datenschreiber = bool(final_pfad)

        datenschreiber = None
        if use_datenschreiber:
            datenschreiber = Datenschreiber(self.pruefmanager, gpkg_path=final_pfad)

        daten_dict: Dict[str, Any] = {"daten": {}}

        raumfilter_layer = pipeline_context.get("raumfilter")
        raumfilter_name = pipeline_context.get("raumfilter_name", "unbekannt")
        raumfilter_crs_authid = None
        if raumfilter_layer is not None and hasattr(raumfilter_layer, "crs") and callable(getattr(raumfilter_layer, "crs")):
            try:
                crs = raumfilter_layer.crs()
                if crs is not None and hasattr(crs, "authid") and callable(getattr(crs, "authid")):
                    raumfilter_crs_authid = crs.authid()
            except Exception:
                raumfilter_crs_authid = None
        # Für den späteren Filter benötigen wir entweder die reine Ausdehnung
        # (Pufferlayer) oder – im Falle eines echten Verfahrensgebiets – die
        # vollständige Geometrie. Die Filtermethode wird im Schleifenrumpf
        # ausgewählt.
        raumfilter_extent = None
        if raumfilter_layer is not None and getattr(raumfilter_layer, 'extent', None) is not None:
            raumfilter_extent = raumfilter_layer.extent()

        temp_layers: List[Any] = []
        layer_loader = LayerLoader(self.pruefmanager, stil_pruefer=self.stil_pruefer, layer_pruefer=self.link_pruefer)

        # Statistiken für Log: Raumfilter-Info pro Dienst
        row_stats: List[Dict[str, Any]] = []
        layer_call_status: Dict[str, str] = {}


        for idx, row in enumerate(rows, start=1):
            ident = str(row.get("ident") or "")
            provider = str(row.get("Provider", "")).lower()
            link = str(row.get("Link", ""))
            thema = str(row.get("Inhalt") or row.get("ident") or "Dienst")
            style = row.get("stildatei")

            daten_map = (pipeline_context.get("result_dict") or {}).get("daten", {})
            fetched_features = daten_map.get(ident, []) if isinstance(daten_map, dict) else []
            fetched_count = len(fetched_features) if isinstance(fetched_features, list) else None

            if progress is not None:
                progress.set_label(f"Lade Dienst {idx}/{total}: {thema}")
                progress.set_value(idx)
                if progress.is_canceled():
                    aborted = True
                    layer_call_status[thema] = "abbruch_vor_layeraufruf"
                    self._log("Nutzerabbruch: Pipeline gestoppt")
                    self.pruefmanager.verarbeite(
                        pruef_ergebnis(
                            ok=False,
                            meldung="Pipeline durch Benutzer abgebrochen",
                            aktion="abbruch",
                            kontext={"dienst": thema, "schritt": idx},
                        )
                    )
                    break


            self._log(f"Lade Dienst '{thema}' ({provider})")
            self._log(f"[DEBUG] Layeraufruf startet: thema='{thema}', provider='{provider}', link='{link}'")
            layer_call_status[thema] = "layeraufruf_start"

            layer = layer_loader.create_layer(provider, link, thema)

            if not layer:
                layer_call_status[thema] = "layer_nicht_ladbar"
                self._log(f"[DEBUG] Layeraufruf fehlgeschlagen: thema='{thema}'")
                row_stats.append({
                    "dienst": thema,
                    "provider": provider,
                    "link": link,
                    "style": style or "",
                    "datenabruf_features": fetched_count,
                    "total_features": None,
                    "filtered_features": None,
                    "status": "layer_nicht_ladbar",
                    "raumfilter": raumfilter_name,
                })
                continue

            layer_call_status[thema] = "layeraufruf_ok"
            self._log(f"[DEBUG] Layeraufruf erfolgreich: thema='{thema}'")

            if progress is not None and progress.is_canceled():
                aborted = True
                layer_call_status[thema] = "abbruch_nach_layeraufruf"
                self._log("Nutzerabbruch nach Layer-Erzeugung")
                break

            # Je nach Typ des Filters einen geeigneten Filter anwenden.
            if raumfilter_layer and raumfilter_name == "Verfahrensgebiet":
                # echte Geometrie-Schnittmenge, nicht nur BBox
                layer_for_write = layer_loader.filter_by_layer(
                    layer,
                    raumfilter_layer,
                    cancel_callback=(progress.is_canceled if progress is not None else None),
                )
            else:
                layer_for_write = layer_loader.filter_by_extent(
                    layer,
                    raumfilter_extent,
                    cancel_callback=(progress.is_canceled if progress is not None else None),
                    source_layer=raumfilter_layer,
                )

            if progress is not None and progress.is_canceled():
                aborted = True
                layer_call_status[thema] = "abbruch_nach_raumfilter"
                self._log("Nutzerabbruch nach Raumfilter")
                break

            # Zähle Features vor/nach Raumfilter
            total_features = None
            filtered_features = None
            try:
                if layer is not None and hasattr(layer, "featureCount"):
                    total_features = int(layer.featureCount())
            except Exception:
                total_features = None

            if layer_for_write is not None and hasattr(layer_for_write, "featureCount"):
                try:
                    filtered_features = int(layer_for_write.featureCount())
                except Exception:
                    filtered_features = None

            if not layer_for_write:
                layer_call_status[thema] = "raumfilter_ausserhalb"
                self._log(f"Dienst {thema} ist außerhalb des Raumfilters")
                skipped_outside += 1
                row_stats.append({
                    "dienst": thema,
                    "provider": provider,
                    "link": link,
                    "style": style or "",
                    "datenabruf_features": fetched_count,
                    "total_features": total_features,
                    "filtered_features": 0,
                    "status": "außerhalb",
                    "raumfilter": raumfilter_name,
                })
                continue

            if style:
                layer_loader.apply_style(layer_for_write, style)

            row_stats.append({
                "dienst": thema,
                "provider": provider,
                "link": link,
                "style": style or "",
                "datenabruf_features": fetched_count,
                "total_features": total_features,
                "filtered_features": filtered_features,
                "status": "geladen",
                "raumfilter": raumfilter_name,
            })
            layer_call_status[thema] = "geladen"
            self._log(f"[DEBUG] Dienst geladen: thema='{thema}', provider='{provider}', filtered_features={filtered_features}")


            if provider == "wms":
                # WMS ist Raster und wird nicht in GPKG geschrieben.
                # Im temporären Modus wird er trotzdem direkt geladen.
                loaded_count += 1
                if use_datenschreiber:
                    self._log(f"WMS-Layer {thema} wird nicht in GPKG gespeichert, nur in Projekt (temporär)")
                    # Während Datenbankmodus: wir speichern nicht in daten_dict,
                    # aber für gute Sichtbarkeit laden wir nach erfolgreichem Schreibprozess.
                    temp_layers.append(layer)
                else:
                    temp_layers.append(layer)
                continue

            if use_datenschreiber and datenschreiber:
                daten_dict["daten"][thema] = {
                    "layer": layer_for_write,
                    "style_path": style,
                }
            else:
                temp_layers.append(layer_for_write)

            loaded_count += 1

        if use_datenschreiber and datenschreiber and daten_dict["daten"]:
            self._log(f"Schreibe {len(daten_dict['daten'])} Layer in {final_pfad}")
            results = datenschreiber.schreibe_Daten(
                daten_dict,
                processed_results=pipeline_context.get("datenabruf_results", []),
                speicherort=final_pfad,
            )
            datenschreiber.lade_Layer(results)
            self._log("Datenschreiber abgeschlossen")
        elif temp_layers:
            self._log(f"Temporärmodus: Lade {len(temp_layers)} Layer ins Projekt")
            for layer in temp_layers:
                QgsProject.instance().addMapLayer(layer)
            self._log("Temporärmodus: Layer im Projekt geladen")
        else:
            self._log("Keine Layer zum Laden (kein persistierter GPkg-Write).")

        self._log(f"Dienst-Laden fertig ({len(rows)} Zeilen)")

        return {
            "row_count": len(rows),
            "loaded_count": loaded_count,
            "skipped_outside": skipped_outside,
            "aborted": aborted,
            "row_stats": row_stats,
            "layer_call_status": layer_call_status,
            "raumfilter_name": raumfilter_name,
        }

    def _create_local_layer_from_fetched_features(
        self,
        thema: str,
        features: List[Any],
        crs_authid: Optional[str] = None,
    ) -> Optional[QgsVectorLayer]:
        """Erzeugt aus bereits geholten GeoJSON-Features einen lokalen OGR-Layer.

        Verhindert einen zweiten potentiell blockierenden Remote-Aufruf (WFS/REST).
        """
        if not features:
            return None

        normalized_features: List[Dict[str, Any]] = []
        detected_crs_authid: Optional[str] = None
        for feature in features:
            if not isinstance(feature, dict):
                continue

            # Fall 1: bereits GeoJSON-Feature
            if feature.get("type") == "Feature" and isinstance(feature.get("geometry"), dict):
                normalized_features.append(feature)
                continue

            # Fall 2: ArcGIS Feature-JSON -> GeoJSON konvertieren
            attributes = feature.get("attributes")
            geometry = feature.get("geometry")
            if not isinstance(attributes, dict) or not isinstance(geometry, dict):
                continue

            if detected_crs_authid is None:
                try:
                    sr = geometry.get("spatialReference")
                    if isinstance(sr, dict):
                        wkid = sr.get("latestWkid") or sr.get("wkid")
                        if wkid:
                            detected_crs_authid = f"EPSG:{int(wkid)}"
                except Exception:
                    detected_crs_authid = None

            geojson_geometry: Dict[str, Any] | None = None

            # Point
            if "x" in geometry and "y" in geometry:
                geojson_geometry = {
                    "type": "Point",
                    "coordinates": [geometry.get("x"), geometry.get("y")],
                }
            # MultiPoint
            elif isinstance(geometry.get("points"), list):
                geojson_geometry = {
                    "type": "MultiPoint",
                    "coordinates": geometry.get("points", []),
                }
            # LineString / MultiLineString
            elif isinstance(geometry.get("paths"), list):
                paths = geometry.get("paths", [])
                if len(paths) == 1:
                    geojson_geometry = {
                        "type": "LineString",
                        "coordinates": paths[0],
                    }
                else:
                    geojson_geometry = {
                        "type": "MultiLineString",
                        "coordinates": paths,
                    }
            # Polygon / MultiPolygon
            elif isinstance(geometry.get("rings"), list):
                rings = geometry.get("rings", [])
                cleaned_rings = [
                    ring for ring in rings
                    if isinstance(ring, list) and len(ring) >= 4
                ]
                if len(cleaned_rings) == 1:
                    geojson_geometry = {
                        "type": "Polygon",
                        "coordinates": cleaned_rings,
                    }
                elif len(cleaned_rings) > 1:
                    # Robuster Fallback für ArcGIS-Ringe:
                    # Mehrere Ringe werden als MultiPolygon behandelt,
                    # damit nicht versehentlich alle Ringe als Löcher eines
                    # einzigen Polygons interpretiert werden.
                    geojson_geometry = {
                        "type": "MultiPolygon",
                        "coordinates": [[ring] for ring in cleaned_rings],
                    }

            if geojson_geometry is None:
                continue

            normalized_features.append(
                {
                    "type": "Feature",
                    "geometry": geojson_geometry,
                    "properties": attributes,
                }
            )

        if not normalized_features:
            self._log(f"[DEBUG] Keine konvertierbaren Features für lokalen Layer: thema='{thema}'")
            return None

        try:
            payload = {
                "type": "FeatureCollection",
                "features": normalized_features,
            }

            with tempfile.NamedTemporaryFile(
                suffix=".geojson",
                delete=False,
                mode="w",
                encoding="utf-8",
            ) as fh:
                json.dump(payload, fh, ensure_ascii=False)
                tmp_path = fh.name

            layer = QgsVectorLayer(tmp_path, thema, "ogr")
            if layer and layer.isValid():
                target_crs = detected_crs_authid or crs_authid
                if target_crs and QgsCoordinateReferenceSystem is not None and hasattr(layer, "setCrs"):
                    try:
                        layer.setCrs(QgsCoordinateReferenceSystem(target_crs))
                    except Exception:
                        pass
                self._log(
                    f"[DEBUG] Lokaler Layer gültig: thema='{thema}', "
                    f"input_features={len(features)}, geojson_features={len(normalized_features)}, "
                    f"layer_features={layer.featureCount()}, crs='{target_crs or 'unbekannt'}'"
                )
                return layer

            self._log(f"[DEBUG] Lokaler Layer aus Datenabruf ungültig: thema='{thema}', pfad='{tmp_path}'")
            return None
        except Exception as exc:
            self._log(f"[DEBUG] Fehler beim Erzeugen lokaler Featureschicht für {thema}: {exc}")
            return None

    def _write_markdown_log(
        self,
        final_pfad: str,
        source_dict: DataDict,
        pipeline_context: Dict[str, Any],
        load_summary: Dict[str, Any],
    ) -> None:
        """Schreibt den Pipeline-Log (Markdown)."""
        lines = [
            "# Plan41 Fachdaten-Ladevorgang",
            "",
            f"**Datum**: {datetime.datetime.now().isoformat()}",
            f"**Verfahrens-DB**: {final_pfad or 'temporär'}",
            f"**Linkliste**: {pipeline_context.get('linkliste')}",
            "",
            "## Zusammenfassung",
            "",
            f"- **Zeilen gesamt**: {load_summary.get('row_count', 0)}",
            f"- **Geladene Dienste**: {load_summary.get('loaded_count', 0)}",
            f"- **Außerhalb Raumfilter**: {load_summary.get('skipped_outside', 0)}",
            f"- **Abgebrochen**: {load_summary.get('aborted', False)}",
            f"- **Raumfilter**: {load_summary.get('raumfilter_name', 'unbekannt')}",
            f"- **Raumfilter-Typ**: {pipeline_context.get('raumfilter_name', 'unbekannt')}",
            "",
            "## Dienstliste",
            "",
            "| Dienst | Provider | Linkadresse | Aufrufstatus | Ergebnisstatus |",
            "|---|---|---|---|---|",
        ]

        status_by_dienst = {
            str(stat.get("dienst", "")): str(stat.get("status", "n/a"))
            for stat in load_summary.get("row_stats", [])
        }
        aufrufstatus_by_dienst = {
            str(key): str(value)
            for key, value in (load_summary.get("layer_call_status", {}) or {}).items()
        }

        for row in source_dict.get('rows', []):
            dienst = row.get('Inhalt') or row.get('ident') or ''
            provider = row.get('Provider') or ''
            link = row.get('Link') or ''
            aufrufstatus = aufrufstatus_by_dienst.get(str(dienst), "nicht_aufgerufen")
            ergebnisstatus = status_by_dienst.get(str(dienst), "n/a")
            lines.append(f"| {dienst} | {provider} | {link} | {aufrufstatus} | {ergebnisstatus} |")

        lines.extend([
            "",
            "## Raumfilter-Statistik",
            "",
            "| Dienst | Provider | Linkadresse | Datenabruf-Objekte | Gesamt-Objekte | Gefilterte Objekte | Raumfilter | Status |",
            "|---|---|---|---|---|---|---|---|",
        ])

        for stat in load_summary.get('row_stats', []):
            lines.append(
                f"| {stat.get('dienst', '')} | {stat.get('provider', '')} | {stat.get('link', '')} | {stat.get('datenabruf_features', 'n/a')} | {stat.get('total_features', 'n/a')} | {stat.get('filtered_features', 'n/a')} | {stat.get('raumfilter', '')} | {stat.get('status', 'n/a')} |"
            )

        markdown = "\n".join(lines)

        if final_pfad:
            log_dir = os.path.dirname(final_pfad)
            os.makedirs(log_dir, exist_ok=True)
            log_file = os.path.join(log_dir, "plan41_lade_log.md")
            try:
                with open(log_file, "w", encoding="utf-8") as fh:
                    fh.write(markdown)

                self.pruefmanager.verarbeite(
                    pruef_ergebnis(
                        ok=True,
                        meldung=f"Lade-Log gespeichert: {log_file}",
                        aktion="log_geschrieben",
                        kontext={"log_file": log_file},
                    )
                )
                info("Lade-Log", f"Lade-Protokoll gespeichert: {log_file}", duration=10)
            except Exception as exc:
                self.pruefmanager.verarbeite(
                    pruef_ergebnis(
                        ok=False,
                        meldung=f"Fehler beim Schreiben des Logle (md): {exc}",
                        aktion="log_schreiben_fehlgeschlagen",
                        kontext={"error": str(exc)},
                    )
                )
                warning("Lade-Log", f"Konnte Datei nicht schreiben: {exc}", duration=10)
        else:
            # temporärer Modus: nur anzeigen
            info("Lade-Log (temporär)", markdown, duration=20)


    def _clone_layer_with_extent(self, layer: QgsVectorLayer, extent, thema: str) -> QgsVectorLayer | None:
        """Erstellt eine Memory-Kopie von <layer> mit Geometrien im BBOX-Raumfilter."""
        try:
            request = QgsFeatureRequest().setFilterRect(extent)
            features = list(layer.getFeatures(request))
            if not features:
                return None

            geom_type_map = {0: "Point", 1: "LineString", 2: "Polygon"}
            geom_type = geom_type_map.get(layer.geometryType(), "Polygon")
            uri = f"{geom_type}?crs={layer.crs().authid()}"

            filtered_layer = QgsVectorLayer(uri, f"{thema}_BBOX", "memory")
            if not filtered_layer or not filtered_layer.isValid():
                self._log(f"Fehler beim Erzeugen des temporären Filterlayers für {thema}")
                return None

            provider = filtered_layer.dataProvider()
            provider.addAttributes(layer.fields())
            filtered_layer.updateFields()
            provider.addFeatures(features)
            filtered_layer.updateExtents()

            return filtered_layer
        except Exception as e:
            self._log(f"Fehler beim Filtern von {thema} nach Raumfilter: {e}")
            return None


    def _resolve_linkliste(self, linkliste: str | None) -> str | None:
        """
        Prüft und normalisiert den Linklisten-Pfad.

        Rückgabe:
        - gültiger Pfad zur Linkliste (str)
        - None → Pipeline abbrechen
        """

        # --------------------------------------------------
        # Standard-Linkliste (plattformneutral)
        # --------------------------------------------------
        plugin_root = get_plugin_root()
        standard_linkliste = join_path(plugin_root, "sn_plan41","assets", "Linkliste.xlsx")

        # --------------------------------------------------
        # 🔹 LEERE EINGABE → AUTOMATISCH STANDARDDATEI
        # --------------------------------------------------
        if not linkliste:
            linkliste_final = str(standard_linkliste)
            self.set_linkliste(linkliste_final)
            return linkliste_final

        # --------------------------------------------------
        # Dateiprüfung nur bei expliziter Eingabe
        # --------------------------------------------------
       
        pruefer = Dateipruefer(
            pfad=linkliste,
            leereingabe_erlaubt=True,
            standarddatei=str(standard_linkliste),
        )

        ergebnis = pruefer.pruefe()

        # --------------------------------------------------
        # Entscheidung über Pruefmanager
        # --------------------------------------------------
        ergebnis = self.pruefmanager.verarbeite(ergebnis)

        if not ergebnis.ok:
            # Nutzer hat abgebrochen oder Fehler nicht bestätigt
            return None

        # --------------------------------------------------
        # Erfolgsfall → geprüften Pfad übernehmen
        # --------------------------------------------------
        linkliste_final = str(ergebnis.kontext)

        # Optional: Projektvariable aktualisieren
        self.set_linkliste(linkliste_final)

        return linkliste_final

    def _resolve_raumfilter(self, raumfilter: str, source: str) -> QgsVectorLayer | None:
        self._log(f"Raumfilter-Auswahl: '{raumfilter}'")
        self._log(f"Source: '{source}'")

        if raumfilter == "Verfahrensgebiet":
            layer = self._get_verfahrensgebiet_layer()
            self._log(
                "Verfahrensgebiet gefunden"
                if layer else
                "❌ Kein Verfahrensgebiet im Projekt"
            )
            return layer

        if raumfilter == "Pufferlayer":
            self._log("Pufferlayer-Modus aktiv")
            return self._handle_pufferlayer(source)

        self._log("Kein Raumfilter gewählt")
        return None


    def _get_verfahrensgebiet_layer(self) -> QgsVectorLayer | None:
        layer_id = self.load_verfahrensgebiet_layer_id()
        self._log(f"Verfahrensgebiet-Layer-ID: {layer_id}")

        if not layer_id:
            self._log("❌ Keine Layer-ID gespeichert")
            return None

        layer = QgsProject.instance().mapLayer(layer_id)
        if not layer:
            self._log("❌ Layer-ID existiert nicht im Projekt")
            return None

        if not self.is_valid_verfahrensgebiet_layer(layer):
            self._log("❌ Layer ist kein gültiger Vektorlayer")
            return None

        self._log(f"Verfahrensgebiet-Layer OK: '{layer.name()}'")
        return layer


    def _handle_pufferlayer(self, source: str) -> QgsVectorLayer | None:
        self._log("Prüfe vorhandenen Pufferlayer im Projekt")

        existing = self._load_existing_pufferlayer()
        if existing:
            self._log("✔ Pufferlayer bereits im Projekt vorhanden")
            return existing

        self._log("Kein Pufferlayer im Projekt")

        if source:
            self._log("Prüfe Pufferlayer im Source")
            exists = self._pufferlayer_exists_in_source(source)
            self._log(f"Pufferlayer im Source vorhanden: {exists}")

            if exists:
                return self._load_existing_pufferlayer() or self._create_pufferlayer()

        self._log("Erzeuge neuen Pufferlayer")
        return self._create_pufferlayer()


    def _load_existing_pufferlayer(self) -> QgsVectorLayer | None:
        """
        Liefert einen vorhandenen Pufferlayer aus dem Projekt.
        """
        layers = QgsProject.instance().mapLayersByName("Pufferlayer")
        return layers[0] if layers else None

    
    def _create_pufferlayer(self) -> QgsVectorLayer | None:
        self._log("Starte Pufferlayer-Erstellung")

        basis_layer = self._get_verfahrensgebiet_layer()
        if not basis_layer:
            self._log("❌ Kein Verfahrensgebiet → kein Puffer möglich")
            return None
        source = self.load_verfahrens_db()
        self._log(f"Basislayer: '{basis_layer.name()}'")

        layer = self.Pufferlayer_erstellen(
            basis_layer=basis_layer,
            distance=1000,
            name="Pufferlayer",
            source=source,
        )

        self._log(
            "✔ Pufferlayer erfolgreich erzeugt"
            if layer else
            "❌ Pufferlayer-Erstellung fehlgeschlagen"
        )
        return layer


    from sn_basis.functions.qgiscore_wrapper import QgsVectorLayer

    def _pufferlayer_exists_in_source(self, source: str) -> bool:
        """
        Prüft, ob im Source (z.B. GPKG) ein Layer namens 'Pufferlayer' existiert.
        """
        if not source:
            return False

        uri = f"{source}|layername=Pufferlayer"
        layer = QgsVectorLayer(uri, "Pufferlayer", "ogr")

        return layer.isValid()


    
    def Pufferlayer_erstellen(
        self,
        basis_layer: QgsVectorLayer,
        distance: float,
        name: str,
        source: str | None = None,
    ) -> QgsVectorLayer | None:
        """
    Erzeugt einen rechteckigen Pufferlayer (BBOX + Abstand)
    um das Verfahrensgebiet.

    - Ohne Source → temporärer Memory-Layer
    - Mit Source → Schreiben über Datenschreiber

    Parameters
    ----------
    basis_layer : QgsVectorLayer
        Verfahrensgebiet-Layer.
    distance : float
        Pufferabstand in Metern.
    name : str
        Name des Ziel-Layers.
    source : str | None
        Zielquelle (z.B. Verfahrens-DB) oder None für temporär.

    Returns
    -------
    QgsVectorLayer | None
        Neuer Pufferlayer oder None bei Fehler.
    """
        if not basis_layer or not basis_layer.isValid():
            self._log("❌ Basislayer ungültig – kein Puffer möglich")
            return None

        # --------------------------------------------------
        # 1. Rechteck-Geometrie (Extent + Puffer)
        # --------------------------------------------------
        extent = basis_layer.extent().buffered(distance)
        bbox_geom = QgsGeometry.fromRect(extent)

        # --------------------------------------------------
        # 2. CRS übernehmen
        # --------------------------------------------------
        crs_auth = basis_layer.crs().authid()
        uri = f"Polygon?crs={crs_auth}"

        mem_layer = QgsVectorLayer(uri, name, "memory")
        provider = mem_layer.dataProvider()
        provider.addAttributes([
            QgsField("id", QVariant.Int)
        ])
        mem_layer.updateFields()


        
        # --------------------------------------------------
        # 4. Feature erzeugen
        # --------------------------------------------------
        feat = QgsFeature(mem_layer.fields())
        feat.setGeometry(bbox_geom)
        feat["id"] = 1
        provider.addFeature(feat)
        mem_layer.updateExtents()

        # --------------------------------------------------
        # 5. Temporärer Modus → direkt ins Projekt
        # --------------------------------------------------
        if not source:
            QgsProject.instance().addMapLayer(mem_layer)
            self._log("✔ Temporärer rechteckiger Pufferlayer erzeugt")
            return mem_layer

        # --------------------------------------------------
        # 6. Persistenter Modus → Datenschreiber
        # --------------------------------------------------
        writer = Datenschreiber(
            pruefmanager=self.pruefmanager,
            gpkg_path=source,
        )

        daten_dict = {
            "daten": {
                name: {
                    "layer": mem_layer
                }
            }
        }


        results = writer.schreibe_Daten(
            daten_dict=daten_dict,
            processed_results=[],
            speicherort=source,
        )

        if not results:
            self._log("❌ Schreiben des Pufferlayers fehlgeschlagen")
            return None

        writer.lade_Layer(results)

        layers = QgsProject.instance().mapLayersByName(name)
        if layers:
            self._log("✔ Persistenter rechteckiger Pufferlayer geladen")
            return layers[0]

        return None