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

/**
 * Wählt die Font Awesome Icon-Klasse basierend auf der Datenquelle.
 * @param {string | null} source - Die Datenquelle (z.B. 'POI', 'HERE', 'OSM').
 * @returns {string} Die CSS-Klasse für das Icon oder ein leerer String, wenn die Quelle fehlt.
 */
function getSourceIconClass(source) {
    // Gibt einen leeren String zurück, wenn die Quelle fehlt oder leer ist.
    if (!source || source.trim() === '') {
        return ''; 
    }

    const lowerSource = source.toLowerCase();

    switch (lowerSource) {
        case 'poi':
            return 'fas fa-user'; // Icon für Points of Interest / Namenssuchen
        case 'here':
            return 'fas fa-external-link-alt'; // Icon für externe HERE-Quelle
        case 'osm':
        case 'nominatim': 
            return 'fas fa-globe'; // Icon für OpenStreetMap-Daten
        default:
            return 'fas fa-map-marker-alt'; // Standard-Icon, falls Quelle unbekannt, aber vorhanden
    }
}

// ⭐ NEU: HILFSFUNKTION FÜR KANONISCHE SCHLÜSSEL (Duplikatsprüfung) ⭐
/**
 * Erzeugt einen kanonischen Schlüssel aus Adressbestandteilen zur Duplikatsprüfung.
 * @param {string} street
 * @param {string} houseNr
 * @param {string} district
 * @returns {string} Ein konsistenter, normalisierter Schlüssel (z.B. "musterstrasse5friedenau").
 */
function createCanonicalAddressKey(street, houseNr, district) {
    if (!street && !houseNr) {
        return '';
    }

    // 1. Alles in Kleinbuchstaben
    let key = `${street} ${houseNr} ${district}`.toLowerCase();
    
    // 2. Abkürzungen/Variationen vereinheitlichen
    key = key.replace(/str\./g, 'strasse');
    key = key.replace(/allee\s/g, 'allee');
    key = key.replace(/damm\s/g, 'damm');
    
    // 3. Leerzeichen und Bindestriche entfernen
    key = key.replace(/[-\s]/g, '');

    return key;
}
// ⭐ ENDE HILFSFUNKTION ⭐


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

    // ❌ ÄNDERUNG: Nur das erste Element (Current-Location) beibehalten.
    // Entferne alle Listenelemente außer dem ersten (current-location), da 'Zur eingegebenen Adresse' obsolet ist.
    while (resultsContainer.children.length > 1) {
        resultsContainer.removeChild(resultsContainer.lastChild);
    }

    // HINWEIS: Der Code zur Erstellung des 'Zur eingegebenen Adresse'-Elements wurde hier nicht mitgeliefert, 
    // muss aber ebenfalls entfernt werden, falls er vor diesem Block stand.

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

            // Icon basierend auf der festen 'HERE' Quelle auswählen
            const iconClass = getSourceIconClass('HERE');

            const li = createResultListItem(
                iconClass, 
                feature.display_name,
                {
                    lat: feature.lat,
                    lon: feature.lon,
                    displayName: feature.display_name,
                    textToDisplay: feature.display_name,
                    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(); // ALT: Veraltete Prüfung
    const displayedCanonicalKeys = new Set(); // ⭐ NEU: Kanonischer Schlüssel für Duplikatsprüfung

    // 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();

        // ❌ FILTERLOGIK AUSKOMMENTIERT, UM VERWERFEN VON ERGEBNISSEN ZU VERMEIDEN 
        // if (searchTerm && feature.source !== "POI" && roadName.indexOf(searchTerm) === -1) {
        //     return;
        // }

        // POI-Daten benötigen den Filter nicht, da sie per similarity/houseNr bereits passen
        
        const gid = parseInt(feature.gid) || '';
        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 = [];
        
        // ⭐ KORRIGIERTE LOGIK FÜR POI-GRUPPIERTE DATEN ⭐
        if (feature.source === "POI") {
            // Der display_name vom Backend ist bereits die vollständig formatierte Adresse
            // inkl. Trefferanzahl.
            textToDisplay = feature.display_name;
            
        } else {
         // Adresssuche (OSM/HERE) -> manuelle Formatierung wie bisher

            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 MIT KANONISCHEM SCHLÜSSEL ⭐
        const canonicalKey = createCanonicalAddressKey(
            feature.street, 
            feature.houseNr, 
            feature.district
        );
        
        if (canonicalKey && displayedCanonicalKeys.has(canonicalKey)) {
             return; // Duplikat überspringen
        }
        
        // Den Schlüssel zum Set hinzufügen, um zukünftige Duplikate zu verhindern.
        if (canonicalKey) {
            displayedCanonicalKeys.add(canonicalKey);
        }
        // ⭐ ENDE DUPLIKATSPRÜFUNG ⭐


        // Das Feature zusammen mit dem finalen Anzeigetext speichern
        uniqueAndProcessedResults.push({
            gid: gid,
            lat: lat,
            lon: lon,
            street: feature.street,
            houseNr: feature.houseNr,
            displayName: feature.display_name, // Originaler Display Name beibehalten
            textToDisplay: textToDisplay,       // Unser formatierter Text (oder der fertig formatierte POI-Text)
            source: feature.source || null,     // <-- NULL wird gesetzt, wenn Quelle fehlt
            // Übertrage POI-spezifische Daten zur Weiterverarbeitung
            poi_count: feature.poi_count || null, 
            aggregated_names: feature.aggregated_names || null,
        });
    });

    // ⭐ NEUE SORTIERLOGIK: Priorität der Quelle und dann alphabetisch ⭐
    uniqueAndProcessedResults.sort((a, b) => {
        // Hilfsfunktion zur Zuweisung eines Sortierwerts
        const getSortValue = (item) => {
            switch (item.source) {
                case 'POI':
                    // 1. Höchste Priorität für POI-Ergebnisse (da bereits im Backend vorsortiert)
                    return 1; 
                case 'HERE':
                    // 2. Mittlere Priorität
                    return 2; 
                case 'OSM':
                case 'Nominatim':
                    // 3. Niedrigste Priorität
                    return 3; 
                default:
                    return 99;
            }
        };

        const sortValueA = getSortValue(a);
        const sortValueB = getSortValue(b);

        // Hauptkriterium: Nach Quelle sortieren (POI -> HERE -> OSM)
        if (sortValueA !== sortValueB) {
            return sortValueA - sortValueB;
        }

        // Sekundärkriterium: Innerhalb der Quelle alphabetisch sortieren
        return a.textToDisplay.localeCompare(b.textToDisplay);
    });

    // Jetzt die sortierten Ergebnisse rendern
    uniqueAndProcessedResults.forEach(item => {
        
        // Icon basierend auf item.source auswählen
        const iconClass = getSourceIconClass(item.source); 

        const li = createResultListItem(
            iconClass, 
            item.textToDisplay ,
            {
                gid: item.gid,   
                lat: item.lat,
                lon: item.lon,
                street: item.street,
                houseNr: item.houseNr,
                // Füge POI-spezifische Daten hinzu, falls vorhanden
                poi_count: item.poi_count || null, 
                aggregated_names: item.aggregated_names || null,
                
                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'). Kann auch leer sein.
 * @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];
        }
    }

    // Setzt das Icon und den Text
    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;
}