// popup-utils.js
// Funktionen , die sich auf das marker popup bezoehen
import { ScStone } from './ScStone.js';
import { showToast } from './sc-utilities.js'; // showToast für Fehlermeldungen importieren
import { is_development } from './sc-utilities.js'; // ✅ NEU: is_development importiert
import { getColorCodeAndText, getMarkerIcon } from './marker-display-utils.js';

/**
 * Ableiten von Farbe und Popup-Text abhängig vom lastcleaned datum
 * @param {*} lastCleanedTimestamp 
 * @returns 
 */
/* jetzt in marker-display-utils.js
function getColorCodeAndText(lastCleanedTimestamp) {
    let colorCode = "gray";
    let colorText = "(Zeitpunkt unbekannt)";

    if (lastCleanedTimestamp) {
        const lastCleanedDate = new Date(lastCleanedTimestamp);
        const currentDate = new Date();
        const diffTime = currentDate - lastCleanedDate;
        const diffMonths = diffTime / (1000 * 60 * 60 * 24 * 30);

        if (diffMonths < 1) {
            colorCode = "green";
            colorText = "im letzten Monat";
        } else if (diffMonths >= 1 && diffMonths < 3) {
            colorCode = "yellow";
            colorText = "vor 1 - 3 Monaten";
        } else if (diffMonths >= 3 && diffMonths < 6) {
            colorCode = "orange";
            colorText = "vor 3 - 6 Monaten";
        } else if (diffMonths >= 6) {
            colorCode = "red";
            colorText = "vor mehr als 6 Monaten";
        }
    }
    return { colorCode, colorText };
}
*/
/**
 * Setzen des css style für das Stolperstein Icon - abh. davon, ob es einen Paten gibt Dreieck oder Schild
 * @param {*} caretakerStatus 
 * @param {*} colorCode 
 * @returns 
 */
/* jetzt in marker-display-utils.js
function getMarkerIcon(caretakerStatus, colorCode) {
    let iconHtml = "";

    if (caretakerStatus && caretakerStatus.trim() !== "") {
        iconHtml = `<i class="fas fa-shield-alt" style="font-size: 24px; color:${colorCode}; background: none; border: none;"></i>`;
    } else {
        iconHtml = `<i class="fas fa-exclamation-triangle" style="font-size: 24px; color:${colorCode}; background: none; border: none;"></i>`;
    }
    return iconHtml;
}
*/
/**
 * Setzen der Inhalte für das Marker Popup des Stolpersteins
 * @param {*} marker 
 * @param {Object} userLocationInstance - ✅ NEU: Instanz der ScUserLocation-Klasse.
 * @param {Object} tzManagerInstance - ✅ NEU: Instanz des TzManager.
 * @returns {string} Der HTML-Inhalt für das Popup.
 */
/* jetzt in marker-popup-utils.js
function getPopupContent(marker, userLocationInstance, tzManagerInstance) {
    const props = marker.options.data;
    const latlng = marker.getLatLng();
    const coords = latlng ? [latlng.lat, latlng.lng] : null;

    let actionContent = "";
    let caretakerStatus = props.caretaker || "";
    let isCaretakerEmpty = caretakerStatus === "";
    let isCaretakerAnonym = caretakerStatus === "anonym";
    let isCaretakerDefined = caretakerStatus !== "" && caretakerStatus !== "anonym";

    // ✅ Greife auf die Benutzerposition über die userLocationInstance zu
    const currentUserPosition = userLocationInstance.getUserPosition();

    if (currentUserPosition) {
        const distance = L.latLng(currentUserPosition).distanceTo(
            L.latLng(coords[0], coords[1])
        );

        // ✅ Greife auf die tzManagerInstance zu
        if (distance <= 99 || (tzManagerInstance && tzManagerInstance.isAdmin())) {
            if (isCaretakerEmpty) {
                actionContent = `
                    <div>
                        <label>
                            <input type="checkbox" id="caretaker-checkbox" /> Ich reinige regelmäßig (Patenschaft)
                        </label>
                    </div>
                    <br>
                    <button class="cleaned-button">
                        Ist gereinigt
                    </button>
                `;
            } else if (isCaretakerAnonym) {
                actionContent = `
                    <div>
                        <label>
                            <input type="checkbox" id="caretaker-checkbox" checked /> Ich reinige regelmäßig (Patenschaft)
                        </label>
                    </div>
                    <br><button class="cleaned-button">
                        Ist gereinigt</button>
                `;
            } else {
                actionContent = `
                    <div>
                        <label>
                            <input type="checkbox" id="caretaker-checkbox" checked disabled /> Reinigung in Putztour (Patenschaft)
                        </label>
                    </div>
                    <br><button class="cleaned-button">
                        Ist gereinigt</button>
                `;
            }
        } else {
            actionContent = `<br><button class="approach-button">Zum Markieren den Stolperstein aufsuchen</button>`;
        }
    }

    let lastCleanedDate = "N/A";
    if (props.last_cleaned) {
        const lastCleanedYear = new Date(props.last_cleaned).getFullYear();
        if (lastCleanedYear >= 2024) {
            lastCleanedDate = new Date(props.last_cleaned).toLocaleString();
        }
    }

    if (is_development()) {
        return `
            <b>${props.first_name} ${props.last_name}</b><br>
            Geboren: ${props.year_of_birth}<br>
            ${props.street} ${props.house_no}<br>
            <br>Gereinigt ${getColorCodeAndText(props.last_cleaned).colorText}
            <br> ( ${lastCleanedDate} )
            
            ${actionContent}
        `;
    } else {
        return `
            <b>${props.first_name} ${props.last_name}</b><br>
            Geboren: ${props.year_of_birth}<br>
            ${props.street} ${props.house_no}<br>
            <br>Gereinigt ${getColorCodeAndText(props.last_cleaned).colorText}
            ${actionContent}
        `;
    }
}
*/
/* jetzt in marker-popup-utils.js
function UpdateMarkerIcon(poiId, lastCleaned, markers) {
    console.log('DEBUG: UpdateMarkerIcon: markers-Objekt beim Start:', markers); // Debug-Log
    const marker = markers.getLayers().find((m) => m.options.data.gid === poiId);

    if (marker) {
        marker.options.data.needs_cleaning = false; // Status für "cleaned"
        marker.options.data.last_cleaned = lastCleaned; // Neues `last_cleaned` setzen

        const { colorCode, colorText } = getColorCodeAndText(lastCleaned); // Farben je nach Datum berechnen
        const iconHtml = getMarkerIcon(marker.options.data.caretaker, colorCode);

        // Markierer-Icon aktualisieren
        marker.setIcon(
            L.divIcon({
                html: iconHtml,
                className: "custom-icon",
                iconSize: [30, 30],
            })
        );
        console.log('DEBUG: UpdateMarkerIcon: Vor refreshClusters(), markers:', markers); // Debug-Log
        if (markers && typeof markers.refreshClusters === 'function') {
            markers.refreshClusters(); // Aktualisiere alle Marker-Cluster
            console.log("DEBUG: refreshClusters() erfolgreich aufgerufen in UpdateMarkerIcon.");
        } else {
            console.warn("WARNUNG: markers oder refreshClusters() nicht verfügbar in UpdateMarkerIcon.");
        }
        marker.closePopup(); // Schließe das Popup nach erfolgreichem Update
    } else {
        console.error(`Kein Marker mit der GID ${poiId} gefunden.`);
    }
}
*/



/**
 * Erstellt einen Klick-Handler für den "Bereinigt"-Button.
 * Markiert einen Stolperstein als "gesäubert".
 */
/* jetzt in marker-popup-utils.js
function createCleanClickHandler(markers, map, marker, scStoneInstance) {
    return async function (poiId) {

        try {
            // Ruft das Backend auf, um den Stein als 'sauber' zu markieren
            const result = await scStoneInstance.updateCleaningStatus(false);

            // Prüft auf Erfolg und das Vorhandensein des zurückgegebenen Datums
            if (result.success && result.last_cleaned) {
                //              showToast("Erfolg", "Status erfolgreich aktualisiert!");

                // Frontend-Update: Marker-Daten mit dem exakten Backend-Zeitstempel aktualisieren
                marker.options.data.last_cleaned = result.last_cleaned;

                // Marker-Icon basierend auf den neuen Daten aktualisieren
                const { colorCode: newColorCode } = getColorCodeAndText(marker.options.data.last_cleaned);
                const newIconHtml = getMarkerIcon(marker.options.data.caretaker, newColorCode);
                marker.setIcon(L.divIcon({
                    className: "poi-icon " + newColorCode,
                    html: newIconHtml,
                    iconSize: [24, 24],
                }));
                marker.closePopup();

                // Optional: Marker-Cluster aktualisieren, falls nötig
                if (markers && typeof markers.refreshClusters === 'function') {
                    markers.refreshClusters();
                }
            } else {
                showToast("Fehler", `Fehler beim Aktualisieren des Status: ${result.error || 'Backend hat kein Datum zurückgegeben.'}`);
            }
        } catch (error) {
            console.error("Fehler beim Senden der Statusaktualisierung:", error);
            showToast("Fehler", "Fehler beim Senden der Statusaktualisierung.");
        }

    };
}
*/
/**
 * Markiert den Stein als "ungesäubert" (dirty) im Admin-Modus.
 */
/* jetzt in marker-popup-utils.js
async function markStoneAsDirty(poiId, markers, map, marker, scStoneInstance, tzManagerInstance) {

    try {
        // ✅ Greife auf die tzManagerInstance zu
        if (!tzManagerInstance || !tzManagerInstance.isAdmin()) {
            showToast("Zugriffsfehler", "Nur Admins dürfen als 'schmutzig' markieren.");
            return;
        }
        // Ruft das Backend auf, um den Stein als 'schmutzig' zu markieren
        const result = await scStoneInstance.updateCleaningStatus(true);

        // Prüft auf Erfolg und das Vorhandensein des zurückgegebenen Datums
        if (result.success && result.last_cleaned) {
            //              showToast("Erfolg", "Status erfolgreich auf 'ungesäubert' aktualisiert!");

            // Frontend-Update: Marker-Daten mit dem exakten Backend-Zeitstempel aktualisieren
            marker.options.data.last_cleaned = result.last_cleaned;

            // Marker-Icon basierend auf den neuen Daten aktualisieren
            const { colorCode: newColorCode } = getColorCodeAndText(marker.options.data.last_cleaned);
            const newIconHtml = getMarkerIcon(marker.options.data.caretaker, newColorCode);
            marker.setIcon(L.divIcon({
                className: "poi-icon " + newColorCode,
                html: newIconHtml,
                iconSize: [24, 24],
            }));

            marker.closePopup();

            // Optional: Marker-Cluster aktualisieren, falls nötig
            if (markers && typeof markers.refreshClusters === 'function') {
                markers.refreshClusters();
            }
        } else {
            showToast("Fehler", `Fehler beim Aktualisieren des Status auf 'ungesäubert': ${result.error || 'Backend hat kein Datum zurückgegeben.'}`);
        }
    } catch (error) {
        console.error("Fehler beim Senden der Dirty-Statusaktualisierung:", error);
        showToast("Fehler", "Fehler beim Senden der Dirty-Statusaktualisierung.");
    }

}
*/

/**
 * ✅ NEU: Exportiert, damit sie von showmap.html genutzt werden kann
 * @param {*} poiId 
 * @param {*} isDirty 
 * @param {L.MarkerClusterGroup} markers Die Marker-Layer-Gruppe (für cluster-Refresh)
 * @param {Object} tzManagerInstance - ✅ NEU: Instanz des TzManager.
 * @returns 
 */

function handleCleaningStatusChange(poiId, isDirty, markers, tzManagerInstance) {
    console.log('DEBUG: handleCleaningStatusChange: markers-Objekt beim Start:', markers); // Debug-Log
    const username = localStorage.getItem("username");
    if (!username) {
        showToast("Fehler", "Kein Benutzername gefunden."); // Ersetzt alert
        return;
    }

    /*        const tzManager = window.tzManager;*/

    // ✅ Greife auf die tzManagerInstance zu
    if (!tzManagerInstance || !tzManagerInstance.isAdmin()) {
        showToast("Zugriffsfehler", "Nur Admins dürfen als 'schmutzig' markieren.");
        return;
    }

    // DB-Update aufrufen
    const stone = new ScStone({ gid: poiId });

    // Status in DB aktualisieren
    stone.updateCleaningStatus(isDirty)
        .then((result) => {
            UpdateMarkerIcon(poiId, result.last_cleaned, markers); // GUI aktualisieren
        })
        .catch((error) => {
            console.error("Fehler beim Aktualisieren des Status:", error);
            showToast("Update-Fehler", "Der Status konnte nicht aktualisiert werden."); // Ersetzt alert
        });

}

/**
 * Aktualisiert den Caretaker-Status eines POI.
 * @param {number} gid Die globale ID des POI.
 * @param {boolean} isChecked Ob die Checkbox aktiviert ist (true = 'anonym', false = NULL).
 * @param {L.MarkerClusterGroup} markers Die Leaflet MarkerClusterGroup Instanz.
 * @param {L.Map} map Die Leaflet Karteninstanz.
 * @param {L.Marker} marker Das Leaflet Marker-Objekt.
 * @param {ScStone} scStoneInstance Die ScStone-Instanz für den aktuellen Marker.
 */
/* jetzt in marker-popup-utils.js
async function handleCaretakerCheckboxChange(gid, isChecked, markers, map, marker, scStoneInstance) {
    console.debug('DEBUG: handleCaretakerCheckboxChange: markers-Objekt beim Start:', markers);

    try {
        const response = await scStoneInstance.updateCaretakerStatus(isChecked);

        if (response.success) {
            //       showToast("Erfolg", "Paten-Status erfolgreich aktualisiert!");

            // --- WICHTIG: GUI Update für den einzelnen Marker ---
            // 1. Aktualisiere die Daten des Markers lokal
            marker.options.data.caretaker = isChecked ? "anonym" : null; // Oder ein leerer String, je nachdem was dein Backend speichert

            // 2. Berechne die neue Farbe und das neue Icon basierend auf den AKTUALISIERTEN Marker-Daten
            // Die Farbe (basierend auf last_cleaned) ändert sich hier nicht, aber das Icon könnte sich ändern,
            // wenn es ein spezielles Symbol für "mit Pate" vs. "ohne Pate" gibt.
            const { colorCode: newColorCode } = getColorCodeAndText(marker.options.data.last_cleaned);
            const newIconHtml = getMarkerIcon(marker.options.data.caretaker, newColorCode);

            // 3. Setze das neue Icon für den Marker
            marker.setIcon(L.divIcon({
                className: "poi-icon " + newColorCode,
                html: newIconHtml,
                iconSize: [24, 24],
            }));

            // 4. Schließe das Popup
            marker.closePopup();

            // 5. Aktualisiere die Cluster
            if (markers && typeof markers.refreshClusters === 'function') {
                markers.refreshClusters();
                console.debug('DEBUG: refreshClusters() erfolgreich nach Status-Update aufgerufen.');
            } else {
                console.warn('WARNUNG: markers oder refreshClusters() nicht verfügbar nach Status-Update.');
            }


        } else {
            console.error('Fehler beim Senden oder Verarbeiten der Caretaker-Anfrage:', error);
            showToast("Fehler", 'Fehler beim Aktualisieren der Patenschaft: ' + error.message);
        }
    } catch (error) {
        console.error('Fehler beim Senden oder Verarbeiten der Caretaker-Anfrage:', error);
        showToast("Fehler", 'Ein unerwarteter Fehler ist aufgetreten: ' + error.message);
    }
}
*/
/**
 * Hängt Event-Listener an die Aktionen im Popup an (z.B. Checkbox, Buttons).
 * Diese Funktion verwaltet die Interaktionen im Stolperstein-Popup,
 * einschließlich des Verhaltens des "Gereinigt"-Buttons bei Einfach- und Doppelklick.
 * @param {HTMLElement} popupElement Das DOM-Element des Popups.AA
 * @param {L.MarkerClusterGroup} markers Die Leaflet MarkerClusterGroup Instanz.
 * @param {L.Map} map Die Leaflet Karteninstanz.
 * @param {L.Marker} marker Das Leaflet Marker-Objekt, zu dem das Popup gehört.
 * @param {ScStone} scStoneInstance Die ScStone-Instanz für den aktuellen Marker.
 * @param {Object} tzManager Die tzManager-Instanz für den Admin-Modus (enthält isAdmin()).
 */
/* jetzt in marker-popup-utils.js
function attachPopupActionListeners(popupElement, markers, marker, map, scStoneInstance, tzManager) {
    console.debug('DEBUG: attachPopupActionListeners: markers-Objekt beim Start:', markers);

    // Event-Listener für die "Caretaker"-Checkbox
    const caretakerCheckbox = popupElement.querySelector('#caretaker-checkbox');
    if (caretakerCheckbox) {
        const handleCaretakerChange = function () {
            const gid = parseInt(marker.options.data.gid, 10);
            const isChecked = this.checked;
            if (isNaN(gid)) {
                console.error("Fehler: GID des Markers ist keine gültige Zahl.");
                return;
            }
            handleCaretakerCheckboxChange(gid, isChecked, markers, map, marker, scStoneInstance);
        };

        // Entfernt alte Listener, um Doppelbindungen zu vermeiden
        if (caretakerCheckbox._caretakerChangeListener) {
            caretakerCheckbox.removeEventListener('change', caretakerCheckbox._caretakerChangeListener);
        }
        caretakerCheckbox.addEventListener('change', handleCaretakerChange);
        caretakerCheckbox._caretakerChangeListener = handleCaretakerChange; // Speichert den Listener zur späteren Entfernung
    }

    // Event-Listener für den "Bereinigt"-Button
    const cleanedButton = popupElement.querySelector(".cleaned-button");
    if (cleanedButton) {
        // Variablen zur Erkennung von Einfach- und Doppelklicks
        let clickTimeout;
        let lastClickTime = 0;
        let clickCount = 0;
        const DOUBLE_CLICK_THRESHOLD_MS = 300;

        const handleCleanButtonClick = function () {
            const now = Date.now();
            const isDoubleClickEvent = (now - lastClickTime < DOUBLE_CLICK_THRESHOLD_MS);

            lastClickTime = now;

            if (isDoubleClickEvent) {
                clickCount++;
            } else {
                clickCount = 1;
            }

            const poiId = parseInt(marker.options.data.gid, 10);
            if (isNaN(poiId)) {
                console.error("Fehler: GID des Markers ist keine gültige Zahl.", marker.options.data.gid);
                return;
            }

            clearTimeout(clickTimeout);

            if (clickCount === 1) {
                // Dies ist der erste Klick.
                // Setze einen Timer. Wenn bis dahin kein zweiter Klick erfolgt, ist es ein Einfachklick.
                clickTimeout = setTimeout(() => {
                    // ✅ NEU: Einfachklick markiert IMMER als "gereinigt", egal ob Admin-Modus oder nicht.
                    console.log(`Einfachklick auf Gereinigt-Button für POID: ${poiId}. Markiere als sauber.`);
                    createCleanClickHandler(markers, map, marker, scStoneInstance)(poiId);

                    clickCount = 0; // Zähler für die nächste Interaktion zurücksetzen
                }, DOUBLE_CLICK_THRESHOLD_MS);
            } else if (clickCount >= 2) {
                // Dies ist der zweite Klick oder ein weiterer Klick innerhalb des Zeitfensters,
                // was einen Doppelklick bestätigt.
                if (tzManager && tzManager.isAdmin()) {
                    // Im Admin-Modus bedeutet ein Doppelklick "ungesäubert" (rot).
                    console.log(`Admin Modus: Doppelklick auf Gereinigt-Button für POID: ${poiId}. Markiere als ungesäubert.`);
                    markStoneAsDirty(poiId, markers, map, marker, scStoneInstance, tzManager);
                } else {
                    // Im normalen Modus (oder wenn Admin-Modus nicht aktiv) führt ein Doppelklick
                    // auch zur Markierung als "gesäubert" (grün), da der Einfachklick die primäre Aktion ist.
                    console.log(`Normaler Doppelklick auf Gereinigt-Button für POID: ${poiId}. Markiere als sauber.`);
                    createCleanClickHandler(markers, map, marker, scStoneInstance)(poiId);
                }
                clickCount = 0; // Zähler für die nächste Interaktion zurücksetzen
            }
        };

        // Entfernt alte Listener, um Doppelbindungen zu vermeiden
        if (cleanedButton._cleanButtonListener) {
            cleanedButton.removeEventListener('click', cleanedButton._cleanButtonListener);
        }
        cleanedButton.addEventListener('click', handleCleanButtonClick);
        cleanedButton._cleanButtonListener = handleCleanButtonClick;
    }
}
*/

/**
 * Erstellt und verwaltet den "Taps and Zooms" (tz) Admin-Modus.
 * @param {HTMLElement} triggerElement Das DOM-Element, das angetippt werden muss.
 * @param {Function} onActivate Callback-Funktion, die aufgerufen wird, wenn der Admin-Modus aktiviert wird.
 * @returns {{isAdmin: Function}} Ein Objekt mit einer isAdmin-Methode.
 */
function createTzManager(triggerElement, onActivate) {
    let tapCount = 0;
    let lastTapTime = 0;
    const TAP_THRESHOLD_MS = 500; // Zeitfenster für aufeinanderfolgende Taps
    const REQUIRED_TAPS = 5;      // Anzahl der Taps zum Aktivieren
    let adminMode = false;        // Standardmäßig deaktiviert

    if (!triggerElement) {
        console.error("createTzManager: Trigger-Element nicht gefunden.");
        return { isAdmin: () => false };
    }

    triggerElement.addEventListener('click', () => {
        const now = Date.now();
        if (now - lastTapTime < TAP_THRESHOLD_MS) {
            tapCount++;
        } else {
            tapCount = 1; // Reset, wenn zu viel Zeit zwischen den Taps liegt
        }
        lastTapTime = now;

        console.debug(`DEBUG: Tap Count: ${tapCount}`);

        if (tapCount >= REQUIRED_TAPS && !adminMode) {
            adminMode = true;
            tapCount = 0; // Zähler zurücksetzen
            if (onActivate && typeof onActivate === 'function') {
                onActivate(); // Callback aufrufen
            }
        }
    });

    return {
        isAdmin: () => adminMode, // Methode, um den Status des Admin-Modus abzufragen
        // Optional: Methoden zum Deaktivieren oder Umschalten könnten hier hinzugefügt werden
        // deactivate: () => { adminMode = false; console.log("Admin Modus deaktiviert."); },
        // toggle: () => { adminMode = !adminMode; console.log("Admin Modus umgeschaltet:", adminMode); }
    };
}




// Liste aller funktion die exportiert werden sollen
export {
    getColorCodeAndText,
    getMarkerIcon,
    getPopupContent,
    handleCaretakerCheckboxChange,
    createCleanClickHandler,
    handleCleaningStatusChange,
    is_development,
    UpdateMarkerIcon,
    attachPopupActionListeners,
    createTzManager
};