// update-poi-details-co.js
import { showToast, getCurrentUser, mylog } from './sc-utilities.js';
import { BackendService } from './backend-poi.js';
import { updateBsForPoi } from './bs-poi-co.js';
import { UpdateMarkerIcon, isMarkerHighlighted } from './map-poi-mgr.js';
import { triggerMarkerClick } from './map-gen-mgr.js';
import { UpdatePoiUI } from './update-poi-details-ui.js';


/* Behandelt das Speichern eines aktualisierten Stolpersteins.
* @param {object} stoneData - Die vom Popup gesammelten Daten.
* @param {BackendService} backendService - Die Instanz des BackendService.
*/
export async function handleUpdateStoneDetails(stoneData, backendService) {
    console.log("Starte Aktualisierung für Stolperstein mit GID:", stoneData.gid);

    if (!stoneData.gid) {
        console.error("Fehler: Keine GID zum Aktualisieren des Stolpersteins vorhanden.");
        showToast("Fehler: Konnte den Stolperstein nicht identifizieren.");
        return;
    }

    const updateData = {
        gid: stoneData.gid,
        first_name: stoneData.first_name,
        last_name: stoneData.last_name,
        year_of_birth: stoneData.year_of_birth,
        stone_position: stoneData.stone_position,
        username: getCurrentUser()
    };

    try {
        const result = await backendService.updateStoneDetails(updateData);

        if (result.success) {
            console.log("Stolperstein erfolgreich aktualisiert:", result);
            showToast("Erfolg", "Stolperstein erfolgreich aktualisiert!", 'success');

            // Rückgabe des Erfolgsstatus ist optional, aber hilfreich für die aufrufende Funktion
            return { success: true, gid: stoneData.gid };
        } else {
            console.error("Fehler beim Aktualisieren des Stolpersteins:", result.error);
            showToast("Fehler", `Konnte Stolperstein nicht aktualisieren: ${result.error}`, 'error');
        }
    } catch (error) {
        console.error("Ein unerwarteter Fehler ist aufgetreten:", error);
        showToast("Fehler", "Ein Netzwerkfehler ist aufgetreten.", 'error');
    }
}


// ... (Andere Importe und die Funktion handleUpdateStoneDetails bleiben unverändert)

/**
 * Erstellt den Klick-Handler für den "Bearbeiten"-Button.
 * @param {BsUI} bottomSheetUIInstance - Die Instanz des Bottom Sheet UI.
 * @param {L.Marker} marker - Der aktuell ausgewählte Marker (noch in der Signatur für onSaveCallback benötigt).
 * @param {BackendService} backendServiceInstance - Die Instanz des BackendService.
 * @param {object} mapState - Der Zustand der Karte.
 * @param {function(): boolean} getAdminModeStatus - Funktion zur Abfrage des Admin-Modus-Status.
 * @param {object} markers - Eine Sammlung aller Marker.
 * @param {object} map - Die Karteninstanz.
 * @param {object} addButtonUIInstance - Die Instanz der "Hinzufügen"-Schaltfläche.
 * @param {object} updatePoiUIInstance - Die Instanz des Update-Popups.
 * @returns {Function} Der eigentliche Klick-Handler, der das Popup öffnet.
 */
export function createUpdateClickHandler(
    bottomSheetUIInstance,
    marker,
    backendServiceInstance,
    mapState,
    getAdminModeStatus,
    markers,
    map,
    addButtonUIInstance,
    updatePoiUIInstance
) {
    // ----------------------------------------------------------------------
    // onSaveCallback (Wird ausgeführt, wenn Daten im Popup gespeichert werden)
    // ----------------------------------------------------------------------
    const onSaveCallback = async (stoneData) => {
        // ... (Lokaler Code bis zur Aktualisierung der UI) ...
        
        // 🚨 KORRIGIERT: Hole den AKTUELLEN Marker aus dem mapState.
        const activeMarker = mapState.activeMarkerOrCluster;
        const poiClusters = markers; // Alias für MarkerClusterGroup

        // Wir fügen eine lokale Referenz für die UI-Instanz hinzu, um den Code sauberer zu halten.
        // 1. Instanz aus der Closure holen
        let updateUI = updatePoiUIInstance;
        


        // 2. Nur wenn die Closure-Instanz UNDEFINED ist, versuchen wir, das Singleton zu verwenden
        if (!updateUI) {
            // 🚨 KORRIGIERT: Kein '|| updatePoiUIInstance' am Ende mehr!
            updateUI = (typeof UpdatePoiUI !== 'undefined' && UpdatePoiUI.getInstance)
                ? UpdatePoiUI.getInstance()
                : undefined; // Explizit undefined setzen, um sicherzustellen, dass es keine Zuweisung gibt
        }
        if (updateUI) updateUI.closePopup();

        try {
            const updateResult = await handleUpdateStoneDetails(stoneData, backendServiceInstance);
            if (!updateResult || !updateResult.success) {
                if (updateUI) updateUI.closePopup(); // 🚨 Null-Check für TypeError
                return;
            }

            const freshResponse = await backendServiceInstance.fetchPoiByGID(stoneData.gid);
            const freshPoiData = freshResponse && freshResponse.data;

            // ------------------- Wichtigster Check -------------------
            // Stelle sicher, dass wir einen gültigen Marker haben (kein Cluster-Objekt).
            if (!activeMarker || activeMarker.getAllChildMarkers) { // Prüfe auf undefined ODER ob es ein Cluster ist
                mylog("ERROR: onSaveCallback: Aktiver Marker nicht gefunden oder ist ein Cluster. Update abgebrochen.");
                showToast("Fehler", "Interner Fehler: Aktiver Marker nicht gefunden.");
                if (updateUI) updateUI.closePopup(); // 🚨 Null-Check für TypeError
                return;
            }
            // --------------------------------------------------------------------------------

            if (freshPoiData && freshPoiData.gid) {

                // 1. HARD-RESET (Entfernen/Hinzufügen)
                if (poiClusters && poiClusters.hasLayer(activeMarker)) {
                    poiClusters.removeLayer(activeMarker);
                    mylog("DEBUG: Marker entfernt für Hard-Reset.");
                }

                // 2. Daten-Update und Marker wieder hinzufügen
                activeMarker.options.data = freshPoiData;


                // 🔥 NEU: Marker-Position explizit aktualisieren
                if (freshPoiData.lat && freshPoiData.lng) {
                    activeMarker.setLatLng([freshPoiData.lat, freshPoiData.lng]);
                }

                if (poiClusters) {
                    poiClusters.addLayer(activeMarker);
                    mylog("DEBUG: Aktualisierter Marker wieder zum Cluster hinzugefügt.");
                }

                // 3. Cluster-Zähler korrigieren
                if (activeMarker.__parent && typeof activeMarker.__parent._updateIcon === 'function') {
                    activeMarker.__parent._updateIcon();
                    mylog("DEBUG: Cluster-Icon nach Hard-Reset erzwungen neu gezeichnet.");
                }

                // 4. Highlight und Marker-Icon aktualisieren
                UpdateMarkerIcon(
                    activeMarker,
                    isMarkerHighlighted(activeMarker.options.data.gid, mapState)
                );

                // 5. BOTTOM SHEET mit den NEUEN Daten aktualisieren
                updateBsForPoi(
                    activeMarker, // <--- HIER IST DIE KONSISTENZ-KORREKTUR
                    bottomSheetUIInstance,
                    backendServiceInstance,
                    mapState,
                    getAdminModeStatus, // ⬅️ Parameter nachgerückt
                    markers,
                    map,
                    addButtonUIInstance,
                    updatePoiUIInstance
                );

                // 6. Karte auf den Marker zentrieren
                if (poiClusters && typeof poiClusters.zoomToShowLayer === 'function') {
                    poiClusters.zoomToShowLayer(activeMarker, () => {
                        mylog("DEBUG: Karte nach Update zentriert und Cluster offengelassen.");
                        map.invalidateSize();
                    });
                } else {
                    mylog("WARN: zoomToShowLayer nicht verfügbar oder poiClusters fehlt.");
                }
            
            } 

            else {
                showToast("Fehler", "Konnte die aktualisierten Daten nicht laden.");
                if (updateUI) updateUI.closePopup(); // 🚨 Null-Check für TypeError
            }
        } catch (error) {
            console.error("Fehler beim Aktualisieren der Daten:", error);
            showToast("Fehler", "Ein Fehler ist beim Speichern oder Neuladen aufgetreten.");
            if (updateUI) updateUI.closePopup(); // 🚨 Null-Check für TypeError
        }
    };
    // ----------------------------------------------------------------------
    // NEUER KLICK-HANDLER FÜR DEN EDIT-BUTTON (Robust gegen Swipes)
    // ----------------------------------------------------------------------
    return async function () { // Der Handler muss ASYNCHRON sein

        const displayedObject = bottomSheetUIInstance.getDisplayedObject();

        if (!displayedObject || !displayedObject.options || !displayedObject.options.data) {
            console.error("Fehler: Aktuell angezeigtes Objekt oder Daten fehlen (Bottom Sheet leer/instabil).");
            showToast("Fehler: Konnte aktuellen Marker nicht finden.", 'error');
            return;
        }

        const gid = displayedObject.options.data.gid;

        const instance = UpdatePoiUI.getInstance();

        if (typeof instance.showPopup !== 'function') {
            console.error("SCHWERER FEHLER: Update-Popup-Singleton ist beschädigt.");
            showToast("Fehler: UI-Instanz defekt.", 'error');
            return;
        }

        // Aktuelle Daten vom Server holen, um veraltete Daten zu vermeiden
        try {
            // Lade-Anzeige
            showToast("Lade aktuelle Daten...", 'info', 500);

            // Nutzen der korrekten, aktuellen Backend-Funktion
            const latestPoiData = await backendServiceInstance.fetchPoiByGID(gid);

            if (latestPoiData && typeof latestPoiData === 'object') {
                // Popup mit den AKTUELLEN (frischen) Daten vom Server öffnen
                instance.showPopup(latestPoiData, onSaveCallback);
            } else {
                console.error("Datenformatfehler nach GID-Abruf:", latestPoiData);
                showToast("Fehler: Unerwartete Antwort vom Server.", 'error');
            }

        } catch (error) {
            console.error("Fehler beim Abruf der aktuellen POI-Daten:", error);
            showToast("Daten konnten nicht geladen werden. Bitte erneut versuchen.", 'error');
        }
    };
}