// sc-settings-location.js
import { LocationTrackingCoordinator } from './loc-tracking-co.js';;

let scSettingsLocationInstance = null;

export class ScSettingsLocation {
    /**
     * @private {HTMLElement} _parentElement - Das DOM-Element, in das die Standort-UI gerendert wird.
     * @private {HTMLElement} _mainSliderElement - Der Haupt-Custom-Toggle-Slider.
     * @private {HTMLElement} _locationToggleValueDisplayElement - Das HTML-Span-Element für die Textanzeige (An/Aus).
     * @private {LocationTrackingCoordinator|null} _locTrackingCoordinator - Das Singleton der LocationTrackingCoordinator-Klasse (kann null sein, wenn nicht initialisiert).
     */
    constructor(parentElement) { 
        
        // Ruft das Singleton ab. Es ist nun die Aufgabe dieser Klasse, es zu finden.
        this._locTrackingCoordinator = LocationTrackingCoordinator.getInstance();
        
        if (!(this._locTrackingCoordinator instanceof LocationTrackingCoordinator)) {
            // WICHTIG: Kein 'return' hier! Sonst würde der Konstruktor 'undefined' zurückgeben 
            // und SettingsUI würde den Folgefehler werfen. Wir loggen nur den Fehler.
            console.error("ScSettingsLocation: Eine gültige Instanz von LocationTrackingCoordinator ist erforderlich.");
        }

        this._parentElement = parentElement;
        this._mainSliderElement = null;
        this._locationToggleValueDisplayElement = null;

        this._injectHTML();
        this._injectCSS();
        this._cacheElements();
        
        // Listener nur hinzufügen, wenn der Manager verfügbar ist.
        if (this._locTrackingCoordinator) {
            this._addEventListeners();

            // Abonniere den Status-Callback der LocationTrackingCoordinator-Klasse
            this._locTrackingCoordinator.onTrackingStateChange(isActive => {
                this._updateUIState(isActive);
            });

            // Setze den initialen UI-Zustand basierend auf dem aktuellen Tracking-Status
            this._updateUIState(this._locTrackingCoordinator.isTrackingActive());
        }

        console.log("ScSettingsLocation: Instanziiert und bereit.");
    }

    /**
     * Injiziert das HTML für den Standort-Bereich in das Parent-Element.
     * @private
     */
    _injectHTML() {
        const htmlContent = `
            <div class="settings-content">
                <div class="setting-item">
                    <label for="location-toggle-slider">Standortfreigabe</label>
                    <div id="location-toggle-slider" class="custom-on-off-toggle">
                        <div class="custom-toggle-handle"></div>
                    </div>
                    <span id="location-toggle-value" class="slider-value">Aus</span>
                </div>
            </div>
        `;
        if (this._parentElement) {
            this._parentElement.insertAdjacentHTML('beforeend', htmlContent);
        } else {
            console.error("ScSettingsLocation: Parent element not provided for HTML injection.");
        }
    }

    /**
     * Injiziert das spezifische CSS für den Standort-Bereich.
     * @private
     */
    _injectCSS() {
        const cssContent = `
            /* Allgemeine Einstellungen für Layout */
            .settings-content {
                padding-top: 10px;
            }
            .setting-item {
                display: flex;
                align-items: center;
                padding: 10px 0;
                border-bottom: 1px solid #eee;
            }
            .setting-item:last-child {
                border-bottom: none;
            }
            .setting-item label {
                flex-shrink: 0;
                font-size: 1.1em;
                color: #555;
                cursor: pointer;
                margin-right: 15px;
            }
            .custom-on-off-toggle {
                margin: 0 10px;
                height: 24px;
                width: 50px;
                border-radius: 12px;
                background: #ccc;
                cursor: pointer;
                position: relative;
                transition: background-color 0.2s ease;
            }
            .custom-on-off-toggle.active {
                background: #4CAF50;
            }
            .custom-toggle-handle {
                width: 20px;
                height: 20px;
                background: #fff;
                border-radius: 50%;
                position: absolute;
                top: 2px;
                left: 2px;
                transition: left 0.2s ease;
                box-shadow: 0 1px 3px rgba(0,0,0,0.4);
            }
            .custom-on-off-toggle.active .custom-toggle-handle {
                left: 28px;
            }
            .slider-value {
                min-width: 40px;
                text-align: right;
                font-size: 1.1em;
                color: #555;
            }
        `;
        if (!document.getElementById('sc-location-settings-styles')) {
            const styleElement = document.createElement('style');
            styleElement.id = 'sc-location-settings-styles';
            styleElement.textContent = cssContent;
            document.head.appendChild(styleElement);
        }
    }

    /**
     * Cacht die DOM-Elemente des Standort-Bereichs.
     * @private
     */
    _cacheElements() {
        this._mainSliderElement = this._parentElement.querySelector('#location-toggle-slider');
        this._locationToggleValueDisplayElement = this._parentElement.querySelector('#location-toggle-value');
    }

    /**
     * Fügt Event-Listener für die Standort-UI-Elemente hinzu.
     * @private
     */
    _addEventListeners() {
        if (this._mainSliderElement) {
            this._mainSliderElement.addEventListener('click', this._handleSliderClick.bind(this));
        }
    }

    /**
     * Handler für den Klick auf den Slider.
     * @private
     */
    _handleSliderClick() {
        // Füge eine Sicherheitsprüfung hinzu
        if (!this._locTrackingCoordinator) {
            console.warn("Klick ignoriert: LocationTrackingCoordinator Manager nicht verfügbar.");
            return;
        }

        if (this._locTrackingCoordinator.isTrackingActive()) {
            this._locTrackingCoordinator.stopLocationTracking();
        } else {
            // StartTrackingAndHandlePermission() muss den TrackingStateChange-Event auslösen, 
            // der _updateUIState() asynchron aktualisiert.
            this._locTrackingCoordinator.startTrackingAndHandlePermission();
        }
    }

    /**
     * Aktualisiert die UI (Slider und Text) basierend auf dem aktuellen Status.
     * @private
     * @param {boolean} isActive
     */
    _updateUIState(isActive) {
        this._updateMainSliderVisual(isActive);
        this._updateLocationToggleDisplay(isActive ? 1 : 0);
    }

    /**
     * Aktualisiert die Textanzeige für den Location Toggle (An/Aus).
     * @private
     */
    _updateLocationToggleDisplay(value) {
        if (this._locationToggleValueDisplayElement) {
            this._locationToggleValueDisplayElement.textContent = value === 1 ? 'An' : 'Aus';
        }
    }

    /**
     * Aktualisiert den visuellen Zustand des Location Toggle Sliders.
     * @private
     */
    _updateMainSliderVisual(isEnabled) {
        if (this._mainSliderElement) {
            if (isEnabled) {
                this._mainSliderElement.classList.add('active');
            } else {
                this._mainSliderElement.classList.remove('active');
            }
        }
    }

    // --- Öffentliche Schnittstelle für SettingsUI ---

    /**
     * Setzt den Zustand des Standortfreigabe-Toggles (Slider) in der UI.
     * Diese Methode wird von SettingsUI.updateLocationToggle() aufgerufen, 
     * um den visuellen Zustand zu synchronisieren.
     * @param {boolean} isEnabled - True für 'An', False für 'Aus'.
     */
    setLocationToggle(isEnabled) { 
        this._updateUIState(isEnabled);
    }
    
    /**
     * Gibt den aktuellen Zustand des Sandortfreigabe-Toggles (Slider) zurück.
     * @returns {boolean|null} True, wenn 'An', False, wenn 'Aus', oder null, wenn Manager fehlt.
     */
    getLocationToggleState() {
        if (!this._locTrackingCoordinator) {
             return null;
        }
        return this._locTrackingCoordinator.isTrackingActive();
    }
}

/**
 * Initialisiert die ScSettingsLocation-Komponente.
 * @param {HTMLElement} parentElement - Das DOM-Element, in das die UI gerendert wird.
 * @returns {ScSettingsLocation} Die neu erstellte oder existierende Instanz.
 */
export function initializeLocationSettings(parentElement) {
    if (scSettingsLocationInstance) {
        console.warn("ScSettingsLocation wurde bereits initialisiert. Existierende Instanz zurückgegeben.");
        return scSettingsLocationInstance;
    }
    try {
        // Konstruktor wird jetzt nur mit parentElement aufgerufen.
        scSettingsLocationInstance = new ScSettingsLocation(parentElement);
        console.log("ScSettingsLocation: Initialisierung abgeschlossen.");
        return scSettingsLocationInstance;
    } catch (error) {
        console.error("Fehler bei der Initialisierung von ScSettingsLocation:", error);
        return null; // Gibt null zurück, wenn die Initialisierung fehlschlägt
    }
}

/**
 * Gibt den aktuellen UI-Zustand des Standort-Toggles (Ein/Aus) zurück.
 * @returns {boolean|null} True, wenn 'An', False, wenn 'Aus', oder null bei Fehler.
 * @public
 */
export function getLocationToggleState() {
    if (!scSettingsLocationInstance) {
        console.error("ScSettingsLocation ist nicht initialisiert. Rufen Sie zuerst initializeLocationSettings() auf.");
        return null;
    }
    return scSettingsLocationInstance.getLocationToggleState();
}