// addrs-ui.js
import { mylog } from "./sc-utilities";
import { renderAddressSheetResults } from "./addrs-render-results";
/**
 * Managt die Benutzeroberfläche für die Adresssuche (Eingabefeld, Schließen-Button, Ergebnis-Sheet).
 * Diese Klasse ist für das DOM-Management zuständig und informiert andere Module über Benutzerinteraktionen
 * mittels Callbacks. Sie führt KEINE Kartenoperationen oder AJAX-Anfragen selbst aus.
 *
 * Diese Version injiziert ihr HTML und findet ihre Elemente selbst, ähnlich wie SettingsUI.
 */
export class ScAddressSheetUI {
    /**
     * Konstruktor für addressSheetUI.
     * Injiziert automatisch HTML und CSS und initialisiert Event-Listener.
     * Erwartet keine DOM-Element-IDs mehr als Parameter.
     */
    constructor() {
        // HTML-Template für das Adress-Sheet - sc-address-result-name ist entfernt!
        this.panelHTML = `
            <div id="address-input-container" class="hidden">
                <div id="address-input-header">
                    <input type="text" id="address-search-input" placeholder="Adresse eingeben..." />
                    <button id="address-search-close-button" class="hidden">
                        <i class="fas fa-times"></i>
                    </button>
                </div>
                <div id="address-results-sheet" class="hidden">
                    <ul class="sc-address-results-list">
                        <li id="current-location-item" class="sc-address-result-item" data-type="current-location">
                            <div class="sc-address-result-icon"><i class="fas fa-location-crosshairs"></i></div>
                            <div class="sc-address-result-text">
                                <div id="current-location-display-text" class="sc-address-result-line">Standortfreigabe deaktiviert</div>
                            </div>
                        </li>
                        <li id="search-entered-address-item" class="sc-address-result-item" data-type="search-entered-address">
                            <div class="sc-address-result-icon"><i class="fas fa-search"></i></div>
                            <div class="sc-address-result-text">
                                <div class="sc-address-result-line">Zur eingegebenen Adresse (präzise)</div>
                            </div>
                        </li>
                        <p style="text-align: center; color: #888; padding: 20px;">Beginne mit der Eingabe einer Adresse...</p>
                    </ul>
                </div>
            </div>
        `;

        // CSS-Styles für das Adress-Sheet - Angepasst für eine einzelne Textzeile
        this.panelCSS = `
            /* NEUE STYLES FÜR ADRESSSUCHE */
            #address-input-container {
                position: absolute;
                top: 20px;
                left: 50%;
                transform: translateX(-50%);
                width: 50%;
                max-width: 500px;
                background-color: #fff;
                border-radius: 25px;
                box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
                z-index: 1000;
                transition: all 0.3s ease-in-out;
                overflow: hidden;
                display: flex;
                flex-direction: column;
            }

            #address-input-container.fullscreen-mode {
                top: 20;
                left: 0;
                width: 100%;
                height: 100vh;
                max-width: none;
                border-radius: 0;
                transform: translateX(0);
                background-color: white;
                z-index: 10002;
            }

            #address-input-header {
                display: flex;
                align-items: center;
                padding: 5px;
                height: 50px;
                box-sizing: border-box;
                background-color: #fff;
                z-index: 2;
                position: relative;
                width: 100%;
            }

            #address-input-header.active {
                border-bottom: 1px solid #eee;
            }

            #address-search-input {
                flex-grow: 1;
                padding: 10px 15px;
                border: none;
                border-radius: 25px;
                font-size: 1em;
                outline: none;
                box-shadow: none;
                background: transparent;
                margin: 0;
            }

            #address-search-close-button {
                background-color: #f44336;
                color: white;
                border: none;
                border-radius: 50%;
                width: 35px;
                height: 35px;
                display: flex;
                justify-content: center;
                align-items: center;
                font-size: 20px;
                cursor: pointer;
                box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
                margin-left: 10px;
            }

            #address-search-close-button:hover {
                background-color: #d32f2f;
            }

            #address-results-sheet {
                flex-grow: 1;
                background-color: white;
                overflow-y: auto;
                padding: 0;
                box-shadow: none;
                max-height: calc(100vh - 50px);
            }

            .sc-address-results-list {
                padding: 0;
                margin: 0;
                list-style: none;
            }

            /* --- WICHTIGE VERBESSERUNGEN HIER STARTEN --- */

            .sc-address-result-item {
                display: flex;
                align-items: center;
                padding: 12px 15px;
                border-top: 1px solid #eee;
                cursor: pointer;
                /* Hinzugefügt/Aktualisiert für sanftere Übergänge */
                transition: background-color 0.2s ease, opacity 0.2s ease, color 0.2s ease;
            }

            .sc-address-result-item:first-child {
                border-top: none;
            }

            .sc-address-result-item:hover:not(.disabled-location) {
                background-color: #f0f0f0;
            }

            .sc-address-result-icon {
                font-size: 1.2em;
                color: #555; /* Standard-Icon-Farbe, leicht dunkler für besseren Kontrast */
                margin-right: 10px;
                width: 25px;
                text-align: center;
            }

            .sc-address-result-text {
                flex-grow: 1;
            }

            .sc-address-result-text .sc-address-result-line {
                font-weight: normal;
                color: #333; /* Standard-Textfarbe, dunkler für besseren Kontrast */
                font-size: 1em;
            }

            /* Styles für den AKTIVEN Zustand (sowohl für Standort als auch für die neue Adresse) */
            .sc-address-result-item.enabled-location {
                background-color: #e6f7ff; /* Hellblauer Hintergrund */
            }

            .sc-address-result-item.enabled-location .sc-address-result-icon {
                color: #007bff; /* Kräftiges Blau für aktive Icons */
            }

            .sc-address-result-item.enabled-location .sc-address-result-text .sc-address-result-line {
                color: #007bff; /* Kräftiges Blau für aktiven Text */
                font-weight: bold; /* Macht den Text fetter */
            }

            /* Styles für den DEAKTIVIERTEN Zustand eines Listenelements */
            .sc-address-result-item.disabled-location {
                cursor: not-allowed;
                opacity: 0.6; /* Leichte Transparenz, um Inaktivität zu signalisieren */
            }

            .sc-address-result-item.disabled-location .sc-address-result-icon {
                color: #888; /* Graue Farbe für deaktivierte Icons */
            }

            .sc-address-result-item.disabled-location .sc-address-result-text .sc-address-result-line {
                color: #888; /* Graue Farbe für deaktivierten Text */
                font-style: italic; /* Kursivschrift für deaktivierten Text */
            }

            /* --- HIER ENDEN DIE WICHTIGEN VERBESSERUNGEN --- */


            /* Styles für den Adress-Such-Trigger - , damit die UI alle styles hier beisammen hat */
            #search-address-trigger {
                position: fixed;
                top: 20px;
                left: 50%;
                transform: translateX(-50%);
                width: 70%;
                max-width: 500px;
                height: 50px;
                background-color: #fff;
                border-radius: 25px;
                box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
                z-index: 500;
                display: flex;
                align-items: center;
                padding: 0 15px;
                cursor: pointer;
                box-sizing: border-box;
                font-size: 1em;
                color: #555;
            }
            #search-address-trigger i {
                margin-right: 10px;
                color: #888;
            }
            #search-address-trigger:hover {
                background-color: #f5f5f5;
            }
        `;

        // 1. CSS des Adress Sheets in den Head des Dokuments injizieren
        this._injectCSS();

        // 2. HTML des Adress Sheets in den Body des Dokuments injizieren
        this._injectHTML();

        // 3. Jetzt, da HTML und CSS im DOM sind, können wir die Elemente abrufen
        this.addressInputContainer = document.getElementById('address-input-container');
        this.addressSearchInput = document.getElementById('address-search-input');
        this.addressResultsSheet = document.getElementById('address-results-sheet');
        this.addressSearchCloseButton = document.getElementById('address-search-close-button');
        this.addressInputHeader = this.addressSearchInput.closest('#address-input-header');
        this.addressResultsList = this.addressResultsSheet.querySelector('.sc-address-results-list');
        this.currentLocationDisplayTextElement = document.getElementById('current-location-display-text');
        this.currentLocationItem = document.getElementById('current-location-item');
        // NEU: Element für den "Eingegebene Adresse finden" Button abrufen
        this.searchEnteredAddressItem = document.getElementById('search-entered-address-item');
        // Internes Auffinden des Trigger-Elements
        this._triggerElement = document.getElementById('search-address-trigger');

        if (!this.addressInputContainer || !this._triggerElement) {
            console.error("Fehler: Kritische Elemente für das Adress-Sheet (Container oder Trigger) nicht gefunden.");
            // Hier könnte man weitere Fehlerbehandlung oder einen throw einfügen
        }

        // Initialisierung der Callbacks
        this.searchInputCallbacks = [];
        this.addressSelectedCallbacks = [];
        this.stateChangeCallbacks = [];
        this.currentLocationSelectedCallbacks = [];
        this.openSheetCallbacks = []; // Callback für den externen Trigger
        // NEU: Callback für den "Eingegebene Adresse finden" Button
        this.searchEnteredAddressCallbacks = [];

        // Initialer Zustand des Sheets: versteckt (durch 'hidden' Klasse im HTML gesteuert)
        this._currentState = 'input-only';

        this._addEventListeners();

        // Initialisieren des "Aktuellen Standort"-Buttons beim Start
        this.updateCurrentLocationButton(false);
        // Initialisieren des "Eingegebene Adresse finden" Buttons beim Start
        this.updateSearchEnteredAddressButtonState();
    }

    /**
     * Injiziert die CSS-Styles in den <head> des Dokuments.
     * Stellt sicher, dass Styles nur einmal hinzugefügt werden.
     * @private
     */
    _injectCSS() {
        if (!document.getElementById('sc-address-sheet-styles')) {
            const style = document.createElement('style');
            style.id = 'sc-address-sheet-styles';
            style.textContent = this.panelCSS;
            document.head.appendChild(style);
        }
    }

    /**
     * Injiziert das HTML-Template in den Body des Dokuments.
     * Stellt sicher, dass das HTML nur einmal hinzugefügt wird.
     * @private
     */
    _injectHTML() {
        if (!document.getElementById('address-input-container')) {
            document.body.insertAdjacentHTML('beforeend', this.panelHTML);
        }
    }

    /**
     * Fügt Event-Listener zu den UI-Elementen hinzu.
     * @private
     */
    _addEventListeners() {
        // Listener für den externen Trigger, der das Sheet öffnet
        if (this._triggerElement) {
            this._triggerElement.addEventListener('click', () => {
                this.openSheetCallbacks.forEach(cb => cb());
                this.openResults();
            });
        }

        this.addressSearchInput.addEventListener('focus', () => {
            this.setInitialResultsContent();
            this.updateSearchEnteredAddressButtonState(); // Zustand des neuen Buttons bei Fokus aktualisieren
        });

        this.addressSearchInput.addEventListener('input', () => {
            const query = this.addressSearchInput.value.trim();
            this.searchInputCallbacks.forEach(cb => cb(query));
            this.updateSearchEnteredAddressButtonState(); // Zustand des neuen Buttons bei Eingabe aktualisieren
        });

        this.addressSearchCloseButton.addEventListener('click', () => {
            this.closeResults();
        });

        this.addressResultsList.addEventListener('click', (event) => {
            const listItem = event.target.closest('.sc-address-result-item');
            if (listItem) {
                if (listItem.dataset.type === 'current-location' && listItem.style.pointerEvents !== 'none') {
                    this.currentLocationSelectedCallbacks.forEach(cb => cb());
                    this.closeResults();
                } else if (listItem.dataset.type === 'search-entered-address' && listItem.style.pointerEvents !== 'none') {
                    // Wenn der "Eingegebene Adresse finden"-Button geklickt wird
                    const query = this.getInputValue().trim();
                    if (query.length > 5) { // Nur auslösen, wenn die Bedingung erfüllt ist
                        // Wichtig: Hier wird die query gesendet, damit der Controller die Suche ausführen kann.
                        // Fügt source: null hinzu, um Konsistenz mit regulären Adressen zu gewährleisten
                        this.addressSelectedCallbacks.forEach(cb => cb({ lat: 0, lon: 0, displayName: query, source: null }));
                        this.closeResults(); // Das Fenster nach dem Klick schließen
                    }
                } else if (listItem.dataset.type !== 'current-location' && listItem.dataset.type !== 'search-entered-address') {
                    const lat = parseFloat(listItem.dataset.lat);
                    const lon = parseFloat(listItem.dataset.lon);
                    const street  = listItem.dataset.street;
                    const houseNr = listItem.dataset.houseNr;
                    const displayName = listItem.dataset.displayName;
                    const textToDisplay = listItem.dataset.textToDisplay;
                    const source = listItem.dataset.source;

                    if (!isNaN(lat) && !isNaN(lon)) {
                        this.addressSelectedCallbacks.forEach(cb => cb({ lat, lon, street, houseNr,displayName: textToDisplay, source: source }));
                        this.closeResults();
                    }
                }
            }
        });

        // Event-Listener für Klicks außerhalb des Sheets zum Schließen
        document.addEventListener('click', (event) => {
            // Nur wenn das Sheet geöffnet ist UND der Klick NICHT innerhalb des Containers oder des Triggers war
            if (this.isOpen() &&
                !this.addressInputContainer.contains(event.target) &&
                !this._triggerElement.contains(event.target)) {
                this.closeResults();
                mylog("DEBUG: Adress Sheet geschlossen durch Klick außerhalb.");
            }
        });
    }

    /**
     * Wendet die CSS-Klassen basierend auf dem aktuellen Zustand an.
     * @private
     */
    _applyState() {
        if (this._currentState === 'input-only') {
            this.addressInputContainer.classList.add('hidden');
            this.addressResultsSheet.classList.add('hidden');
            this.addressSearchCloseButton.classList.add('hidden');

            if (this.addressInputHeader) {
                this.addressInputHeader.classList.add('initial');
                this.addressInputHeader.classList.remove('active');
            }

            this.addressInputContainer.classList.remove('fullscreen-mode');

            if (this._triggerElement) {
                this._triggerElement.classList.remove('hidden'); // Trigger wieder sichtbar
            }

        } else if (this._currentState === 'results-open') {
            this.addressInputContainer.classList.remove('hidden');
            this.addressResultsSheet.classList.remove('hidden');
            this.addressSearchCloseButton.classList.remove('hidden');

            if (this.addressInputHeader) {
                this.addressInputHeader.classList.remove('initial');
                this.addressInputHeader.classList.add('active');
            }

            this.addressInputContainer.classList.add('fullscreen-mode');
            this.addressSearchInput.focus();

            // Verstecke den Trigger, wenn das Sheet geöffnet ist
            if (this._triggerElement) {
                this._triggerElement.classList.add('hidden');
            }
        }
        this.stateChangeCallbacks.forEach(cb => cb(this._currentState));
    }

    /**
     * Öffnet das Adress-Such-Ergebnis-Sheet.
     * Wird intern oder vom externen Trigger aufgerufen.
     */
    openResults() {
        if (this._currentState !== 'results-open') {
            this._currentState = 'results-open';
            this._applyState();
            this.addressSearchInput.value = ''; // Eingabefeld leeren, wenn Sheet geöffnet wird
            this.setInitialResultsContent();
            this.updateSearchEnteredAddressButtonState(); // Zustand des neuen Buttons beim Öffnen aktualisieren
            mylog("DEBUG: Adress-Suchsheet geöffnet.");
        }
    }

    /**
     * Schließt das Adress-Such-Ergebnis-Sheet und leert die Inhalte.
     */
    closeResults() {
        if (this._currentState !== 'input-only') {
            this._currentState = 'input-only';
            this.addressSearchInput.value = '';
            this.setInitialResultsContent();
            this._applyState();
            this.updateSearchEnteredAddressButtonState(); // Zustand des neuen Buttons beim Schließen aktualisieren
            mylog("DEBUG: Adress-Suchsheet geschlossen.");
        }
    }

 

    /**
     * Setzt den initialen Inhalt der Ergebnisliste (inkl. "Aktueller Standort" und "Gib eine Adresse ein...").
     * Diese Methode wird beim Öffnen oder Leeren des Sheets aufgerufen.
     */
    setInitialResultsContent() {
        // Den letzten Child-Element (der p-Tag "Beginne mit der Eingabe...") entfernen,
        // aber die ersten beiden (current-location und search-entered-address) behalten.
        while (this.addressResultsList.children.length > 2) {
            this.addressResultsList.removeChild(this.addressResultsList.lastChild);
        }

        // Füge den "Beginne mit der Eingabe..."-Text nur hinzu, wenn das Eingabefeld leer ist und noch kein solcher Text existiert.
        const hasPlaceholderText = this.addressResultsList.querySelector('p');
        if (this.addressSearchInput.value.trim() === '' && !hasPlaceholderText) {
            const textLi = document.createElement('li');
            textLi.innerHTML = '<p style="text-align: center; color: #888; padding: 20px;">Beginne mit der Eingabe einer Adresse...</p>';
            this.addressResultsList.appendChild(textLi);
        } else if (this.addressSearchInput.value.trim() !== '' && hasPlaceholderText) {
            // Wenn Text eingegeben wird, entferne den Placeholder-Text
            hasPlaceholderText.remove();
        }
        this.updateSearchEnteredAddressButtonState(); // Zustand des neuen Buttons anpassen
    }


    /**
     * Registriert einen Callback, der aufgerufen wird, wenn der Nutzer im Suchfeld tippt.
     * @param {function(string): void} callback - Die Funktion, die den aktuellen Suchstring erhält.
     */
    onSearchInput(callback) {
        if (typeof callback === 'function') {
            this.searchInputCallbacks.push(callback);
        }
    }

    /**
     * Registriert einen Callback, der aufgerufen wird, wenn ein Suchergebnis angeklickt wird.
     * @param {function({lat: number, lon: number, displayName: string, source: string}): void} callback - Die Funktion, die die Details des ausgewählten Ortes erhält.
     */
    onAddressSelected(callback) {
        if (typeof callback === 'function') {
            this.addressSelectedCallbacks.push(callback);
        }
    }

    /**
     * Registriert einen Callback, der aufgerufen wird, wenn sich der Zustand des Sheets ändert (offen/geschlossen).
     * @param {function('input-only' | 'results-open'): void} callback - Die Funktion, die den neuen Zustand erhält.
     */
    onStateChange(callback) {
        if (typeof callback === 'function') {
            this.stateChangeCallbacks.push(callback);
        }
    }

    /**
     * Registriert einen Callback, der aufgerufen wird, wenn der "Aktueller Standort"-Eintrag angeklickt wird.
     * @param {function(): void} callback - Die Funktion, die aufgerufen wird, wenn der aktuelle Standort ausgewählt wird.
     */
    onCurrentLocationSelected(callback) {
        if (typeof callback === 'function') {
            this.currentLocationSelectedCallbacks.push(callback);
        }
    }

    /**
     * Registriert einen Callback, der aufgerufen wird, wenn der externe Trigger geklickt wird.
     * @param {function(): void} callback - Die Funktion, die aufgerufen wird, wenn der Trigger geklickt wird.
     */
    onSheetTriggered(callback) {
        if (typeof callback === 'function') {
            this.openSheetCallbacks.push(callback);
        }
    }

    /**
     * Registriert einen Callback, der aufgerufen wird, wenn der "Eingegebene Adresse finden"-Button geklickt wird.
     * @param {function(string): void} callback - Die Funktion, die den aktuellen Wert des Eingabefeldes erhält.
     */
    onSearchEnteredAddress(callback) {
        if (typeof callback === 'function') {
            this.searchEnteredAddressCallbacks.push(callback);
        }
    }

    /**
     * Gibt den aktuellen Wert des Adress-Eingabefeldes zurück.
     * @returns {string}
     */
    getInputValue() {
        return this.addressSearchInput.value;
    }

    /**
     * Prüft, ob das Ergebnis-Sheet aktuell geöffnet ist.
     * @returns {boolean}
     */
    isOpen() {
        return this._currentState === 'results-open';
    }


    /**
     * Rendert eine Liste von Adressergebnissen im Sheet.
     * @param {Array<Object>} data - Das Array von Adress-Feature-Objekten von Nominatim/HERE.
     */
    renderResults(data)
    {
    renderAddressSheetResults(this.addressResultsList, this.addressSearchInput, data);
          }
          /*
renderResults(data) {
    mylog('DEBUG (ui.js): Daten in renderResults empfangen:', data);

    const resultsContainer = this.addressResultsList;

    if (!resultsContainer) {
        console.error("FEHLER in renderResults(): Element mit der Klasse '.sc-address-results-list' wurde NICHT gefunden. Bitte HTML-Struktur prüfen!");
        return;
    }

    // Entferne alle Listenelemente außer den ersten beiden (current-location und search-entered-address)
    while (resultsContainer.children.length > 2) {
        resultsContainer.removeChild(resultsContainer.lastChild);
    }

    if (!Array.isArray(data) || data.length === 0) {
        if (this.addressSearchInput.value.trim().length > 0) {
            const noResultsLi = document.createElement('li');
            noResultsLi.innerHTML = '<p style="text-align: center; color: #888; padding: 20px;">Keine Ergebnisse gefunden.</p>';
            resultsContainer.appendChild(noResultsLi);
        }
        return;
    }

    // NEUE LOGIK: Behandlung des spezifischen HERE-Treffers
    if (data.length === 1 && (data[0].type === 'here_specific' || data[0].type === 'info')) {
        const feature = data[0];

        if (feature.type === 'info') {
            const infoLi = document.createElement('li');
            infoLi.innerHTML = feature.display_name;
            resultsContainer.appendChild(infoLi);
            return;
        }

        if (feature.type === 'here_specific') {
            mylog("DEBUG (ui.js): Spezifisches HERE-Ergebnis erkannt und direkt gerendert.");

            const li = this._createResultListItem(
                'fas fa-star', // Ein anderes Icon zur Kennzeichnung
                feature.display_name,
                {
                    lat: feature.lat,
                    lon: feature.lon,
                    displayName: feature.display_name,
                    textToDisplay: feature.display_name, // Beides gleich setzen
                    source: 'HERE' // Zusätzliche Info
                }
            );
            resultsContainer.appendChild(li);
            return; // Wichtig: Hier abbrechen, um die normale Nominatim-Logik zu überspringen!
        }
    }

    // Temporäres Array zum Speichern der verarbeiteten und eindeutigen Ergebnisse
    const uniqueAndProcessedResults = [];
    const displayedAddresses = new Set();

    // Suchbegriff anpassen, um nur den Teil vor der Hausnummer zu verwenden (für den Filter)
    let rawSearchTerm = this.addressSearchInput.value.trim();
    const houseNumberRegex = /[.\s]+\d/;
    const match = rawSearchTerm.match(houseNumberRegex);
    let searchTerm = '';

    if (match) {
        searchTerm = rawSearchTerm.substring(0, match.index).toLowerCase();
        mylog(`DEBUG (ui.js): Angepasster Suchbegriff (vor Hausnummer): "${searchTerm}"`);
    } else {
        searchTerm = rawSearchTerm.toLowerCase();
        mylog(`DEBUG (ui.js): Suchbegriff (keine Hausnummer gefunden): "${searchTerm}"`);
    }

    data.forEach(feature => {
        let roadName = (feature.street || '').toLowerCase();

        // NEUE FILTERLOGIK: Wenn Suchbegriff vorhanden ist und Straßenname ihn nicht enthält, überspringen
        if (searchTerm && feature.source !== "POI" && roadName.indexOf(searchTerm) === -1) {
            return;
        }

        const lat = parseFloat(feature.lat);
        const lon = parseFloat(feature.lon);
        let textToDisplay = '';


        const road = feature.street || '';
        const houseNumber = feature.houseNr || '';
        const district = feature.district;
        const postcode = feature.postcode || '';

        let parts = [];

        if (road) {
            let streetAndNumber = road;
            if (houseNumber) {
                streetAndNumber += ` ${houseNumber}`;
            }
            parts.push(streetAndNumber);
        } else if (houseNumber) {
            parts.push(houseNumber);
        }

        if (district) {
            parts.push(district);
        }

        if (postcode) {
            parts.push(postcode);
        }

        if (parts.length > 0) {
            textToDisplay = parts.join(', ');
        }


        if (!textToDisplay && feature.display_name) {
            textToDisplay = feature.display_name;
        } else if (!textToDisplay) {
            textToDisplay = 'Unbekannte Adresse';
        }

        // Duplikatsprüfung
        if (displayedAddresses.has(textToDisplay)) {
            return;
        }

        displayedAddresses.add(textToDisplay);

        // Das Feature zusammen mit dem finalen Anzeigetext speichern
        uniqueAndProcessedResults.push({
            lat: lat,
            lon: lon,
            displayName: feature.display_name, // Originaler Display Name beibehalten
            textToDisplay: textToDisplay,       // Unser formatierter Text
            source: feature.source || null
        });
    });

    // Sortiere die eindeutigen und verarbeiteten Ergebnisse alphabetisch nach textToDisplay
    uniqueAndProcessedResults.sort((a, b) => {
        return a.textToDisplay.localeCompare(b.textToDisplay);
    });

    // Jetzt die sortierten Ergebnisse rendern
    uniqueAndProcessedResults.forEach(item => {
        const li = this._createResultListItem(
            'fas fa-map-marker-alt',
            item.textToDisplay,
            {
                lat: item.lat,
                lon: item.lon,
                displayName: item.displayName,
                textToDisplay: item.textToDisplay,
                source: item.source
            }
        );
        resultsContainer.appendChild(li);
    });
}*/

/**
 * Aktualisiert den Text und/oder das visuelle Erscheinungsbild des "Aktueller Standort" Eintrags.
 * @param {boolean} isEnabled - True, wenn die Standortfreigabe aktiv ist, false sonst.
 */
updateCurrentLocationButton(isEnabled) {
    if (this.currentLocationDisplayTextElement && this.currentLocationItem) {
        if (isEnabled) {
            this.currentLocationDisplayTextElement.textContent = 'Zum aktuellen Standort';
            this.currentLocationItem.classList.add('enabled-location');
            this.currentLocationItem.classList.remove('disabled-location');
            this.currentLocationItem.style.opacity = '1';
            this.currentLocationItem.style.pointerEvents = 'auto';
            this.currentLocationItem.setAttribute('aria-disabled', 'false');
        } else {
            this.currentLocationDisplayTextElement.textContent = 'Standortfreigabe deaktiviert';
            this.currentLocationItem.classList.add('disabled-location');
            this.currentLocationItem.classList.remove('enabled-location');
            this.currentLocationItem.style.opacity = '0.5';
            this.currentLocationItem.style.pointerEvents = 'none';
            this.currentLocationItem.setAttribute('aria-disabled', 'true');
        }
        mylog(`Address Sheet UI: Current location button state updated to isEnabled=${isEnabled}`);
    }
}

/**
 * Aktualisiert den Zustand des "Eingegebene Adresse finden" Buttons.
 * Der Button ist nur aktiv, wenn Text im Eingabefeld vorhanden ist und länger als 5 Zeichen ist.
 */
updateSearchEnteredAddressButtonState() {
    if (this.searchEnteredAddressItem) {
        const query = this.addressSearchInput.value.trim();
        const shouldBeEnabled = this.isOpen() && query.length > 5;

        if (shouldBeEnabled) {
            this.searchEnteredAddressItem.style.opacity = '1';
            this.searchEnteredAddressItem.style.pointerEvents = 'auto';
            this.searchEnteredAddressItem.setAttribute('aria-disabled', 'false');
            this.searchEnteredAddressItem.classList.add('enabled-location');
            this.searchEnteredAddressItem.classList.remove('disabled-location');
        } else {
            this.searchEnteredAddressItem.style.opacity = '0.5';
            this.searchEnteredAddressItem.style.pointerEvents = 'none';
            this.searchEnteredAddressItem.setAttribute('aria-disabled', 'true');
            this.searchEnteredAddressItem.classList.add('disabled-location');
            this.searchEnteredAddressItem.classList.remove('enabled-location');
        }
    }
}

/**
   * Prüft, ob ein gegebenes DOM-Element (oder eines seiner Vorfahren)
   * innerhalb des Haupt-DOM-Elements dieses Address Sheets liegt.
   * @param {HTMLElement} target - Das zu prüfende DOM-Element (z.B. event.target).
   * @returns {boolean} True, wenn das Target innerhalb des Address Sheets liegt, sonst False.
   */
contains(target) {
    if (!this.addressInputContainer) {
        console.warn("addressSheetUI: Haupt-DOM-Element 'addressInputContainer' ist nicht initialisiert. 'contains'-Prüfung nicht möglich.");
        return false;
    }
    return this.addressInputContainer.contains(target);
}
}