// update-poi-details-co.js
import { showToast, getCurrentUser, mylog } from './utilities.js';
import { updateBsForPoi } from './bs-poi-co.js';
import { UpdateMarkerIcon } from './map-poi-mgr.js';
import { updateSinglePoiInStore, getPoiData } from './poi-store.js';
import { UpdatePoiDetailsUI } from './update-poi-details-ui.js';
import { Poi } from './poi.js';
/* Behandelt das Speichern eines aktualisierten Stolpersteins. */

export async function handleUpdateStoneDetails(stoneData, backendService) {
    mylog("Starte Aktualisierung für Stolperstein mit GID:", stoneData.gid);

    if (!stoneData.gid) {
        showToast("Fehler: Konnte den Stolperstein nicht identifizieren.");
        return { success: false };
    }

    try {
        // 1. Das vollständige Original-Objekt aus dem Store holen
        const existingStone = getPoiData(stoneData.gid);
        
        if (!existingStone) {
            showToast("Fehler", "Stolperstein nicht im lokalen Speicher gefunden.", "error");
            return { success: false };
        }

        // 2. Formular-Änderungen auf die Instanz übertragen
        if (typeof existingStone.set === 'function') {
            Object.keys(stoneData).forEach((key) => {
                if (key !== "gid") {
                    existingStone.set(key, stoneData[key]);
                }
            });
        }

        // 3. Die Instanz direkt und ohne Umwege an das Backend übergeben
        // (Der Server weiß über die PHP-Session bereits von selbst, wer der User ist)
        const result = await backendService.updateStoneDetails(existingStone);

        if (result && result.success) {
            // Lokalen Store aktualisieren (die Instanz hat bereits die neuen Werte)
            updateSinglePoiInStore(existingStone);
            return { success: true, gid: stoneData.gid };
        } else {
            showToast("Fehler", `Konnte Stolperstein nicht aktualisieren: ${result ? result.error : 'Unbekannter Fehler'}`, 'error');
            return { success: false };
        }
    } catch (error) {
        console.error("Fehler in handleUpdateStoneDetails:", error);
        showToast("Fehler", "Ein Netzwerkfehler ist aufgetreten.", 'error');
        return { success: false, error };
    }
}

/**
 * Erstellt den Klick-Handler für den "Bearbeiten"-Button.
 */
export function createUpdateClickHandler(
    bottomSheetUIInstance,
    marker,
    backendServiceInstance,
    mapState,
    addButtonUIInstance,
    updatePoiUIInstance
) {
    
    const onSaveCallback = async (stoneData) => {
    const activeMarker = mapState.activeMarkerOrCluster;

    // 1. UI schließen
    let updateUI = updatePoiUIInstance || (UpdatePoiDetailsUI.getInstance?.());
    if (updateUI) updateUI.closePopup();

    try {
        // 2. Daten ans Backend senden
        const updateResult = await handleUpdateStoneDetails(stoneData, backendServiceInstance);
        
        if (updateResult && updateResult.success) {
            // 3. Store lokal aktualisieren mit den Daten, die wir gerade gesendet haben
            // Wir müssen hier sicherstellen, dass stoneData alle Felder hat.
            updateSinglePoiInStore(stoneData);

            // 4. UI-Komponenten informieren (nutzen jetzt die neuen Daten aus dem Store)
            if (activeMarker && typeof activeMarker.getAllChildMarkers !== 'function') {
                
                // Marker-Icon aktualisieren (falls sich z.B. der Caretaker-Status geändert hat)
                UpdateMarkerIcon(activeMarker, true, mapState);

                // Bottom Sheet aktualisieren
                updateBsForPoi(Number(stoneData.gid), {
                    bottomSheetUI: bottomSheetUIInstance,
                    backendService: backendServiceInstance,
                    mapState: mapState,
                    insertPoiUI: addButtonUIInstance,
                    updatePoiUI: updatePoiUIInstance
                });
            }
            
            showToast("Erfolg", "Daten lokal und auf Server aktualisiert.");
        }
    } catch (error) {
        console.error("Fehler beim lokalen Update:", error);
        showToast("Fehler", "Daten konnten nicht synchronisiert werden.");
    }
};

    return function () {
        // GID vom aktiven Element im MapState beziehen
        const activeElement = mapState.activeMarkerOrCluster;
        const gid = activeElement ? activeElement.options.gid : null;

        if (!gid) {
            showToast("Fehler: Kein aktiver Stolperstein ausgewählt.", 'error');
            return;
        }

        const instance = UpdatePoiDetailsUI.getInstance();
        if (!instance) return;

        // 1. Daten direkt aus dem lokalen Store holen (synchron & schnell)
        const localPoiData = getPoiData(gid);

        if (localPoiData) {
            // 2. Popup sofort öffnen mit den vorhandenen Daten
            instance.showPopup(localPoiData, onSaveCallback);
        } else {
            // Falls der Stein wider Erwarten nicht im Store ist
            showToast("Fehler: Daten konnten lokal nicht gefunden werden.", 'error');
            mylog("ERROR: GID " + gid + " nicht im poi-store gefunden.");
        }
    };
}