/**
 * @fileoverview Hauptmodul für die Initialisierung der Karte und das Management der POIs (Points of Interest).
 *
 * Die Hauptaufgabe dieser Datei ist die grundlegende Einrichtung der Leaflet-Karte,
 * der Marker-Cluster-Gruppe und der globalen Zustandsverwaltung (`mapState`).
 * Sie dient als zentrale Schaltstelle für das Laden der POI-Daten vom Backend und
 * die Erzeugung der entsprechenden Marker auf der Karte.
 *
 * Die Datei ist verantwortlich für:
 * 1.  **Initialisierung**: Erstellt die Karteninstanz und fügt die Karten-Layer und die Marker-Cluster-Gruppe hinzu.
 * 2.  **Datenbeschaffung**: Ruft die POI-Daten vom Backend ab.
 * 3.  **Marker-Erstellung**: Erzeugt für jeden POI einen Marker mit den korrekten Daten und dem passenden Icon.
 * 4.  **Event-Handling (POI-Klicks)**: Richtet Event-Listener für einzelne Marker-Klicks ein und delegiert
 * die nachfolgenden Aktionen (visuelle Hervorhebung, Bottom-Sheet-Aktualisierung) an andere spezialisierte Module.
 * 5.  **Zustandsverwaltung**: Verwaltet den globalen `mapState`-Zustand, um den Status der UI-Elemente
 * (wie aktive Marker, gehighlightete Cluster und den Bottom-Sheet-Inhalt) zu verfolgen.
 *
 * Im Kern ist `map-gen-mgr.js` die "Orchester-Leitung", die die Karte aufbaut und sicherstellt,
 * dass alle anderen Module (wie `map-poi-mgr.js` und `bs-gen-co.js`) zur richtigen Zeit die richtigen Aufgaben übernehmen.
 */



// **WICHTIGE ÄNDERUNG: Ersetzen Sie den alten Import**
// import { handleMarkerClick } from './map-poi-mgr.js';
// **durch den neuen zentralen Import:**
// import { handleBsUpdate } from './bs-gen-co.js';

import { getColorCodeAndText, getMarkerIcon } from './marker-display-utils.js';
import { updateMapOnMarkerClick, UpdateMarkerIcon } from './map-poi-mgr.js'
// import { InsertPoiUI } from './insert-poi-ui.js';
// import { UpdatePoiUI } from './update-poi-details-ui.js';
import { mylog, is_development, updateSpinner, forceRedraw, wait, showToast } from './sc-utilities.js';
import { updateBsForPoi } from './bs-poi-co.js';
import { setClusterMarkerIndex } from './bs-cluster-co.js';
import { restoreClusterOriginalStyles } from './map-cluster-mgr.js';
import { removeAddressMarker } from './gui-address-co.js';
import { fetchCoordForAddress } from './validate_address.js'; // ⬅️ Geocoding-Funktion

// mapState muss im Modul global sein, damit alle Funktionen darauf zugreifen können.
export const mapState = {
    currentlySpiderfiedCluster: null, // Hält das cluster das akteuell gespiderfied cluster, sonst null  
    activeMarkerOrCluster: null, // Hält den aktuell aktiven Marker oder Cluster (highlighted)
    activeMarkerOrClusterGID: null,// hält die GID des aktuell aktiven Markers, muss bei markiertem cluster null sein
    // der wert ist redundant zu marker.options.data.gid und hilft inkonistenzen/fehler aufgrund race condition zu erkennen
    originalActiveMarkerSize: [24, 24],
};


/**
 * Initialisiert die Leaflet-Karte und die Marker-Cluster-Gruppe.
 * @returns {{map: L.Map, markers: L.MarkerClusterGroup}} Die initialisierte Karte und Marker-Cluster-Gruppe.
 */
export function initMap() {
    const map = L.map("map").setView([52.469, 13.4249], 10);

    L.tileLayer('https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png', {
        attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors &copy; <a href="https://carto.com/attributions">CARTO</a>',
        subdomains: 'abcd',
        maxZoom: 20
    }).addTo(map);

    let markers = L.markerClusterGroup({
        maxZoom: 19,
        zoomToBoundsOnClick: false,
        spiderfyOnClick: false,
        spiderfyOnMaxZoom: false,
        maxClusterRadius: function (zoom) {
            if (zoom < 19) {
                return 60;
            } else {
                return 10;
            }
        },
        spiderfyCompareFn: (a, b) => { // diese option dient dazu eine stabile reihenfolge der marer im cluster zu haben
            // Hier greifen wir auf die Marker-Optionen zu und vergleichen die GID.
            // Die Funktion sollte 0, -1 oder 1 zurückgeben, wie eine Standard-JS-Sortierfunktion.
            const gidA = a.options.data.gid;
            const gidB = b.options.data.gid;

            if (gidA < gidB) {
                return -1;
            }
            if (gidA > gidB) {
                return 1;
            }
            return 0; // GIDs sind gleich (sollte nicht passieren)
        },
        spiderfyDistanceMultiplier: 3,
        iconCreateFunction: function (cluster) {
            const markersCount = cluster.getChildCount();
            let colorCount = {
                green: 0,
                yellow: 0,
                orange: 0,
                red: 0,
                gray: 0,
            };

            cluster.getAllChildMarkers().forEach((marker) => {
                const color = getColorCodeAndText(
                    marker.options.data.last_cleaned
                ).colorCode;
                colorCount[color]++;
            });

            let dominantColor = "gray";
            let maxCount = 0;
            for (const color in colorCount) {
                if (colorCount[color] > maxCount) {
                    maxCount = colorCount[color];
                    dominantColor = color;
                }
            }

            const clusterHtml = `
                    <div class="marker-cluster-style ${dominantColor}-cluster">
                        ${markersCount}
                    </div>
                    `;

            return new L.DivIcon({
                html: clusterHtml,
                className: "leaflet-marker-cluster",
                iconSize: new L.Point(40, 39),
            });
        },
    });

    map.addLayer(markers);
    console.log("Map and MarkerClusterGroup initialized.");

    return { map, markers };
}


/**
 * Ruft POI-Daten vom Server ab, fügt sie als Marker zur Karte hinzu und zeigt sie an.
 * @param {L.Map} map Die Leaflet-Karteninstanz.
 * @param {L.MarkerClusterGroup} markers Die Leaflet MarkerClusterGroup Instanz.
 * @param {Object} userLocationInstance - Die Instanz der Benutzerstandortverwaltung.
 * @param {Object} bottomSheetUI - Die Instanz des Bottom Sheet UI.
 * @param {Object} backendService - Die Instanz des Backend Service.
 * @param {function(): boolean} getAdminModeStatus - Funktion zum Abfragen des Admin-Modus-Status.
 */

// HINWEIS: Die 'wait' Funktion muss weiterhin im Scope verfügbar sein.

/**
 * Ruft POI-Daten vom Server ab, fügt sie als Marker zur Karte hinzu und zeigt sie an.
 * @param {L.Map} map Die Leaflet-Karteninstanz.
 * @param {L.MarkerClusterGroup} markers Die Leaflet MarkerClusterGroup Instanz.
 * @param {Object} userLocationInstance - Die Instanz der Benutzerstandortverwaltung.
 * @param {Object} bottomSheetUI - Die Instanz des Bottom Sheet UI.
 * @param {Object} backendService - Die Instanz des Backend Service.
 * @param {function(): boolean} getAdminModeStatus - Funktion zum Abfragen des Admin-Modus-Status.
 */
export async function fetchPOIs(
    map,
    markers,
    userLocationInstance,
    bottomSheetUI,
    backendService,
    getAdminModeStatus,
    insertPoiUI,
    updatePoiUI,
    loadingUpdateCallback = () => { }) {



    // Initiales Aufräumen und Spinner starten
    if (markers && markers.clearLayers) {
        markers.clearLayers();
        console.log("Alle vorhandenen Marker von der Karte entfernt, bevor neue geladen werden.");
    } else {
        console.warn("Marker-Gruppe ist nicht korrekt initialisiert oder hat keine clearLayers-Methode.");
    }

    // --- CHUNK-ABRUF-LOGIK ---
    const CHUNK_SIZE = 20000;
    let currentStartId = 0;
    let totalMarkersLoaded = 0;

    // 🛑 NEUE TEMPORÄRE ZÄHLVARIABLEN 🛑
    let geoCodingCounter = 0; // Zählt die Geocoding-Aufrufe
    const MAX_GEOCODING_UPDATES = 11000; // Maximale Anzahl an Updates

    try {
        while (true) {
            loadingUpdateCallback(`${currentStartId} Stolpersteine`);

            // 1. Asynchroner Aufruf des Backend-Service für den aktuellen Chunk
            const dataChunk = await backendService.fetchPOIs(currentStartId, currentStartId + CHUNK_SIZE);

            if (!Array.isArray(dataChunk) || dataChunk.length === 0) {
                // Schleife beenden, wenn keine Daten mehr vom Server kommen
                break;
            }

            const poiMarkers = [];

            // 2. Verarbeitung des kleinen Daten-Chunks
            for (const feature of dataChunk) {

                const props = feature.properties;
                let coords = null;
                //  mylog (props.gid);
                // isZeroZero Logik entfernt

                // 1. Koordinaten S I C H E R abrufen
                if (feature && feature.geometry && feature.geometry.coordinates) {
                    coords = feature.geometry.coordinates;
                }

                // 🛑 GEZIELTE GEOCoding-PRÜFUNG 🛑
                // Wir geocodieren NUR, wenn die GID in unserer temporären Liste ist.

                const isGeocodingCandidate = false; //GIDS_TO_GEOCODE.has(props.gid);




                if (isGeocodingCandidate) {
                    // --- Hier wird die Geocoding-Routine gestartet ---

                    /**
                     * NEUE STRUKTUR: Adresse als Objekt übergeben
                     * @type {{street: string, house_no: string, localdistrict: string}}
                     */
                    const fullAddress = {
                        street: props.street,
                        house_no: props.house_no,
                        localdistrict: props.localdistrict,
                    };

                    // WARTEZEIT AUF 600MS KORRIGIERT 
                    if (geoCodingCounter > 0) {
                        mylog(`[GEOCODING] GID ${props.gid}: Warte 600ms, um Rate Limiting zu vermeiden...`);
                        await wait(200);
                    }

                    // Asynchrone Geocoding-Prüfung starten
                    // HINWEIS: fetchCoordForAddress erwartet nun das Adressobjekt
                    fetchCoordForAddress(fullAddress)
                        .then(async (newCoords) => {
                            if (newCoords) {
                                // 🔥 KRITISCHER FIX: try...catch fängt Fehler von Promise B (DB-Update) ab
                                try {
                                    // DB-Update über den BackendService starten
                                    const updateResult = await backendService.updateStoneGeoLocation(
                                        props.gid,
                                        newCoords.lat,
                                        newCoords.lon
                                    );

                                    if (updateResult.success) {
                                        // Frontend-Daten sofort aktualisieren, um das Ergebnis zu sehen
                                        props.geolocation_lat = newCoords.lat;
                                        props.geolocation_lon = newCoords.lon;
                                        mylog(`[GEO UPDATE] GID ${props.gid}: Aktualisiert mit präzisen Daten.`);
                                    } else {
                                        // Falls das Backend zwar antwortet, aber 'success: false' liefert
                                        console.warn(`[DB UPDATE FAIL] GID ${props.gid}: Update meldet Misserfolg.`, updateResult);
                                    }
                                } catch (updateError) {
                                    // Fängt Fehler von updateStoneGeoLocation (Promise B) ab und lässt die Schleife weiterlaufen
                                    console.error(`[DB UPDATE ERROR] GID ${props.gid}: Fehler bei updateStoneGeoLocation.`, updateError);
                                }
                            }
                        })
                        .catch(error => {
                            // Fängt Fehler von fetchCoordForAddress (Promise A) ab
                            console.error(`[LOOP GEOCODING ERROR] GID ${props.gid}:`, error);
                        });

                    geoCodingCounter++; // Zähler erhöhen
                }

                // 🛑 MARKER-ERSTELLUNG 🛑
                // Marker nur erstellen, wenn KOORDINATEN vorliegen (VEREINFACHTER CHECK)
                if (coords) {

                    let colorCode = "gray";
                    if (props.last_cleaned) {
                        colorCode = getColorCodeAndText(props.last_cleaned).colorCode;
                    }

                    const iconHtml = getMarkerIcon(props.caretaker, colorCode);

                    const enhancedProps = {
                        ...props,
                        localdistrict: props.localdistrict || null, // Fügt das lokale Attribut hinzu
                        original_lat: coords[1],
                        original_lon: coords[0]
                    };

                    const marker = L.marker([coords[1], coords[0]], {
                        icon: L.divIcon({
                            className: "poi-icon " + colorCode,
                            html: iconHtml,
                            iconSize: mapState.originalActiveMarkerSize,
                        }),
                        data: enhancedProps,
                    });

                    poiMarkers.push(marker);

                    // Klick-Listener für jeden Marker
                    marker.on('click', function (event) {
                        L.DomEvent.stopPropagation(event);
                        const parentCluster = this.__parent || null;

                        triggerMarkerClick(
                            this,
                            {
                                bottomSheetUI, markers, map, backendService,
                                getAdminModeStatus, userLocation: userLocationInstance,
                                mapState, insertPoiUI, updatePoiUI
                            },
                            parentCluster
                        );
                    });
                }
            }

            // 3. Marker des Chunks zum Cluster HINZUFÜGEN
            markers.addLayers(poiMarkers);

            totalMarkersLoaded += dataChunk.length;

            // 4. Nächste ID vorbereiten und Thread kurz freigeben, um die UI-Aktualisierung zu garantieren
            currentStartId += CHUNK_SIZE;
            // await wait(200);
        }

        // ------------------------------------------------------------------
        // ✅ MarkerClusterGroup zur Karte hinzufügen, NUR WENN Ladevorgang abgeschlossen
        // ------------------------------------------------------------------
        if (totalMarkersLoaded > 0) {
            map.addLayer(markers); // Fügt die MarkerClusterGroup zur Karte hinzu
        }

        mylog('Marker-Laden abgeschlossen. Cluster-Gruppe ist vollständig und sichtbar.');

    } catch (error) {
        // Fehler wird hier abgefangen
        console.error("Fehler beim Abrufen der POIs:", error.message);
    } finally {
        await wait(500);

        // ✅ Das Hintergrundbild ausblenden, da alles fertig geladen ist
        const background = document.getElementById('background-image-container');
        if (background) {
            background.classList.add('fade-out');
            mylog("Hintergrundbild ausgeblendet. Karte ist jetzt sichtbar.");
        }
    }
}

/*
 * Simuliert einen Klick auf einen Marker, indem die zugehörige Logik ausgelöst wird.
 * @param {L.Marker} marker - Der Marker.
 * @param {Object} bottomSheetUI - Die Instanz des Bottom Sheet UI.
 * @param {Object} mapState - Der globale Zustand der Karte.
 * @param {Object} userLocationInstance - Die Instanz der Benutzerstandortverwaltung.
 * @param {function(): boolean} getAdminModeStatus - Funktion zum Abfragen des Admin-Modus-Status.
 * @param {L.MarkerClusterGroup} markers - Die Marker-Cluster-Gruppe.
 * @param {L.Map} map - Die Leaflet-Karteninstanz.
 * @param {Object} backendService - Die Instanz des Backend Service.
 * @param {Object} insertPoiUI - Die Instanz des Insert POI UI.
 * @param {Object} updatePoiUI - Die Instanz des Update POI UI.
 * @param {Object} cluster - Die (optionale!) Instanz des Clusters zu dem der marker gehört .
 * */

export function triggerMarkerClick(marker, allParams, cluster = null) {
    console.log("DEBUG: triggerMarkerClick: Logik für Bottom Sheet und Karte wird ausgelöst.");
    removeAddressMarker(allParams.map);
    console.trace('triggerMarkerClick wurde aufgerufen von mit GID:', marker.options.data.gid);
    // Dekonstruieren Sie das allParams-Objekt, um die Komponenten zu erhalten
    const {
        bottomSheetUI, markers, map, backendService,
        getAdminModeStatus, userLocation, mapState,
        insertPoiUI, updatePoiUI
    } = allParams;

    // 🔥 FIX: Den Parent-Cluster in den stabilen Zustand speichern.
    // 'cluster' wird hier von der Cluster-Bibliothek als der Parent übergeben.
    mapState.parentClusterOfActiveMarker = cluster;

    console.log(`DEBUG triggerMarkerClick: mapState.parentClusterOfActiveMarker gesetzt mit ID: ${cluster ? cluster._leaflet_id : 'NULL'}`);


    // Der Aufruf bleibt unverändert, da die Variablen nun lokal existieren
    updateMapOnMarkerClick(marker, map, mapState);

    // Die Logik zur Unterscheidung bleibt bestehen
    if (cluster) {
        // Zuerst den Index in der Cluster-Liste setzen
        setClusterMarkerIndex(marker, cluster);
    }
    // Dann das Bottom Sheet mit den Daten des EINEN Markers aktualisieren
    updateBsForPoi(
        marker,
        bottomSheetUI,
        backendService,
        mapState,
        userLocation,
        getAdminModeStatus,
        markers,
        map,
        insertPoiUI,
        updatePoiUI
    );

}

/**
 * Prüft, ob die Karte auf ein Element zentriert werden soll,
 * basierend darauf, ob es sich in der unteren Hälfte der Karte befindet.
 * Achtung: das ist etwas anderes als centerMapOnBottomSheetContent, denn
 * der User soll auf der Karte herumklicken können, ohne das diese sich dauernd vershiebt!
 * @param {L.Map} map Die Leaflet-Karteninstanz.
 * @param {L.LatLng} latLng Die geografischen Koordinaten des Elements.
 * @returns {boolean} True, wenn die Karte verschoben werden soll, false sonst.
 */
export function shouldPanToElement(map, latLng) {
    const mapPx = map.latLngToContainerPoint(latLng);
    const mapHeight = map.getSize().y;

    const thresholdY = mapHeight * 0.65;

    if (mapPx.y > thresholdY) {
        return true;
    } else {
        return false;
    }
}





/**
 * Hängt alle Klick- und Gesten-Listener an die Hauptkarte an.
 * @param {L.Map} map Die Leaflet-Karteninstanz.
 * @param {Object} userLocation Die Instanz für den Benutzerstandort.
 * @param {Object} bottomSheetUI Die Instanz des Bottom Sheet UI.
 * @param {function(): boolean} getAdminModeStatus Funktion zum Abfragen des Admin-Modus-Status.
 */
export function setupMapEventListeners(map, userLocation, bottomSheetUI, backendService, getAdminModeStatus,
    insertPoiUI, // <-- NEU: insertPoiUI als Argument
    updatePoiUI // <-- NEU: updatePoiUI als Argument
) {
    // Listener für Doppelklick


    // Listener für einfachen Klick auf die leere Karte zum Schließen des BS
    map.on('click', function (e) {
        if (e.originalEvent && e.originalEvent.cancelBubble) {
            return;
        }
        removeAddressMarker(map);
        console.log("DEBUG: Klick auf leere Karte erkannt. Schließe Bottom Sheet.");
        if (bottomSheetUI.isOpen()) {
            bottomSheetUI.close();
        }
    });
}

/**
 * Zentriert die Karte auf die Koordinaten des aktuell aktiven Elements im Bottom Sheet.
 * @param {L.Map} map - Die Leaflet-Karteninstanz.
 * @param {object} bottomSheetUI - Die Instanz des Bottom Sheets, um die Koordinaten zu erhalten.
 */
export function centerMapOnBottomSheetContent(map, bottomSheetUI, zoom) {
    const coords = bottomSheetUI.getDisplayCoords();
    /*if (coords && coords.lat !== null && coords.lng !== null) {
        console.log(`Zentriere Karte auf Bottom Sheet Inhalt: (${coords.lat}, ${coords.lng})`);
        map.setView(L.latLng(coords.lat, coords.lng), 19);
    } else {
        console.warn("Keine gültigen Koordinaten im Bottom Sheet verfügbar, kann nicht zentrieren.");
    }
    */
    if (coords && coords.lat !== null && coords.lng !== null) {
        // 1. Koordinaten in Pixel auf dem Bildschirm umwandeln
        const pointPixel = map.latLngToContainerPoint([coords.lat, coords.lng]);

        // 2. Den vertikalen Versatz berechnen (Höhe des Bottom Sheets)
        const sheetHeight = bottomSheetUI.bottomSheet.offsetHeight;
        const yOffset = sheetHeight / 2; // Negativer Wert verschiebt nach oben

        // 3. Den neuen Pixel-Punkt berechnen, auf den das Objekt zentriert werden soll
        const newPixelPoint = new L.Point(pointPixel.x, pointPixel.y + yOffset);

        // 4. Den neuen Pixel-Punkt zurück in geografische Koordinaten umwandeln
        const newCenterLatLng = map.containerPointToLatLng(newPixelPoint);

        // 5. Die Karte auf diese neu berechneten Koordinaten zentrieren
        map.setView(newCenterLatLng, zoom || map.getZoom());
        /*
                const displayedObject = bottomSheetUI._displayedObject;
                if (displayedObject && displayedObject.getAllChildMarkers) {
                    displayedObject.spiderfy();
                }
                */

        console.log("Karte auf Bottom Sheet Inhalt zentriert, mit Offset über setView.");
    } else {
        console.warn("Keine gültigen Koordinaten im Bottom Sheet verfügbar. Kann nicht zentrieren.");
    }
}

/**
 * Entfernt die Hervorhebung (Demarkierung) vom aktiven Marker (POI oder Cluster) und stellt das Icon wieder her.
 * @param {L.Marker|L.MarkerCluster} element - Das zuvor aktive Element.
 * @param {object} mapState - Der globale Karten-Zustand.
 */
export function demarcateElement(element, mapState) {
    const isMarker = element.options && element.options.data;

    if (isMarker) {
        // Logik zur Wiederherstellung des ursprünglichen Marker-Icons
        UpdateMarkerIcon(element, false, mapState);
        console.log("DEBUG Demarcate: Marker demarkiert.");
    } else if (element._icon) {
        // Logik zur Wiederherstellung des ursprünglichen Cluster-Styles
        restoreClusterOriginalStyles(element._icon, element);
        console.log("DEBUG Demarcate: Cluster-Stil zurückgesetzt.");
    }
}


/**
 * Richtet alle Listener vom AddressCoordinator ein, die direkt die Karte oder den
 * Karten-bezogenen Zustand (wie userLocation) betreffen.
 * Diese Funktion ersetzt die Listener-Definitionen in index.html.
 *
 * @param {L.Map} map Die Leaflet-Karteninstanz.
 * @param {Object} addressCoordinator Die Instanz des AddressCoordinator.
 * @param {Object} userLocation Die Instanz der Benutzerstandortverwaltung.
 * @param {Object} bottomSheetUI Die Instanz des Bottom Sheet UI.
 * @param {Object} addressSheetUI Die Instanz des Address Sheet UI (für Button-Updates).
 */
export function setupAddressCoordinatorListeners(map, addressCoordinator, userLocation, bottomSheetUI) {

    const addressSheetUI =addressCoordinator.addressSheetUI;

    // 1. Listener: 'Aktueller Standort' wurde gewählt (Zentrierung auf der Karte)
    addressCoordinator.onCurrentLocationSelected(() => {
        mylog("DEBUG ( map-gen-mgr.js): 'Aktueller Standort' vom Coordinator empfangen, zentriere auf User.");
        removeAddressMarker(map);
        if (userLocation) {
            userLocation.centerMapOnUser();
        } else {
            showToast('Standortdienst nicht verfügbar.', 'Warnung');
        }
        bottomSheetUI.close();
    });

    // 2. Listener: Zustand des Address Sheets hat sich geändert (Karten-Größe invalidieren)
    addressCoordinator.onSheetStateChange((newState) => {
        mylog(`DEBUG ( map-gen-mgr.js): Adress-Sheet Zustand geändert zu: ${newState}. Invalidiere Kartengröße.`);
        // map.invalidateSize() muss aufgerufen werden, wenn sich die Kartengröße im Viewport ändert
        // (z.B. durch Öffnen/Schließen von UI-Elementen, die die Karte verdecken).
        map.invalidateSize();
    });

    // 3. Listener: Address Sheet wurde geöffnet (Aktualisierung des Standort-Buttons abh. von der Freigabe)
    addressCoordinator.onSheetOpened(() => {
        mylog("DEBUG ( map-gen-mgr.js): Adress-Sheet wurde über Trigger geöffnet. Aktualisiere Standort-Button UI.");
        // Die Logik, ob der Button aktiv sein soll, hängt vom UserLocation-Dienst ab.
        const isEnabled = userLocation && userLocation.isTrackingActive();
        addressSheetUI.updateCurrentLocationButton(isEnabled);
    });
}

