// map-poi-navigation.js
import { mylog } from './sc-utilities.js';
import { LocationTrackingCoordinator } from './loc-tracking-co.js';

let routingControl = null;
let routeDecorator = null;

/**
 * Entfernt alle Routing-Elemente und Pfeile von der Karte.
 * (Vorgegebener Name: demarcate_route)
 */
export function demarcate_route(map) {
    if (!map) return;
    if (routingControl) {
        try { map.removeControl(routingControl); } catch (e) { }
        routingControl = null;
    }
    if (routeDecorator) {
        try { map.removeLayer(routeDecorator); } catch (e) { }
        routeDecorator = null;
    }
    // Falls clearNavigation als Alias gebraucht wird, rufen wir es hier mit ab
    mylog("DEBUG: Route via demarcate_route() entfernt.");
}

export function clearNavigation(map) {
    demarcate_route(map);
}

/**
 * Hilfsfunktion: Nutzt deinen BackendService (HERE Reverse Geocode), 
 * um Punkte auf die Straße zu zwingen.
 */
async function getSnappedCoords(backendService, coords) {
    try {
        const addressItem = await backendService.getAddressFromLocation(coords.lat, coords.lng);
        if (addressItem && addressItem.position) {
            mylog(`DEBUG: Snapping erfolgreich auf: ${addressItem.title || 'Straße'}`);
            return {
                lat: addressItem.position.lat,
                lng: addressItem.position.lng
            };
        }
    } catch (e) {
        mylog("DEBUG: Snapping fehlgeschlagen, nutze Original-Koordinaten.");
    }
    return coords;
}

/**
 * Zeichnet die Route. 
 * Wartet kurz, damit der Fokus auf dem Zielstein (Schritt 1) wirken kann,
 * und zoomt dann auf die Übersicht (Schritt 2).
 */
export async function showPedestrianRoute(map, startCoords, destCoords, backendService) {
    mylog("DEBUG: showPedestrianRoute startet");
    // 1. User-Position direkt vom Singleton holen
    const locTrackingCoordinator = LocationTrackingCoordinator.getInstance();
    const userPosArray = locTrackingCoordinator.getUserPosition(); // Liefert [lat, lng]

    if (!userPosArray) {
        mylog("DEBUG: Routing abgebrochen - Kein User-Standort vom Singleton.");
        return;
    }

    const userCoords = { lat: userPosArray[0], lng: userPosArray[1] };

    // 1. UI-Elemente via demarcate_route zurücksetzen
    demarcate_route(map);

    // 2. Start- und Zielpunkt via HERE begradigen
    const [snappedStart, snappedDest] = await Promise.all([
        getSnappedCoords(backendService, startCoords),
        getSnappedCoords(backendService, destCoords)
    ]);

    try {
        routingControl = L.Routing.control({
            waypoints: [
                L.latLng(snappedStart.lat, snappedStart.lng),
                L.latLng(snappedDest.lat, snappedDest.lng)
            ],
            router: L.Routing.osrmv1({
                serviceUrl: 'https://routing.openstreetmap.de/routed-foot/route/v1',
                profile: 'foot'
            }),
            lineOptions: {
                styles: [{ color: '#007bff', weight: 6, opacity: 0.8 }]
            },
            createMarker: () => null,
            addWaypoints: false,
            draggableWaypoints: false,
            show: false,
            fitSelectedRoutes: false // Verhindert sofortiges Springen
        }).addTo(map);

        routingControl.on('routesfound', (e) => {
            const routes = e.routes;
            const coords = routes[0].coordinates;
            const bounds = L.latLngBounds(coords);
            // 2. Erweitere die Box um den aktuellen User-Standort
            bounds.extend(userCoords);
            bounds.extend(L.latLng(userCoords.lat, userCoords.lng)); // usermarker immer in den blick nehmen
            /* zum debuggen die bounds box anzeigen
const boundsVisualizer = L.rectangle(bounds, {
                color: "#007bff",
                weight: 1,
                fillOpacity: 0.05,
                dashArray: '5, 5',
                interactive: false
            }).addTo(map);
            */

            // 3. Richtungspfeile hinzufügen
            routeDecorator = L.polylineDecorator(coords, {
                patterns: [
                    {
                        offset: 50,
                        repeat: 100,
                        symbol: L.Symbol.arrowHead({
                            pixelSize: 12,
                            headAngle: 60,
                            polygon: false,
                            pathOptions: { color: '#ffffff', weight: 2, opacity: 1 }
                        })
                    }
                ]
            }).addTo(map);

            // 4. Schritt 2: Verzögertes Herauszoomen auf die Übersicht
            // Wir warten 2 Sekunden, damit der User das Ziel (Schritt 1) wahrnimmt (clusster)
            setTimeout(() => {
                map.invalidateSize();

                // Dynamisches Padding für macOS Tahoe/Sequoia (12% oben)
                const mapHeight = map.getSize().y;
                const dynamicTopPadding = Math.max(100, mapHeight * 0.12);
                const bsElement = document.querySelector('.bottom-sheet-wrapper.open');
                const bsHeight = bsElement ? bsElement.offsetHeight : 0;

                map.flyToBounds(bounds, {
                    paddingTopLeft: [10, dynamicTopPadding],
                    paddingBottomRight: [10, bsHeight + 10],
                    animate: true,
                    duration: 1, // Sanftes Herausgleiten
                    maxZoom: 19
                });
                mylog("DEBUG: Routen-Übersicht fokussiert.");
            }, 2000);
        });

    } catch (error) {
        console.error("DEBUG: Fehler im Routing-Modul:", error);
    }
}