# Importiert den Event-Loop und URL-Objekte aus der PyQt-Bibliothek von QGIS
from qgis.PyQt.QtCore import QEventLoop, QUrl
# Importiert den NetworkAccessManager aus dem QGIS Core-Modul
from qgis.core import QgsNetworkAccessManager
# Importiert das QNetworkRequest-Objekt für HTTP-Anfragen
from qgis.PyQt.QtNetwork import QNetworkRequest
# Importiert die Klasse für das Ergebnisobjekt der Prüfung
from pruef_ergebnis import PruefErgebnis

# Definiert die Klasse zum Prüfen von Links
class Linkpruefer:
    """Prüft den Link mit QgsNetworkAccessManager und klassifiziert Anbieter nach Attribut."""

    # Statische Zuordnung möglicher Anbietertypen als Konstanten
    ANBIETER_TYPEN: dict[str, str] = {
        "REST": "REST",
        "WFS": "WFS",
        "WMS": "WMS",
        "OGR": "OGR"
    }

    # Konstruktor zum Initialisieren der Instanz
    def __init__(self, link: str, anbieter: str):
        # Speichert den übergebenen Link als Instanzvariable
        self.link = link
        
       # Speichert den Anbietertyp, bereinigt und in Großbuchstaben (auch wenn leer oder None)
        self.anbieter = anbieter.upper().strip() if anbieter else ""
        # Erstellt einen neuen NetworkAccessManager für Netzwerkverbindungen
        self.network_manager = QgsNetworkAccessManager()

    # Methode zur Klassifizierung des Anbieters und der Quelle
    def klassifiziere_anbieter(self):
        # Bestimmt den Typ auf Basis der vorgegebenen Konstante oder nimmt den Rohwert
        typ = self.ANBIETER_TYPEN.get(self.anbieter, self.anbieter)
        # Unterscheidet zwischen "remote" (http/https) oder "local" (Dateipfad)
        quelle = "remote" if self.link.startswith(("http://", "https://")) else "local"
        # Gibt Typ und Quelle als Dictionary zurück
        return {
            "typ": typ,
            "quelle": quelle
        }


    # Prüft die Erreichbarkeit und Plausibilität des Links
    def pruefe_link(self):
        # Initialisiert Listen für Fehler und Warnungen
        fehler = []
        warnungen = []

        # Prüft, ob ein Link übergeben wurde
        if not self.link:
            fehler.append("Link fehlt.")
            return PruefErgebnis(False, fehler=fehler, warnungen=warnungen)
        
        # Prüft, ob ein Anbieter angegeben ist
        if not self.anbieter or not self.anbieter.strip():
            fehler.append("Anbieter muss gesetzt werden und darf nicht leer sein.")

        # Prüfung für Remote-Links (http/https)
        if self.link.startswith(("http://", "https://")):
            # Erstellt eine HTTP-Anfrage mit dem Link
            request = QNetworkRequest(QUrl(self.link))
            # Startet eine HEAD-Anfrage über den NetworkManager
            reply = self.network_manager.head(request)

            # Wartet synchron auf die Netzwerkanwort (Event Loop)
            loop = QEventLoop()
            reply.finished.connect(loop.quit)
            loop.exec_()

            # Prüft auf Netzwerkfehler
            if reply.error():
                fehler.append(f"Verbindungsfehler: {reply.errorString()}")
            else:
                # Holt den HTTP-Statuscode aus der Antwort
                status = reply.attribute(reply.HttpStatusCodeAttribute)
                # Prüft, ob der Status außerhalb des Erfolgsbereichs liegt
                if status is None or status < 200 or status >= 400:
                    fehler.append(f"Link nicht erreichbar: HTTP {status}")
            # Räumt die Antwort auf (Vermeidung von Speicherlecks)
            reply.deleteLater()
        else:
            # Plausibilitäts-Check für lokale Links (Dateien), prüft auf Dateiendung
            if "." not in self.link.split("/")[-1]:
                warnungen.append("Der lokale Link sieht ungewöhnlich aus.")

        # Gibt das Ergebnisobjekt mit allen gesammelten Informationen zurück
        return PruefErgebnis(len(fehler) == 0, daten=self.klassifiziere_anbieter(), fehler=fehler, warnungen=warnungen)

    # Führt die Linkprüfung als externe Methode aus
    def ausfuehren(self):
        # Gibt das Ergebnis der Prüf-Methode zurück
        return self.pruefe_link()