// map-poi-navigation.js
import { mylog } from './utilities.js';
import { LocationTrackingCoordinator } from './loc-tracking-co.js';
import { getAddressByLocationHERE } from './backend-geo.js';
import { L ,    mapState,} from './map-service.js';
import { getSafeViewport } from './map-gen-mgr.js';

export function addDirectionHint(text) {
    if (!text) return text;
    const isRoute = mapState?.isRouteActive;
    const iconHtml = isRoute
        ? ` <span style="display:inline-flex; align-items:center; justify-content:center; width:1.4em; height:1.4em; border-radius:50%; background:#ADE8F4; margin-left:8px; vertical-align:middle;">
               <i class="fas fa-times" style="color:#1a1a1a; font-size:0.75em;"></i>
           </span>`
        : ` <i class="fas fa-directions bs-directions-icon" style="color:#007AFF; margin-left:8px; font-size:1.4em !important;"></i>`;
    if (text.includes(')')) {
        return text.replace(')', ')' + iconHtml);
    }
    return text + iconHtml;
}

let routingControl = null;
let routeDecorator = null;

/**
 * Entfernt alle Routing-Elemente und Pfeile von der Karte.
 */
/*
export function demarcateRoute(map) {
    if (!map) return;
    if (routingControl) {
        try { map.removeControl(routingControl); } catch (e) { }
        routingControl = null;
    }
    if (routeDecorator) {
        try { map.removeLayer(routeDecorator); } catch (e) { }
        routeDecorator = null;
    }
    mylog("DEBUG: Route via demarcateRoute() entfernt.");
}
*/




let activeRouteGroup = null;
/**
 * Hilfsfunktion: Nutzt den direkten HERE-Import, 
 * um Punkte auf die Straße zu zwingen.
 */
async function getSnappedCoords(coords) {
    try {
        const addressItem = await getAddressByLocationHERE(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 Fußgänger-Route mit Pfeilen und intelligentem Zoom.
 */
/**
 * Zeichnet die Route, packt alles in eine Gruppe und zoomt nach 2 Sek. auf die Übersicht.
 * Nutzt den Router direkt, um Plugin-Konflikte zu vermeiden.
 */
export async function showPedestrianRoute(map, startCoords, destCoords) {
    mylog("DEBUG: showPedestrianRoute startet");
    
    // 1. Vorherige Route visuell entfernen
    demarcateRoute(map);

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

    // 3. Router-Instanz ohne Karten-Control erstellen
    const router = L.Routing.osrmv1({
        serviceUrl: 'https://routing.openstreetmap.de/routed-foot/route/v1',
        profile: 'foot'
    });

    return new Promise((resolve) => {
        // Direkte Abfrage der Koordinaten beim Router
        router.route([
            { latLng: L.latLng(snappedStart.lat, snappedStart.lng) },
            { latLng: L.latLng(snappedDest.lat, snappedDest.lng) }
        ], (err, routes) => {
            if (err || !routes || routes.length === 0) {
                console.error("DEBUG: Routing-Fehler oder keine Route gefunden:", err);
                resolve(false);
                return;
            }

            const coords = routes[0].coordinates;

            // 4. Grafische Layer manuell erstellen
            const routeLine = L.polyline(coords, { 
                color: '#007bff', 
                weight: 6, 
                opacity: 0.8 
            });

            const 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 }
                    })
                }]
            });

            // 5. In die zentrale Gruppe packen und anzeigen
            activeRouteGroup = L.layerGroup([routeLine, routeDecorator]).addTo(map);

            // 6. Verzögerter Zoom auf die Gesamtübersicht (2 Sek. Delay für Stein-Fokus)
            setTimeout(() => {
                if (!activeRouteGroup) return; // Falls zwischenzeitlich gelöscht wurde

                map.invalidateSize();
                const bounds = L.latLngBounds(coords);
                
                // Aktuelle User-Position für die Sichtbox einbeziehen
                const userPosArray = LocationTrackingCoordinator.getInstance().getUserPosition();
                if (userPosArray) {
                    bounds.extend(L.latLng(userPosArray[0], userPosArray[1]));
                }

                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: [20, dynamicTopPadding],
                    paddingBottomRight: [20, bsHeight + 20],
                    animate: true,
                    duration: 1.5,
                    maxZoom: 18
                });
                mylog("DEBUG: Route & User im Fokus.");
            }, 100);

            resolve(true);
        });
    });
}

export function demarcateRoute(map) {
    if (activeRouteGroup && map) {
        map.removeLayer(activeRouteGroup);
        activeRouteGroup = null;
    }
}