// geo-backend-services.js
/**
    * Ruft die Adress-Suchergebnisse über den Nominatim-Proxy ab.
    * @param {string} query Die zu suchende Adresse.
    * @returns {Promise<Array<Object>>}
    */
export async function fetchAdressesFromNominatim(query) {
    // Hängen Sie ", Berlin" an, um die Ergebnisse zu verbessern und zu begrenzen
    const proxyUrl = `./get_addresses_nominatim.php?q=${encodeURIComponent(query + ", Berlin")}`;

    try {
        const response = await fetch(proxyUrl);
        if (!response.ok) {
            let errorMessage = `HTTP-Fehler! Status: ${response.status}`;
            try {
                const errorData = await response.json();
                if (errorData && errorData.error) {
                    errorMessage += `, Details: ${errorData.error}`;
                }
            } catch (e) {
                console.warn("Konnte Fehlerdetails vom Nominatim-Proxy nicht als JSON parsen.", e);
            }
            throw new Error(errorMessage);
        }

        const data = await response.json();

        if (!Array.isArray(data)) {
            console.error("Nominatim-Proxy lieferte unerwartetes Datenformat.", data);
            return [];
        }

        return data;

    } catch (error) {
        console.error("Fehler bei der Adresssuche über Nominatim Proxy:", error);
        // Statt einen Error zu werfen, wird er im Haupt-Handler abgefangen.
        throw new Error("Nominatim-Suche fehlgeschlagen.");
    }
}

/**
 * Ruft die Geokodierungsdaten über den PHP-Proxy (der die HERE API kontaktiert) ab.
 * @param {string} query Die zu suchende Adresse (z.B. "Hauptstraße 5, Berlin").
 * @returns {Promise<Array<Object>>}
 */
export async function fetchAdressesFromHere(query) {
    const proxyUrl = `./get_addresses_here.php?q=${encodeURIComponent(query)}`;

    console.log(`Starte HERE Proxy-Aufruf für: ${query} an URL: ${proxyUrl}`);

    try {
        const response = await fetch(proxyUrl);

        if (!response.ok) {
            console.error(`HTTP-Fehler ${response.status}: ${response.statusText}`);
            throw new Error(`Proxy-Fehler: HTTP ${response.status}`);
        }

        const data = await response.json();

        if (!Array.isArray(data)) {
            console.error("HERE Proxy lieferte unerwartetes Datenformat (kein Array).", data);
            return [];
        }

        return data;

    } catch (error) {
        console.error("Fehler beim Abrufen der HERE Adressen:", error);
        throw new Error("HERE-Suche fehlgeschlagen.");
    }
}


export async function validateAddress(displayName) {
    try {
        const response = await fetch(`./validate_address.php?q=${encodeURIComponent(displayName + ', Berlin')}`);
        const validationData = await response.json();

        // Wir geben das erste Ergebnis zurück oder null
        return (validationData && validationData.length > 0) ? validationData[0] : null;
    } catch (e) {
        console.error("BackendService: Fehler bei Adressvalidierung", e);
        return null;
    }
}

export  async function getAddressByLocationHERE(lat, lng) {
    try {
        const response = await fetch(`get_address_by_location_here.php?lat=${lat}&lng=${lng}`);
        const data = await response.json();
        return data.items ? data.items[0] : null;
    } catch (e) { return null; }
}
/**
 * Hilfsfunktion für HTTP-Aufrufe mit Exponential Backoff.
 * Reiner Daten-Fetcher ohne UI-Abhängigkeiten.
 */
async function fetchWithRetry(url, retries = 3, delay = 500) {
    for (let attempt = 0; attempt <= retries; attempt++) {
        try {
            const response = await fetch(url);
            
            if (!response.ok) {
                if (response.status === 404) throw new Error("404: Adresse nicht gefunden.");
                throw new Error(`HTTP Fehler: ${response.status}`);
            }

            return await response.json();
        } catch (error) {
            const isLastAttempt = attempt >= retries;
            const is404 = error.message.includes("404");

            if (is404 || isLastAttempt) {
                throw error;
            }

            const currentDelay = delay * Math.pow(2, attempt);
            await new Promise(resolve => setTimeout(resolve, currentDelay));
        }
    }
}

/**
 * Validiert die Adresse über das PHP-Backend.
 * @param {{street: string, houseNr: string, localdistrict: string}} fullAddressObject 
 * @returns {Promise<{lat: number, lng: number, source: string, precision: string}>}
 */
export async function fetchLocationFromAddressNominatim(fullAddressObject) {
    const params = new URLSearchParams({
        street: fullAddressObject.street || '',
        house_no: fullAddressObject.houseNr || '',
        local_district: fullAddressObject.localdistrict || '',
        city: 'Berlin',
        country: 'Deutschland',
        source: 'HERE'
    });

    const url = `https://www.app.stolperclean.de/webapp/DEVELOPMENT/validate_address_details.php?${params.toString()}`;

    // Wir werfen die Fehler einfach weiter ("rethrow"), damit das UI reagieren kann
    const response = await fetchWithRetry(url);

    if (response.status === 'success' && response.data) {
        return {
            lat: response.data.latitude,
            lng: response.data.longitude,
            source: response.source,
            precision: response.precision_level
        };
    } 
    
    if (response.status === 'error') {
        // Wir werfen einen Error mit der Nachricht vom PHP-Server
        throw new Error(response.message || "Validierung fehlgeschlagen");
    }

    throw new Error("Unerwartetes Antwortformat vom Server");
}