Plugin_SN_Basis/modules/Pruefmanager.py

"""
sn_basis/modules/Pruefmanager.py
"""

from __future__ import annotations
from typing import Optional, Any

from sn_basis.functions import ask_yes_no, info, warning, error, ask_overwrite_append_cancel_custom
from sn_basis.modules.pruef_ergebnis import pruef_ergebnis, PruefAktion
print("DEBUG: Pruefmanager DATEI GELADEN:", __file__)

class Pruefmanager:
    def __init__(self, ui_modus: str = "qgis", parent: Optional[Any] = None) -> None:
        self.ui_modus = ui_modus
        self.parent = parent

    # ------------------------------------------------------------------
    # Meldungen / Zusammenfassungen
    # ------------------------------------------------------------------
    def report_error(
        self,
        thema: str,
        meldung: str,
        *,
        aktion: Optional[PruefAktion] = None,
        kontext: Optional[Any] = None,
    ) -> None:
        critical_actions = {
            "netzwerkfehler", "pruefe_exception", "save_exception",
            "layer_create_failed", "read_error", "open_error",
        }
        warn_actions = {
            "datei_nicht_gefunden", "pfad_nicht_gefunden", "url_nicht_erreichbar",
            "falsche_endung", "kein_header", "kein_arbeitsblatt",
        }

        if aktion in critical_actions:
            error(thema, meldung)
            return
        if aktion in warn_actions:
            warning(thema, meldung)
            return
        warning(thema, meldung)

    def report_summary(self, summary: dict) -> None:
        geladen = summary.get("geladen", [])
        fehler = summary.get("fehler", {})
        ausserhalb = summary.get("ausserhalb", [])
        relevant = summary.get("relevant", [])

        message = (
            f"Geladene Dienste: {len(geladen)}\n"
            f"Relevante Dienste: {len(relevant)}\n"
            f"Dienste ausserhalb: {len(ausserhalb)}\n"
            f"Fehler: {len(fehler)}"
        )
        info("DataGrabber Zusammenfassung", message)

    # ------------------------------------------------------------------
    # VERFAHRENS-DB-spezifische Entscheidungen
    # ------------------------------------------------------------------
    def _handle_datei_existiert(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
        """Handhabt das Szenario, dass die Ziel-Verfahrens-DB bereits existiert.

        Zeigt einen einzigen Dialog mit drei Optionen an:
        - **Überschreiben**: Bestehende Layer ersetzen (entspricht YES)
        - **Anhängen**: Neue Layer zur Datei hinzufügen (entspricht NO)  
        - **Abbrechen**: Vorgang beenden (entspricht CANCEL)

        Parameters
        ----------
        ergebnis : pruef_ergebnis
            Eingabe-Ergebnis mit Dateipfad im ``kontext``-Attribut.

        Returns
        -------
        pruef_ergebnis
            Ergebnis mit Aktion:
            - ``datei_existiert_ueberschreiben``
            - ``datei_existiert_anhaengen``  
            - ``datei_existiert_ueberspringen`` (für Cancel-Fall)
        """
        if self.ui_modus != "qgis":
            return ergebnis

        pfad = ergebnis.kontext
        pfad_str = str(pfad) if pfad else "unbekannt"

        titel = "Verfahrens-DB existiert bereits"
        meldung = (
            f"Die Datei '{pfad_str}' existiert bereits.\n\n"
            "Was soll geschehen?\n\n"
            "• **Überschreiben**: Bestehende Layer ersetzen\n"
            "• **Anhängen**: Neue Layer hinzufügen\n"
            "• **Abbrechen**: Vorgang beenden"
        )

        # Einzelner Dialog mit drei Optionen
        entscheidung = ask_overwrite_append_cancel_custom(
            parent=self.parent,
            title=titel,
            message=meldung
        )

        if entscheidung == "overwrite":
            return pruef_ergebnis(
                ok=True,
                aktion="datei_existiert_ueberschreiben",
                kontext=ergebnis.kontext,
            )
        elif entscheidung == "append":
            return pruef_ergebnis(
                ok=True,
                aktion="datei_existiert_anhaengen",
                kontext=ergebnis.kontext,
            )
        else:  # cancel
            return pruef_ergebnis(
                ok=True,
                aktion="datei_existiert_ueberspringen",
                kontext=ergebnis.kontext,
            )
    # ------------------------------------------------------------------
    # Basis-Entscheidungen (KORREKT: → pruef_ergebnis)
    # ------------------------------------------------------------------
    def _handle_basic_decision(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
        """Basis-Entscheidung für einfache Ja/Nein-Fragen."""
        print(f"DEBUG _handle_basic_decision: aktion='{ergebnis.aktion}', ui_modus='{self.ui_modus}'")
        
        if self.ui_modus != "qgis":
            print("DEBUG: Nicht QGIS → ergebnis unverändert")
            return ergebnis

        title_map = {
            "leereingabe_erlaubt": "Ohne Eingabe fortfahren",
            "standarddatei_vorschlagen": "Standarddatei verwenden",
            "temporaer_erlaubt": "Temporäre Layer erzeugen",
            "layer_unsichtbar": "Layer einblenden",
        }

        title = title_map.get(ergebnis.aktion, "Entscheidung erforderlich")
        meldung = ergebnis.meldung or ""

        try:
            print(f"DEBUG ask_yes_no: title='{title}', meldung='{meldung[:50]}...'")
            yes = ask_yes_no(title, meldung, default=False, parent=self.parent)
            print(f"DEBUG ask_yes_no: yes={yes}")
        except Exception as e:
            print(f"DEBUG ask_yes_no Exception: {e}")
            return ergebnis

        if not yes:
            print("DEBUG: Nutzer sagte Nein → ok=False")
            return ergebnis

        # Nutzer sagte Ja
        if ergebnis.aktion == "temporaer_erlaubt":
            print("DEBUG: temporaer_erlaubt bestätigt → ok=True")
            return pruef_ergebnis(
                ok=True,
                aktion="temporaer_erlaubt",
                kontext=ergebnis.kontext
            )

        print("DEBUG: Andere Aktion bestätigt → ok=True, aktion='ok'")
        return pruef_ergebnis(
            ok=True,
            aktion="ok",
            kontext=ergebnis.kontext
        )

    # ------------------------------------------------------------------
    # Hauptlogik: verarbeite() (KORRIGIERT!)
    # ------------------------------------------------------------------
    def verarbeite(self, ergebnis: pruef_ergebnis) -> pruef_ergebnis:
        print("🔥 verarbeite() START")
        print("DEBUG Pruefmanager:", ergebnis.ok, ergebnis.aktion)
        print("DEBUG ergebnis.aktion TYPE:", type(ergebnis.aktion), repr(ergebnis.aktion))
        
        # 1. Erfolg → direkt weiter
        print("🔍 Schritt 1: Prüfe ergebnis.ok =", ergebnis.ok)
        if ergebnis.ok:
            print("✅ Schritt 1: ok=True → return")
            return ergebnis

        # 2. VERFAHRENS-DB: Bestehende Datei
        print("🔍 Schritt 2: Prüfe datei_existiert =", ergebnis.aktion == "datei_existiert")
        if ergebnis.aktion == "datei_existiert":
            print("✅ Schritt 2: _handle_datei_existiert")
            return self._handle_datei_existiert(ergebnis)

        # 3. Basis interaktive Aktionen
        print("🔍 Schritt 3: Definiere interactive_actions")
        interactive_actions = {
            "leereingabe_erlaubt",
            "standarddatei_vorschlagen", 
            "temporaer_erlaubt",
            "layer_unsichtbar",
        }
        print("DEBUG interactive_actions:", repr(interactive_actions))
        print("DEBUG ergebnis.aktion in interactive_actions?", ergebnis.aktion in interactive_actions)
        
        if ergebnis.aktion in interactive_actions:
            print("✅ Schritt 3: Interaktive Aktion → _handle_basic_decision")
            decision = self._handle_basic_decision(ergebnis)
            print(f"DEBUG: _handle_basic_decision Ergebnis: ok={decision.ok}, aktion='{decision.aktion}'")
            return decision

        # 4. Fehler behandeln
        print("❌ Schritt 4: FEHLER BEHANDELN")
        self.report_error(
            thema=ergebnis.aktion or "pruefung",
            meldung=ergebnis.meldung or "",
            aktion=ergebnis.aktion,
            kontext=ergebnis.kontext,
        )
        print("🔥 verarbeite() ENDE mit ok=False")
        return ergebnis