// 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'; 
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 = 10;

    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;
    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;
                    }
                }
            }
        }
    });

    // NEUE LOGIK: 
    // 1. Priorität: Ein eindeutiger Match (Straße UND Hausnummer, wenn vorhanden)
    if ((hasSearchStreetName || hasSearchHouseNumber) && matchingStreetAndHouseNumberMarkers.length === 1) {
        mylog("DEBUG (findPoiAtCoordinates - Ergebnis): Eindeutiger Marker-Match über Adresse gefunden.");
        return matchingStreetAndHouseNumberMarkers[0];
    }
    // 2. Priorität: Ein eindeutiger Match nur über Koordinaten (Adresse war vmtl. unvollständig)
    if (!(hasSearchStreetName || hasSearchHouseNumber) && allMarkersInTolerance.length === 1) {
        mylog("DEBUG (findPoiAtCoordinates - Ergebnis): Eindeutiger Marker-Match über Koordinate gefunden.");
        return allMarkersInTolerance[0];
    }

    // 3. Priorität: Wenn mehrere POIs an der Adresse gefunden wurden (oder keine Adresse gesucht wurde)
    // -> Gehe zum Cluster des ersten gefundenen Markers, um die Übersichtsanzeige zu ermöglichen.
    let markerForParentCheck = null;
    if (matchingStreetAndHouseNumberMarkers.length > 0) {
        // Bei mehreren Matches: Wähle den ersten passenden Marker als Basis für das Cluster
        markerForParentCheck = matchingStreetAndHouseNumberMarkers[0];
    } else if (allMarkersInTolerance.length > 0) {
        // Bei Match nur über Koordinate (und mehreren POIs): Wähle den ersten Marker als Basis
        markerForParentCheck = allMarkersInTolerance[0];
    }

    if (!markerForParentCheck) {
        return null;
    }

    // Finde das sichtbare Eltern-Element (Cluster oder Marker, wenn schon freigelegt)
    const visibleParent = markerClusterGroup.getVisibleParent(markerForParentCheck);

    if (visibleParent) {
        if (visibleParent instanceof L.MarkerCluster) {
            mylog(`DEBUG (findPoiAtCoordinates - Ergebnis): Cluster gefunden (da mehrere Matches oder in Toleranz) mit ${visibleParent.getChildCount()} Children.`);
            return visibleParent;
        } else if (visibleParent instanceof L.Marker) {
            // Dies passiert, wenn zoomToShowLayer bereits ausgeführt wurde oder die Karte hoch genug gezoomt ist.
            mylog(`DEBUG (findPoiAtCoordinates - Ergebnis): Einzelnen Marker gefunden (trotz mehrerer Matches, da bereits freigelegt).`);
            return visibleParent;
        }
    }

    // Fallback: Sollte eigentlich nicht erreicht werden, wenn die vorherige Logik stimmt.
    return firstMarkerInTolerance;
}

/**
 * Hilfsfunktion, um das übergeordnete L.MarkerCluster-Objekt für einen Marker zu finden.
 * (Unverändert)
 */
function getParentCluster(markerClusterGroup, marker) {
    if (!marker || !(marker instanceof L.Marker)) {
        return null;
    }
    const parent = markerClusterGroup.getVisibleParent(marker);
    
    if (parent && parent instanceof L.MarkerCluster) {
        return parent;
    }
    return null;
}


/**
 * Entfernt den Adress-Marker von der Karte, falls vorhanden.
 * (Unverändert)
 */
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
) {
    if (false) {
    // 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;

        mylog(`DEBUG (gui-addr-co.js): Starte Demarkierung des ALTEN aktiven Elements: Typ=${type}, GID=${gid}, Leaflet ID=${leafletId}.`);
        
        demarcateElement(mapState.activeMarkerOrCluster, mapState);
    } else {
        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 und Interaktion starten
    
    if (targetClusterToSpiderfy) {
        // Fall: Cluster gefunden und muss gespidert werden (weil mehrere POIs an der Adresse)
        
        mylog("DEBUG (gui-addr-co.js): Rufe handleClusterClickLogic für Spiderfy/Highlight auf (Cluster-Szenario).");

        // handleClusterClickLogic führt das Spiderfy, das Highlighting des Clusters und das BS-Update durch.
        // Es setzt auch mapState.activeMarkerOrCluster auf das Cluster.
        await handleClusterClickLogic(
            targetClusterToSpiderfy, 
            markerClusterGroup, 
            map, 
            bottomSheetUI, 
            userLocationInstance, 
            backendService, 
            getAdminModeStatus, 
            mapState
        );
        
        // HINWEIS: Wenn elementToZoomTo ein Marker ist, der im Cluster liegt, 
        // wird er hier NICHT als aktiv markiert (nur das Cluster ist aktiv). 
        // Das ist korrekt, wenn wir die Übersicht des Clusters zeigen wollen.

    } else if (elementToZoomTo instanceof L.Marker) {
        // Fall: Einzelner Marker, entweder direkt gesucht oder der einzige an der Adresse
        mylog("DEBUG (gui-addr-co.js): Einzelner Marker gefunden. Wende Marker-Highlight an.");
        
        mapState.activeMarkerOrCluster = elementToZoomTo;
        mapState.activeMarkerOrClusterGID = elementToZoomTo.options.data.gid;
        // UpdateMarkerIcon übernimmt das Highlighting und die Markierung im mapState (Icon-Änderung)
        UpdateMarkerIcon(elementToZoomTo, true);
    } else if (elementToZoomTo instanceof L.MarkerCluster) {
        // Dies ist der seltene Fall, dass zoomToShowLayer abgeschlossen ist, 
        // aber handleFoundAddressOnGui dachte, es sei ein Cluster, und es wurde aus irgendeinem 
        // Grund nicht gespidert (z.B. keine Spiderfy-Optionen in ClusterGroup). 
        // Wir behandeln es wie einen Marker.
        mylog("DEBUG (gui-addr-co.js): Einzelnes Cluster gefunden, das nicht gespidert werden soll. Highlight Cluster.");
        
        mapState.activeMarkerOrCluster = elementToZoomTo;

        // Hier müssten wir ggf. eine Highlight-Funktion für das Cluster aufrufen, 
        // wenn handleClusterClickLogic nicht verwendet wird.
    }

    // Bottom Sheet für gefundenen POI/Cluster/Marker aktualisieren
    handleBsUpdate(
        elementToZoomTo,
        bottomSheetUI,
        mapState,
        userLocationInstance,
        getAdminModeStatus,
        markerClusterGroup,
        map,
        backendService
    );
}


/**
 * Behandelt die übergebene Adresse, zentriert die Karte und steuert die Anzeige von POIs/Clustern.
 */
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;
    
    // Logik zur Suche nach POI in der Nähe, falls keine direkte Instanz übergeben wurde (targetMarker ist null).
    if (!foundPoiOrCluster && isValidPointAddress) {
        mylog(`DEBUG (gui-addr-co.js): Starte POI-Auswertung in der Nähe von (${lat}, ${lon}).`);
        // Sucht Marker oder das übergeordnete Cluster, wenn mehrere POIs gefunden werden.
        foundPoiOrCluster = findPoiAtCoordinates(map, markerClusterGroup, lat, lon, street, houseNo);
    } else if (foundPoiOrCluster) {
         mylog("DEBUG (gui-addr-co.js): POI-Marker oder Cluster wurde direkt übergeben.");
    }

    // ====================================================================
    // 1. POI/Cluster-Verarbeitung (Ziel gefunden)
    // ====================================================================
    if (foundPoiOrCluster) {
        
        const elementToZoomTo = foundPoiOrCluster;
        let clusterToSpiderfy = null;
        
        // **Bestimme, ob das Ziel ein Cluster ist, das nach der Navigation gespidert werden muss.**
        if (elementToZoomTo instanceof L.MarkerCluster) {
            clusterToSpiderfy = elementToZoomTo;
            mylog("DEBUG (gui-addr-co.js): Ziel ist ein Cluster. Navigation und anschließendes Spiderfy geplant.");
        } else if (elementToZoomTo instanceof L.Marker) {
            // Wenn es ein Marker ist, ist kein Spiderfy erforderlich.
            mylog("DEBUG (gui-addr-co.js): Ziel ist ein Marker. Navigation zum Freilegen des Markers geplant.");
        }
        
        mylog("DEBUG (gui-addr-co.js): Führe zoomToShowLayer auf gefundenes Element aus.");
        
        // Verwenden Sie die Callback-Funktion von zoomToShowLayer, um die asynchrone Navigation abzuwarten.
        const zoomCompletePromise = new Promise(resolve => {
            // Dies navigiert, zentriert und ent-clustert automatisch, bis das Ziel sichtbar ist.
            markerClusterGroup.zoomToShowLayer(elementToZoomTo, () => {
                mylog("DEBUG (gui-addr-co.js): zoomToShowLayer Callback abgeschlossen. Ziel ist sichtbar.");
                
                // Kurze Pufferzeit (z.B. 100ms) für letzte Cluster-DOM-Updates
                setTimeout(resolve, 100); 
            });
        });

        // Warten, bis die Navigation abgeschlossen und der Puffer abgelaufen ist.
        await zoomCompletePromise;
        
        // Führe die Kernlogik aus, die jetzt garantiert auf dem stabilen/freigelegten Element arbeitet.
        // Der Aufruf von handleClusterClickLogic in processFoundPoiOrCluster übernimmt jetzt das Spiderfy.
        await processFoundPoiOrCluster(
            map,
            markerClusterGroup,
            bottomSheetUI,
            elementToZoomTo,
            clusterToSpiderfy, // Dies ist das Element, das das Spiderfy triggern soll (entweder MarkerCluster oder null)
            userLocationInstance,
            backendService,
            getAdminModeStatus
        );

    }
    // ====================================================================
    // 2. KEIN POI gefunden / Ungenaue Adresse
    // ====================================================================
    else if (isValidPointAddress) {
        // Fall: Exakte Adresse, aber kein POI in der Nähe gefunden.
        
        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);
        
        // Adress-Marker hinzufügen
        currentAddressMarker = L.marker([lat, lon]).addTo(map);
        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.
 */
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
        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; 

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

                    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',
                    // WICHTIG: targetMarker übergeben, damit handleFoundAddressOnGui ihn direkt verwenden kann.
                    targetMarker: targetMarker 
                };

                
                // Wenn ein TargetMarker explizit gefunden wurde, leiten wir die Steuerung
                // über den simulierten Klick an den normalen Karten-Flow weiter.
                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.
                    targetMarker.fire('click');
                });
                
                return; // Beende die Funktion hier.
            }
        }
        // Ende der POI-Namenssuche-Logik
        // ====================================================================


        // Erzeuge ein Standard Objekt, um handleFoundAddressOnGui zu füttern (für Adresssuche)
        firstResult = {
            lat: addressResult.lat,
            lon: addressResult.lon,
            resultType: 'pointAddress', 
            street: addressResult.street || '',
            houseNr: addressResult.houseNr || '',
            city: addressResult.city || 'Berlin',
            district: addressResult.district || '',
            postalCode: addressResult.postcode || '',
            gid: addressResult.gid, 
            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)
            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; 
        }

        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; 
        }


        // --- 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.");
}