// insert-poi-co.js
// Aufgabe von insert-poi-co ist es, die gesamte Logik für das Hinzufügen und Speichern neuer Stolpersteine zu koordinieren, 
// indem es die Benutzeroberfläche mit dem Backend-Dienst verbindet.

//todo/nice to have: es wäre sinnvoll, dass der neu angelegte poi sofort in der map narkiert und im bs angezeigt wird
//
import { ScStone } from './ScStone.js';
import { showToast } from './sc-utilities.js'; // showToast für Fehlermeldungen importieren
import { BackendService } from './backend-poi.js';
/**
 * Initialisiert die Logik zum Hinzufügen eines Stolpersteins.
 * @param {BsUI} bottomSheetUIInstance
 * @param {ScAddButtonUI} addButtonUIInstance
 * @param {function(): void} refreshMapMarkersCallback
 * @param {BackendService} backendService
 */
export function initAddStoneLogic(bottomSheetUIInstance, addButtonUIInstance, refreshMapMarkersCallback, backendService) {
    console.log("initAddStoneLogic aufgerufen. Empfangene addButtonUIInstance ist:", addButtonUIInstance);

    bottomSheetUIInstance.onAddStoneClick((coordsFromBottomSheet) => {
        console.log("onAddStoneClick im BottomSheetUI ausgelöst.");
        // **ANPASSUNG: Koordinaten werden nun obligatorisch übergeben**
        addButtonUIInstance.showPopup({}, coordsFromBottomSheet);
    });
}


/**
 * Behandelt das Speichern eines neuen Stolpersteins.
 * Diese Funktion wird als Callback für das 'onSave'-Ereignis des ScAddButtonUI verwendet.
 * @param {object} stoneData - Die vom Popup des AddButtonUI gesammelten Daten.
 * @param {string} stoneData.firstName - Der Vorname des Stolpersteins.
 * @param {string} stoneData.lastName - Der Nachname des Stolpersteins.
 * @param {number} stoneData.birthYear - Das Geburtsjahr des Stolpersteins.
 * @param {BsUI} bottomSheetUIInstance - Die Instanz des BsUI, um auf die Koordinaten zuzugreifen.
 * @param {function(): void} refreshMapMarkersCallback - Callback zum Aktualisieren der Kartenmarker.
 * @param {BackendService} backendServiceInstance - Die Instanz des BackendService.
 */
export async function handleSaveStone(stoneData, bottomSheetUIInstance, refreshMapMarkersCallback, backendService) {
    console.log("Starte Speichervorgang für Stolperstein:", stoneData);

    try {
        // 1. Koordinaten vom BottomSheetUI holen
        const coords = bottomSheetUIInstance.getCoords();
        if (!coords || typeof coords.lat !== 'number' || typeof coords.lng !== 'number') {
            console.error("Keine gültigen Koordinaten im Bottom Sheet UI gefunden. Speichervorgang abgebrochen.");
            showToast("Fehler: Keine gültige Position für den Stolperstein verfügbar. Bitte wählen Sie einen Marker aus.");
            return;
        }

        const { lat, lng } = coords;
        console.log("Koordinaten für Speicherung:", lat, lng);

        // 2. Adresse via getAddressFromLocation holen
        // Sicherstellen, dass getAddressFromLocation verfügbar ist (entweder importiert oder hier definiert)
        const addressData = await backendService.getAddressFromLocation(lat, lng);
        console.log("Empfangene Adressdaten:", addressData);

        // Korrigierte Überprüfung für addressData und seine relevanten Eigenschaften
        if (!addressData || !addressData.address || !addressData.address.street || !addressData.address.houseNumber) {
            console.error("Ungültige oder unvollständige Adressdaten von der API erhalten.", addressData);
            showToast("Fehler: Adresse konnte für die ausgewählte Position nicht ermittelt werden. Speichervorgang abgebrochen.");
            return;
        }

        // 3. SCStone Instanz erstellen und aktualisieren
        const newStoneData = {
            first_name: stoneData.firstName,
            last_name: stoneData.lastName,
            year_of_birth: stoneData.birthYear,
            stone_position: stoneData.position,
            street: addressData.address.street,
            house_no: addressData.address.houseNumber,
            localdistrict: addressData.address.district || '', // Sicherstellen, dass ein String zurückgegeben wird
            city: addressData.address.city || '',              // Sicherstellen, dass ein String zurückgegeben wird
            Lat: lat,
            Lon: lng,
            last_cleaned: "",
            caretaker: "",
        };

        const scStoneInstance = new ScStone(newStoneData, backendService);
        console.log("SCStone Instanz erstellt/aktualisiert:", scStoneInstance);

        // 4. SCStone.insert speichern
        try {
            // 2. Führen Sie den asynchronen Aufruf korrekt durch
            const result = await backendService.insertStone(scStoneInstance);

            // 3. Verarbeiten Sie die Antwort
            if (result.success) {
                console.log("Stolperstein erfolgreich eingefügt:", result);

                showToast("Erfolg", "Stolperstein erfolgreich gespeichert!", 'success');
                bottomSheetUIInstance.close(); // ✨ Hinzugefügt: Bottom Sheet schließen
                if (typeof refreshMapMarkersCallback === 'function') {
                    refreshMapMarkersCallback({
                        newGid: result.gid /*, // Kommt vom Backend
                        lat: lat,            // Kommt von bottomSheetUIInstance.getCoords()
                        lon: lng             // Kommt von bottomSheetUIInstance.getCoords()*/
                    });
                }
            } else {
                console.error("Fehler beim Einfügen des Stolpersteins:", result.error);
                showToast("Fehler", `Konnte Stolperstein nicht speichern: ${result.error}`, 'error');
            }
        } catch (error) {
            // Fangen Sie Fehler ab, die vom BackendService geworfen werden
            console.error("Ein unerwarteter Fehler ist aufgetreten:", error);
            showToast("Fehler", "Ein Netzwerkfehler ist aufgetreten.", 'error');
        }


    } catch (error) {
        console.error("Fehler im Speichervorgang des Stolpersteins:", error);
        showToast("Ein unerwarteter Fehler ist aufgetreten: " + error.message);
    }
}
/**
 * Creates the click handler for the "Edit" button.
 * @param {BsUI} bottomSheetUIInstance - The instance of the Bottom Sheet UI.
 * @param {L.Marker} marker - The currently selected marker.
 * @param {ScAddButtonUI} addButtonUIInstance - Die Instanz des ScAddButtonUI.
 * @returns {Function} The actual click handler.
 */
export function createEditClickHandler(bottomSheetUIInstance, marker, addButtonUIInstance) {
    return function () {
        console.log("DEBUG: Edit button clicked. Preparing data for the popup.");

        const stoneData = marker.options.data;

        // **WICHTIG:** Sicherstellen, dass die nötige UI-Instanz verfügbar ist
        // **ÄNDERUNG:** Zugriff über die korrekte Instanz
        if (!addButtonUIInstance) {
            console.error("Fehler: `addButtonUIInstance` ist nicht verfügbar.");
            return;
        }

        // Close the bottom sheet before the popup is opened
        bottomSheetUIInstance.close();

        // Open the popup with the data of the current stone
        addButtonUIInstance.editStone(stoneData);
    };
}