// map-loc-ui.js
import { LocationTrackingCoordinator } from './loc-tracking-co.js';
import { showToast, mylog } from './utilities.js';
import { L, getMap } from './map-service.js'; 

/**
 * Klasse zur visuellen Darstellung des Benutzerstandorts auf einer Leaflet-Karte.
 * Fungiert als Observer für den LocationTrackingCoordinator.
 */
export class MapLocationUI {
    
    /**
     * @private {L.Map} _map - Die Leaflet-Karte.
     * @private {LocationTrackingCoordinator} _coordinator - Referenz auf das Model/Controller-Singleton.
     * @private {L.Marker|null} _userMarker - Der Leaflet-Marker.
     * @private {L.divIcon} _userIcon - Das Icon für den Benutzer-Marker.
     */
    constructor() {
        // Holen der Map-Instanz direkt aus dem Service statt via Parameter
        try {
            this._map = getMap();
        } catch (error) {
            throw new Error(`MapLocationUI Initialisierung fehlgeschlagen: ${error.message}`);
        }
        
        this._coordinator = LocationTrackingCoordinator.getInstance();
        this._userMarker = null;

        // View-spezifische Initialisierung
        this._userIcon = L.divIcon({ 
            className: 'user-location-emoji',
            html: '📍',
            iconSize: [20, 20],
            iconAnchor: [10, 10]
        });

        this._subscribeToController();
        mylog("MapLocationUI: Instanziiert und bereit (Map via MapService bezogen).");
    }

    // --- Observer-Implementierung ---

    _subscribeToController() {
        // Abonniere Statuswechsel, um Marker zu entfernen, wenn Tracking stoppt
        this._coordinator.onTrackingStateChange(isActive => {
            if (!isActive) {
                this.clearMarker();
            }
        });

        // Abonniere Positions-Updates, um Marker zu verschieben/zentrieren
        this._coordinator.onNewPosition((position, isInitial) => {
            this.updateMarker(position);
            if (isInitial) {
                // Bei initialer Position einmal zentrieren
                this.centerView(position, 16); 
            }
        });
    }

    // --- View Methoden (Manipulation der Karte) ---

    /**
     * Aktualisiert die Position des Markers oder erstellt ihn neu.
     * @param {GeolocationPosition} position 
     */
    updateMarker(position) {
        if (!position || !position.coords) return;
        
        const latlng = [position.coords.latitude, position.coords.longitude];

        if (this._userMarker) {
            this._userMarker.setLatLng(latlng);
        } else {
            // Marker erstellen und zur Karte hinzufügen
            this._userMarker = L.marker(latlng, { icon: this._userIcon, zIndexOffset: 1000 }).addTo(this._map);
            this._userMarker.on('click', () => {
                this.centerView(position, this._map.getZoom());
            });
        }
    }

    /**
     * Entfernt den Marker von der Karte.
     */
    clearMarker() {
        if (this._userMarker) {
            this._map.removeLayer(this._userMarker);
            this._userMarker = null;
        }
    }

    /**
     * Zentriert die Karte auf die aktuelle Position.
     * @param {GeolocationPosition} position 
     * @param {number} zoom 
     */
    centerView(position, zoom = 18) {
        if (this._map && position && position.coords) {
            const latLng = [position.coords.latitude, position.coords.longitude];
            if (latLng[0] !== 0 || latLng[1] !== 0) {
                this._map.setView(latLng, zoom);
                mylog(`MapLocationUI: Karte auf Benutzerposition zentriert (Zoom: ${zoom}).`);
                return;
            }
        }
        mylog("MapLocationUI: Position nicht verfügbar. Zeige Hinweis.");
        showToast('Standort-Tracking ist inaktiv oder Position wird noch abgerufen. Bitte warten.', 'Info');
    }
}