// 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 { handleMarkerSelection } from './map-gen-mgr.js';
import { getMap, getMarkers } from './map-markers-co.js';
import { updateSinglePoiInStore } from './poi-store.js';
import { UpdatePoiUI } from './update-poi-details-ui.js';

/* Behandelt das Speichern eines aktualisierten Stolpersteins. */
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');
            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');
    }
}

/**
 * Erstellt den Klick-Handler für den "Bearbeiten"-Button.
 * BEREINIGT: markers und map aus der Signatur entfernt.
 */
export function createUpdateClickHandler(
    bottomSheetUIInstance,
    marker,
    backendServiceInstance,
    mapState,
    addButtonUIInstance,
    updatePoiUIInstance
) {
    const onSaveCallback = async (stoneData) => {
        // BEREINIGT: Instanzen über Singletons beziehen
        const map = getMap();
        const poiClusters = getMarkers();
        const activeMarker = mapState.activeMarkerOrCluster;

        let updateUI = updatePoiUIInstance;

        if (!updateUI) {
            updateUI = (typeof UpdatePoiUI !== 'undefined' && UpdatePoiUI.getInstance)
                ? UpdatePoiUI.getInstance()
                : undefined;
        }
        if (updateUI) updateUI.closePopup();

        try {
            const updateResult = await handleUpdateStoneDetails(stoneData, backendServiceInstance);
            if (!updateResult || !updateResult.success) {
                if (updateUI) updateUI.closePopup();
                return;
            }

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

            if (!activeMarker || activeMarker.getAllChildMarkers) {
                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();
                return;
            }

            if (freshPoiData && freshPoiData.gid) {
                    // Poistore aktualisieren
                updateSinglePoiInStore(freshPoiData);

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

                // 2. Daten-Update
                activeMarker.options.data = freshPoiData;

                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
                if (activeMarker.__parent && typeof activeMarker.__parent._updateIcon === 'function') {
                    activeMarker.__parent._updateIcon();
                }

                // 4. Highlight
                UpdateMarkerIcon(
                    activeMarker,
                    isMarkerHighlighted(activeMarker.options.data.gid, mapState)
                );

                // 5. BOTTOM SHEET aktualisieren
                updateBsForPoi(
                    Number(stoneData.gid), {
                    bottomSheetUI: bottomSheetUIInstance,
                    backendService: backendServiceInstance,
                    mapState: mapState,
                    insertPoiUI: addButtonUIInstance,
                    updatePoiUI: updatePoiUIInstance
                }
                );

                // 6. Zentrieren
                if (poiClusters && typeof poiClusters.zoomToShowLayer === 'function') {
                    poiClusters.zoomToShowLayer(activeMarker, () => {
                        mylog("DEBUG: Karte nach Update zentriert.");
                        map.invalidateSize();
                    });
                }

            } else {
                showToast("Fehler", "Konnte die aktualisierten Daten nicht laden.");
                if (updateUI) updateUI.closePopup();
            }
        } catch (error) {
            console.error("Fehler beim Aktualisieren der Daten:", error);
            showToast("Fehler", "Ein Fehler ist beim Speichern oder Neuladen aufgetreten.");
            if (updateUI) updateUI.closePopup();
        }
    };

    return async function () {
        const displayedObject = bottomSheetUIInstance.getDisplayedObject();

        if (!displayedObject || !displayedObject.options || !displayedObject.options.data) {
            console.error("Fehler: Aktuell angezeigtes Objekt oder Daten fehlen.");
            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;
        }

        try {
            showToast("Lade aktuelle Daten...", 'info', 500);
            const latestPoiData = await backendServiceInstance.fetchPoiByGID(gid);

            if (latestPoiData && typeof latestPoiData === 'object') {
                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.", 'error');
        }
    };
}