// address-sheet-render-results.js

import { mylog } from "./sc-utilities";


export function renderAddressSheetResults(addressResultsList, addressSearchInput, data) {
    mylog('DEBUG (ui.js): Daten in renderResults empfangen:', data);

    const resultsContainer = 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 (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 = 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 = 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 || '';

        // Teile für Anzeigetext zusamnnehsetzen
        let parts = [];
        // Namens suche
        if (feature.source === "POI") {
         
            parts.push ( feature.first_name);
            parts.push ( ' '+ feature.last_name);
            parts.push ( ' '+ feature.year_of_birth);

            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(', ');
            }
        } else
         // Adresssuche
            {

            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,
            street: feature.street,
            houseNr: feature.houseNr,
            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
    // Achtung: alle relevanten Attribute müssen in addrs-ui.js extrahiert werden!! ->     this.addressResultsList.addEventListener('click', (event) => {
    uniqueAndProcessedResults.forEach(item => {
        const li = createResultListItem(
            'fas fa-map-marker-alt',
            item.textToDisplay ,
            {
                lat: item.lat,
                lon: item.lon,
                street: item.street,
                houseNr: item.houseNr,
                displayName: item.displayName,
                textToDisplay: item.textToDisplay,
                source: item.source
            }
        );
        resultsContainer.appendChild(li);
    });
}


/**
 * Erstellt und gibt ein Listenelement für ein Adressergebnis zurück.
 * @param {string} iconClass - Font Awesome Klasse für das Icon (z.B. 'fas fa-map-marker-alt').
 * @param {string} displayName - Der anzuzeigende Text.
 * @param {Object} dataset - Ein Objekt mit Datenattributen (z.B. { lat, lon, displayName }).
 * @returns {HTMLLIElement} Das erstellte Listenelement.
 * @private
 */
function createResultListItem(iconClass, displayName, dataset = {}) {
    const li = document.createElement('li');
    li.classList.add('sc-address-result-item');

    for (const key in dataset) {
        // Prüft auf null oder undefined, um Fehler bei leeren Werten zu vermeiden
        if (Object.prototype.hasOwnProperty.call(dataset, key) && dataset[key] !== null && dataset[key] !== undefined) {
            li.dataset[key] = dataset[key];
        }
    }

    li.innerHTML = `
            <div class="sc-address-result-icon"><i class="${iconClass}"></i></div>
            <div class="sc-address-result-text">
                <div class="sc-address-result-line">${displayName}</div>
            </div>
        `;
    return li;
}