// gui-address-co.js
// Aufgabe: übergeordnete Verantwortung für die komplette Abwicklung einer Adresssuche auf dem gui

import { showToast, wait, mylog } from './sc-utilities.js';
import { handleBsUpdate } from './bs-gen-co.js';
import { BackendService } from './backend-poi.js';
import { mapState, demarcateElement } from './map-gen-mgr.js';
import { unspiderfyCluster } from './map-cluster-mgr.js'; // highlightCluster entfernt, da in handleClusterClickLogic erwartet
import { UpdateMarkerIcon } from './map-poi-mgr.js'; 
import { handleClusterClickLogic } from './map-cluster-mgr.js';

let currentAddressMarker = null; // Intern für dieses Modul, verwaltet den Adress-Marker

/**
 * Sucht nach einem POI (Point of Interest) Marker oder dem übergeordneten Cluster eines POI-Markers
 * an bestimmten Koordinaten innerhalb einer definierten Toleranz.
 *
 * @param {L.Map} mapInstance 
 * @param {L.MarkerClusterGroup} markerClusterGroup 
 * @param {number} lat 
 * @param {number} lon 
 * @param {string} searchStreetName 
 * @param {string} searchHouseNumber 
 * @returns {L.Marker | L.MarkerCluster | null} Der gefundene Marker oder Cluster, oder null.
 */
function findPoiAtCoordinates(mapInstance, markerClusterGroup, lat, lon, searchStreetName = '', searchHouseNumber = '') {
    const searchLatLng = L.latLng(lat, lon);
    const toleranceMeters = 100;

    let firstMarkerInTolerance = null;
    const allMarkersInTolerance = [];
    const matchingStreetAndHouseNumberMarkers = [];

    const normalizeStreetName = (name) => {
        if (!name) return '';
        return name.toLowerCase().replace(/\s+/g, ' ').replace(/str\./g, 'straße').trim();
    };

    const normalizeHouseNumber = (number) => {
        let normalized = String(number).toLowerCase().trim();
        return normalized;
    };

    const normalizedSearchStreetName = normalizeStreetName(searchStreetName);
    const hasSearchStreetName = normalizedSearchStreetName.length > 0;
    // KORREKTUR: Verwende den Parameter searchHouseNumber (vorher falsch: houseNo)
    const normalizedSearchHouseNumber = normalizeHouseNumber(searchHouseNumber); 
    const hasSearchHouseNumber = normalizedSearchHouseNumber.length > 0;

    mylog(`DEBUG (findPoiAtCoordinates): Suche POI mit Adresse: "${searchStreetName} ${searchHouseNumber}"`);

    markerClusterGroup.eachLayer(function (layer) {
        if (layer instanceof L.Marker) {
            const markerLatLng = layer.getLatLng();
            const distance = markerLatLng.distanceTo(searchLatLng);

            if (distance <= toleranceMeters) {
                allMarkersInTolerance.push(layer);

                const poiStreetNameRaw = layer.options?.data?.street || '';
                const normalizedPoiStreetName = normalizeStreetName(poiStreetNameRaw);
                const poiHouseNumberRaw = layer.options?.data?.house_no || '';
                const normalizedPoiHouseNumber = normalizeHouseNumber(poiHouseNumberRaw);

                let streetNameMatches = false;
                if (hasSearchStreetName) {
                    streetNameMatches = normalizedPoiStreetName.includes(normalizedSearchStreetName) ||
                        normalizedSearchStreetName.includes(normalizedPoiStreetName);
                } else {
                    streetNameMatches = true;
                }

                let houseNumberMatches = false;
                if (hasSearchHouseNumber) {
                    houseNumberMatches = normalizedPoiHouseNumber === normalizedSearchHouseNumber;
                } else {
                    houseNumberMatches = true;
                }

                const fullAddressMatches = streetNameMatches && houseNumberMatches;

                if (fullAddressMatches) {
                    matchingStreetAndHouseNumberMarkers.push(layer);
                    if (!firstMarkerInTolerance) {
                        firstMarkerInTolerance = layer;
                    }
                }
            }
        }
    });

    if ((hasSearchStreetName || hasSearchHouseNumber) && matchingStreetAndHouseNumberMarkers.length === 1) {
        return matchingStreetAndHouseNumberMarkers[0];
    }
    if (!(hasSearchStreetName || hasSearchHouseNumber) && allMarkersInTolerance.length === 1) {
        return allMarkersInTolerance[0];
    }

    let markerForParentCheck = null;
    if (matchingStreetAndHouseNumberMarkers.length > 0) {
        markerForParentCheck = matchingStreetAndHouseNumberMarkers[0];
    } else if (allMarkersInTolerance.length > 0) {
        markerForParentCheck = allMarkersInTolerance[0];
    }

    if (!markerForParentCheck) {
        return null;
    }

    const visibleParent = markerClusterGroup.getVisibleParent(markerForParentCheck);

    if (visibleParent) {
        if (visibleParent instanceof L.MarkerCluster) {
            mylog(`DEBUG (findPoiAtCoordinates - Ergebnis): Cluster gefunden mit ${visibleParent.getChildCount()} Children.`);
            return visibleParent;
        } else if (visibleParent instanceof L.Marker) {
            mylog(`DEBUG (findPoiAtCoordinates - Ergebnis): Einzelnen Marker gefunden.`);
            return visibleParent;
        }
    }

    return firstMarkerInTolerance;
}

/**
 * Hilfsfunktion, um das übergeordnete L.MarkerCluster-Objekt für einen Marker zu finden.
 * @param {L.MarkerClusterGroup} markerClusterGroup - Die MarkerClusterGroup-Instanz.
 * @param {L.Marker} marker - Der Marker, dessen Eltern-Cluster gesucht wird.
 * @returns {L.MarkerCluster | null} Das übergeordnete Cluster oder null, wenn keines gefunden.
 */
function getParentCluster(markerClusterGroup, marker) {
    if (!marker || !(marker instanceof L.Marker)) {
        return null;
    }

    // Leaflet.MarkerCluster bietet eine Methode, um den Parent des Markers zu finden.
    const parent = markerClusterGroup.getVisibleParent(marker);
    
    if (parent && parent instanceof L.MarkerCluster) {
        return parent;
    }

    return null;
}


/**
 * Entfernt den Adress-Marker von der Karte, falls vorhanden.
 * @param {L.Map} map - Die Leaflet-Karteninstanz.
 */
export function removeAddressMarker(map) {
    if (currentAddressMarker) {
        map.removeLayer(currentAddressMarker);
        currentAddressMarker = null;
        mylog("DEBUG (gui-addr-co.js): Adress-Marker entfernt.");
    }
}


/**
 * Kernlogik zur Verarbeitung des gefundenen POI/Clusters, ausgeführt nach erfolgreicher Navigation
 * und nachdem die ClusterGroup ihre Elemente neu gezeichnet hat.
 */
async function processFoundPoiOrCluster(
    map,
    markerClusterGroup,
    bottomSheetUI,
    elementToZoomTo,
    targetClusterToSpiderfy,
    userLocationInstance,
    backendService,
    getAdminModeStatus
) {
    // 1. AUFRÄUMEN (Alten Status demarkieren und Unspiderfy)
    if (mapState.activeMarkerOrCluster) {
        const type = mapState.activeMarkerOrCluster instanceof L.MarkerCluster ? 'Cluster' : 'Marker';
        const gid = mapState.activeMarkerOrCluster.options?.data?.gid || 'N/A';
        const leafletId = mapState.activeMarkerOrCluster._leaflet_id;

        // VERBESSERTES DEBUG-STATEMENT
        mylog(`DEBUG (gui-addr-co.js): Starte Demarkierung des ALTEN aktiven Elements: Typ=${type}, GID=${gid}, Leaflet ID=${leafletId}.`);
        
        demarcateElement(mapState.activeMarkerOrCluster, mapState);
    } else {
        // ZUSÄTZLICHES DEBUG-STATEMENT, wenn keine Demarkierung nötig ist
        mylog("DEBUG (gui-addr-co.js): KEIN aktives Marker/Cluster zum Demarkieren gefunden. Demarkierung übersprungen.");
    }
    
    unspiderfyCluster(markerClusterGroup, mapState);
    mylog("DEBUG (gui-addr-co.js): Aufräumen abgeschlossen (Unspiderfy ausgeführt).");

    // 2. NEUEN STATUS setzen
    mapState.activeMarkerOrCluster = elementToZoomTo;
    
    // 3. HIGHLIGHTING und KARTEN-UPDATE anwenden
    if (targetClusterToSpiderfy) {
        // Ruft die zentrale Cluster-Klick-Logik auf, die Spiderfy, Highlight des Clusters und BS-Update übernimmt.
        mylog("DEBUG (gui-addr-co.js): Rufe handleClusterClickLogic für Spiderfy/Highlight auf.");

        await handleClusterClickLogic(
            targetClusterToSpiderfy, 
            markerClusterGroup, 
            map, 
            bottomSheetUI, 
            userLocationInstance, 
            backendService, 
            getAdminModeStatus, 
            mapState
        );
        
        // Stellen Sie sicher, dass der spezifische Ziel-Marker im gespiderten Zustand hervorgehoben wird,
        // falls das Cluster gespidert wurde und der Zielpunkt ein Marker war.
        if (elementToZoomTo instanceof L.Marker) {
             mapState.activeMarkerOrClusterGID = elementToZoomTo.options.data.gid;
            // UpdateMarkerIcon übernimmt das Highlighting für den Einzelmarker im gespiderten Cluster
            UpdateMarkerIcon(elementToZoomTo, true);
        }

    } else if (elementToZoomTo instanceof L.Marker) {
        // Fall: Einzelner Marker, der NICHT in einem Cluster ist (oder der Cluster Group unbekannt)
        mylog("DEBUG (gui-addr-co.js): Einzelner Marker gefunden, kein Parent-Cluster. Wende Marker-Highlight an.");
        mapState.activeMarkerOrClusterGID = elementToZoomTo.options.data.gid;
        // UpdateMarkerIcon übernimmt das Highlighting und die Markierung im mapState
        UpdateMarkerIcon(elementToZoomTo, true);
    }

    // Bottom Sheet für gefundenen POI/Cluster/Marker aktualisieren
    // HINWEIS: Wir verwenden `elementToZoomTo` für das BS, da es der primäre Fokus ist.
    handleBsUpdate(
        elementToZoomTo,
        bottomSheetUI,
        mapState,
        userLocationInstance,
        getAdminModeStatus,
        markerClusterGroup,
        map,
        backendService
    );
}


/**
 * Behandelt die Logik, wenn eine Adresse auf der Karte gefunden wurde.
 * Navigiert die Karte, setzt Adress-Marker und leitet die POI-Auswertung ein.
 * DIES IST DER ORT DER EHEMALIGEN onAddressSelectedForMap()-LOGIK.
 *
 * @param {L.Map} map - Die Leaflet-Karteninstanz.
 * @param {L.MarkerClusterGroup} markerClusterGroup - Die MarkerClusterGroup-Instanz.
 * @param {object} bottomSheetUI - Das Objekt zur Steuerung des Bottom Sheet UI (muss Methoden wie close() haben).
 * @param {object} addressData - Das Adress-Objekt (lat, lon, street, houseNr, district, ggf. gid).
 * @param {boolean} isValidPointAddress - Gibt an, ob die Adresse genau genug ist.
 * @param {BackendService} backendService - Eine Instanz des BackendService.
 * @param {function} getAdminModeStatus - Eine Funktion für den Admin-Modus-Status.
 * @param {object} userLocationInstance - Die Instanz des UserLocation-Objekts.
 */
export async function handleFoundAddressOnGui(
    map,
    markerClusterGroup,
    bottomSheetUI,
    addressData,
    isValidPointAddress,
    backendService,
    getAdminModeStatus,
    userLocationInstance
) {
    let lat = addressData.lat;
    let lon = addressData.lon;
    const street = addressData.street;
    const houseNo = addressData.houseNr;

    // Vorhandenen Adress-Marker entfernen
    removeAddressMarker(map);

    let foundPoiOrCluster = addressData.targetMarker || null;
    let targetClusterToSpiderfy = null; // Das Cluster, das gespidert werden soll

    if (!foundPoiOrCluster && isValidPointAddress) {
        // Logik für exakte Adresse (Hausnummer gefunden, normale Adresssuche)
        mylog(`DEBUG (gui-addr-co.js): Starte POI-Auswertung in der Nähe von (${lat}, ${lon}).`);
        
        // Hier wird der Marker über die Koordinaten/Adresse gesucht
        foundPoiOrCluster = findPoiAtCoordinates(map, markerClusterGroup, lat, lon, street, houseNo);
    } else if (foundPoiOrCluster) {
         mylog("DEBUG (gui-addr-co.js): POI-Marker wurde direkt übergeben (POI-Namenssuche).");
    }

    // ====================================================================
    // 1. POI/Cluster-Verarbeitung (entweder über Namenssuche oder Adress-Nähe gefunden)
    // ====================================================================
    if (foundPoiOrCluster) {
        
        // **Bestimme das Element für die Navigation**
        const elementToZoomTo = foundPoiOrCluster;
        
        // **Bestimme das Cluster zum Spiderfyen**
        if (elementToZoomTo instanceof L.MarkerCluster) {
            targetClusterToSpiderfy = elementToZoomTo;
            

        } else if (elementToZoomTo instanceof L.Marker) {
            // Wenn es ein einzelner Marker ist, suchen wir das übergeordnete Cluster
            targetClusterToSpiderfy = getParentCluster(markerClusterGroup, elementToZoomTo);
            
        }

        // **KORRIGIERTE REIHENFOLGE:** Zuerst zur Position navigieren und Layer/Cluster sichtbar machen.
        mylog("DEBUG (gui-addr-co.js): Führe zoomToShowLayer auf gefundenes Element aus.");
        
        // Das 'moveend'-Event der Leaflet-Map signalisiert, dass die Navigation/der Zoom abgeschlossen ist.
        const moveEndPromise = new Promise(resolve => {
            const moveEndHandler = () => {
                map.off('moveend', moveEndHandler);
                mylog("DEBUG (gui-addr-co.js): 'moveend' Event empfangen. Karte ist stabilisiert.");
                // Füge eine kleine Pufferzeit hinzu, damit Leaflet.MarkerCluster Zeit hat,
                // auf den Zoom/die Bewegung zu reagieren und die Cluster-Icons neu zu zeichnen.
                setTimeout(resolve, 50); 
            };
            map.on('moveend', moveEndHandler);
        });

        // Führt Navigation aus (zoomt und zentriert auf das gefundene Element)
        markerClusterGroup.zoomToShowLayer(elementToZoomTo); 
        
        // Warten, bis die Karte stabil ist und die ClusterGroup Zeit hatte zu reagieren.
        await moveEndPromise;

        // Führe die Kernlogik aus, die jetzt garantiert auf stabilen Cluster-Icons arbeitet.
        await processFoundPoiOrCluster(
            map,
            markerClusterGroup,
            bottomSheetUI,
            elementToZoomTo,
            targetClusterToSpiderfy,
            userLocationInstance,
            backendService,
            getAdminModeStatus
        );

    }
    // ====================================================================
    // 2. KEIN POI gefunden / Ungenaue Adresse
    // ====================================================================
    else if (isValidPointAddress) {
        // Fall: Exakte Adresse, aber kein POI in der Nähe gefunden.
        
        // Manuelle Navigation auf hohe Zoomstufe
        const fixedZoomLevel = 19;
        mylog(`WARNUNG (gui-addr-co.js): findPoiAtCoordinates hat nichts gefunden. Navigiere zu (${lat}, ${lon}) auf Z${fixedZoomLevel}.`);
        map.setView(L.latLng(lat, lon), fixedZoomLevel);
        await wait(200);

        // Simuliere ein Marker-Objekt für handleBsUpdate im isNewAddressMode
        const tempAddressMarker = L.marker([lat, lon]);
        tempAddressMarker.options.isNewAddressMode = true;
        tempAddressMarker.options.addressData = addressData;

        // Bottom Sheet für Neuanlage öffnen
        handleBsUpdate(
            tempAddressMarker, 
            bottomSheetUI,
            mapState,
            userLocationInstance,
            getAdminModeStatus,
            markerClusterGroup,
            map,
            backendService
        );
    } else {
        // Logik für ungenaue Adresse (nur Straße oder Ort gefunden)
        const fixedZoomLevel = 15;
        mylog(`DEBUG (gui-addr-co.js): Ungenaue Adresse, navigiere zu: (${lat}, ${lon}) auf Zoomstufe ${fixedZoomLevel}`);
        map.setView(L.latLng(lat, lon), fixedZoomLevel);
        await wait(200);

        // Bottom sheet schließen oder auf eine generische Adressanzeige aktualisieren
        bottomSheetUI.close();
        showToast("Die Adresse ist nicht exakt genug. Es wurde kein Marker hervorgehoben.", 'warning');
    }
}

/**
 * Initialisiert den GUI Address Coordinator.
 * Er abonniert das Adressauswahl-Event des ScAddressSheetCoordinator und 
 * implementiert die komplexe Adressvalidierung und -verarbeitung.
 *
 * @param {object} addressCoordinator - Instanz des ScAddressSheetCoordinator (der den Event-Kanal bereitstellt).
 * @param {object} dependencies - Objekt mit allen benötigten Abhängigkeiten (Map, ClusterGroup, Services, etc.).
 */
export function setupGuiAddressCoordinator(addressCoordinator, dependencies) {

    // Die Logik, die ausgeführt wird, wenn der AddressCoordinator meldet: "Adresse ausgewählt!"
    addressCoordinator.onAddressSelected(async (addressResult) => {

        mylog("DEBUG (gui-addr-co.js): Adresse vom Coordinator empfangen. Starte Validierung..." + addressResult.displayName);

        // Alias für Abhängigkeiten aus dem dependencies-Objekt
        const map = dependencies.map;
        const markers = dependencies.markerClusterGroup; // umbenannt von markers zu markerClusterGroup
        // KORRIGIERTE ZEILE: Fehlerbehebung TypeError: Cannot read properties of undefined (reading 'bottomSheetUI')
        // Stellt sicher, dass die bottomSheetUI-Instanz gefunden wird.
        const bottomSheetUI = dependencies.bottomSheetUI || dependencies.depends?.bottomSheetUI;

        // Weitere Aliase (unverändert)
        const backendService = dependencies.backendService;
        const getAdminModeStatus = dependencies.getAdminModeStatus;
        const userLocation = dependencies.userLocationInstance;

        let firstResult = null;
        let targetMarker = null; // Speichert den POI-Marker, wenn per Name gefunden

        // ====================================================================
        // 1. PRÜFUNG: WURDE EIN POI-MARKER DIREKT ÜBER DEN NAMEN AUSGEWÄHLT? (source === 'poi')
        // ====================================================================
        if (addressResult.source === 'POI' && addressResult.gid) {

            // Suche den Marker anhand der GID durch Iteration über alle Layer der Cluster Group.
            markers.eachLayer(function (layer) {
                if (targetMarker) return; // Schleife abbrechen, sobald der Marker gefunden wurde (innerhalb des Callbacks)

                if (layer instanceof L.Marker && layer.options.data) {
                    const markerGid = layer.options.data.gid;

                    // WICHTIG: Erzwungener String-Vergleich zur Vermeidung von Typen-Mismatches
                    if (String(markerGid) === String(addressResult.gid)) {
                        mylog(`INFO: Marker gefunden! GID: ${addressResult.gid}`);
                        targetMarker = layer;
                    }
                }
            });

            if (targetMarker) {
                mylog(`INFO (gui-addr-co.js): Direkte POI-Auswahl (Name/Jahr). GID: ${addressResult.gid}`);

                // Bereite addressData vor, um handleFoundAddressOnGui zu füttern
                firstResult = {
                    lat: addressResult.lat,
                    lon: addressResult.lon,
                    resultType: 'poiNameSearch',
                    street: addressResult.street || (targetMarker.options.data.street || ''),
                    houseNr: addressResult.houseNo || (targetMarker.options.data.house_no || ''),
                    gid: addressResult.gid, 
                    customSource: 'POI',
                    targetMarker: targetMarker // Marker-Instanz direkt übergeben
                };

                
                // === KORREKTUR FÜR IOS-PROBLEM: triggerMarkerClick wird nicht ausgelöst ===
                // Wir navigieren zuerst zur Position und lösen dann das native Leaflet-Klick-Event aus.
                mylog(`DEBUG (gui-addr-co.js): Führe zoomToShowLayer auf gefundenen Marker aus.`);
                
                // 1. Zur Position navigieren
                markers.zoomToShowLayer(targetMarker, () => {
                    mylog("DEBUG (gui-addr-co.js): Zoom abgeschlossen. Feuere 'click' Event auf Marker.");
                    // 2. Klick-Event robust auslösen. Dies triggert den normalen 
                    // Leaflet-Ablauf, der dann triggerMarkerClick und alle Folgeschritte ausführt.
                    targetMarker.fire('click');
                    
                    // Schließe das Bottom Sheet, das die Suche gestartet hat (optional, aber oft gewünscht)
                    // bottomSheetUI.close(); 
                });
                // ==========================================================================

                // Führe die Highlight- und BS-Update-Logik **NICHT** direkt aus,
                // da diese nun über den `targetMarker.fire('click')`-Event-Fluss
                // (ausgelöst in map-gen-mgr.js) abgewickelt wird.
                // Der Aufruf von handleFoundAddressOnGui ist hier überflüssig geworden, 
                // da die gesamte Logik jetzt über den Klick-Event-Fluss läuft.
                
                return; // WICHTIG: Beende die Funktion hier, um die Validierung zu überspringen.
            }
        }
        // Ende der POI-Namenssuche-Logik
        // ====================================================================


        // Erzeuge ein Standard Objekt, um handleFoundAddressOnGui zu füttern
        firstResult = {
            lat: addressResult.lat,
            lon: addressResult.lon,
            resultType: 'pointAddress', // Gehen wir davon aus, da präzise
            // Stellen Sie sicher, dass alle benötigten Adress-Komponenten vorhanden sind
            street: addressResult.street || '',
            houseNr: addressResult.houseNr || '',
            city: addressResult.city || 'Berlin',
            district: addressResult.district || '',
            postalCode: addressResult.postcode || '',
            // Neu: GID hinzufügen, falls vorhanden
            gid: addressResult.gid, 
            // Weitere Metadaten aus dem POI-Resultat (z.B. für Datenbank-Details)
            customSource: addressResult.source,
            originalPoiId: addressResult.poi_id,
            originalNames: addressResult.names,
            originalDisplay: addressResult.display_name
        };

        const isPreValidated = addressResult.source === 'HERE' || addressResult.source === 'POI';

        if (isPreValidated) {
            // WENN bereits HERE oder POI_DB (bereits präzise geocodet), 
            // überspringe Validierung und nutze direkt die übergebenen Koordinaten/Daten.
            mylog("DEBUG (gui-addr-co.js): Adresse ist vor-validiert (Quelle: " + addressResult.source + "). Überspringe Validierung.");

            await handleFoundAddressOnGui(
                map,
                markers,
                bottomSheetUI,
                firstResult,
                true, // Ist immer als gültiger Punkt zu behandeln
                backendService,
                getAdminModeStatus,
                userLocation,
            );
            return; // Beende die Funktion hier, um die Validierung zu überspringen.
        }

        const NoHouseNr = (addressResult.source === 'OSM' && !addressResult.houseNr);

        if (NoHouseNr) {
            // WENN Hausnr fehlt, überspringe Validierung und nutze direkt die übergebenen Koordinaten/Daten.
            mylog("DEBUG (gui-addr-co.js): Adresse ohne Hnr. Überspringe Validierung.");

            await handleFoundAddressOnGui(
                map,
                markers,
                bottomSheetUI,
                firstResult,
                false, // keine Hnr
                backendService,
                getAdminModeStatus,
                userLocation,
            );
            return; // Beende die Funktion hier, um die Validierung zu überspringen.
        }


        // --- FALL: KEINE VOR-VALIDIERTE QUELLE (MUSS VALIDIEREN) ---
        const validationUrl = `./validate_address.php?q=${encodeURIComponent(addressResult.displayName + ', Berlin')}`;
        let isValidPointAddress = false;

        try {
            const response = await fetch(validationUrl);
            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`HTTP-Fehler bei Validierung! Status: ${response.status}, Antwort: ${errorText}`);
            }
            const validationData = await response.json();
            mylog("DEBUG (gui-addr-co.js): Validierungsdaten erhalten:", validationData);

            if (validationData && validationData.length > 0) {
                firstResult = validationData[0];
                let finalLat = firstResult.lat;
                let finalLon = firstResult.lon;

                // Prüfen, ob Ergebnis präzise genug ist
                if (firstResult.precision === 'precise' || firstResult.precision === 'interpolated') {
                    isValidPointAddress = true;
                    mylog("DEBUG (gui-addr-co.js): Adresse als 'Point Address' validiert.");

                    // Füttere handleFoundAddressOnGui mit dem VOM VALIDATOR BEREINIGTEN Ergebnis
                    await handleFoundAddressOnGui(
                        map,
                        markers,
                        bottomSheetUI,
                        firstResult,
                        isValidPointAddress,
                        backendService,
                        getAdminModeStatus,
                        userLocation,
                    );
                } else if (firstResult.precision === 'city') {
                    showToast('Adresse nicht spezifisch genug (nur Stadt)', 'warning');
                    map.setView([finalLat, finalLon], 13);
                    removeAddressMarker(map);
                    bottomSheetUI.close();
                    return;
                } else if (firstResult.precision === 'street') {
                    showToast('Adresse nicht spezifisch genug (nur Straße)', 'warning');
                    map.setView([finalLat, finalLon], 16);
                    removeAddressMarker(map);
                    bottomSheetUI.close();
                    return;
                } else {
                    mylog("DEBUG (gui-addr-co.js): Adresse gefunden, aber keine 'Point Address' (Typ:", firstResult.resultType, ").");
                    // Fallback: Nur zentrieren, kein Address-Marker
                    map.setView([finalLat, finalLon], 17);
                    removeAddressMarker(map);
                    bottomSheetUI.close();
                    return;
                }
            } else {
                mylog("WARNUNG (gui-addr-co.js): Keine Ergebnisse von der Validierungs-API erhalten.");
                showToast('Adresse nicht gefunden', 'Fehler');
                bottomSheetUI.close();
                removeAddressMarker(map);
                return;
            }
        } catch (error) {
            mylog("FEHLER (gui-addr-co.js): Fehler bei der Adressvalidierung, fahre aber mit Navigation fort:", error);
            showToast('Fehler bei der Adressvalidierung. Die Karte wird trotzdem zentriert.', 'Fehler');
            // Im Fehlerfall trotzdem zentrieren
            let finalLat = addressResult.lat;
            let finalLon = addressResult.lon;
            map.setView([finalLat, finalLon], 17);
            bottomSheetUI.close();  
            removeAddressMarker(map);
        }
    });

    mylog("INFO (GuiAddrCo): GUI Address Coordinator ist initialisiert und abonniert Adress-Events.");
}