{% extends 'base.html.twig' %}

{% block title %}{{ 'display.stats'|trans }}- {{ stats.zone }}
            {{ stats.name }} {% endblock %}

{% block stylesheets %}
    {{ parent() }}
    <link href='{{ asset('js/maplibre/maplibre-gl.css') }}' rel='stylesheet' />
    <style>
        .completion-circle {
            fill-opacity: 0.6;
            stroke: #fff;
            stroke-width: 3;
        }
        #distribution_completion {
            height: 300px;
            margin: 20px 0;
        }
    </style>
{% endblock %}

{% block body %}
<div class="container">
    <div class="mt-4 p-4">
        <div class="row">
            <div class="col-md-6 col-12">
                <h1 class="title">{{ 'display.stats'|trans }} - {{ stats.zone }}
                    {{ stats.name }} - {{ stats.completionPercent }}% complété</h1> 
            </div>
            <div class="col-md-6 col-12">
                <a href="{{ path('app_admin_labourer', {'zip_code': stats.zone}) }}" class="btn btn-primary" id="labourer">Labourer les mises à jour</a>
                <button id="openInJOSM" class="btn btn-secondary ms-2">
                    <i class="bi bi-map"></i> Ouvrir dans JOSM
                </button>
            </div>
        </div>
        <div class="row">
            <div class="col-md-3 col-12">
                <span class="badge {% if stats.getCompletionPercent() > 85 %}bg-success{% else %}bg-warning{% endif %}">
                {{ stats.getCompletionPercent() }} %
                </span>
                 complété sur les critères donnés.
                </div>
                <div class="col-md-3 col-12">
                <span class="badge bg-primary">
                <i class="bi bi-building"></i> {{ stats.places | length}} 
                </span>commerces dans la zone.
                </div>
                <div class="col-md-3 col-12">
                <span class="badge bg-primary">
                <i class="bi bi-clock"></i> {{ stats.getAvecHoraires() }} 
                </span>
                commerces avec horaires.
                </div>
                <div class="col-md-3 col-12">
                    <span class="badge bg-primary">
                    <i class="bi bi-map"></i> {{ stats.getAvecAdresse() }} 
                    </span>
                    commerces avec adresse.
                </div>
                <div class="col-md-3 col-12">
                    <span class="badge bg-primary">
                    <i class="bi bi-globe"></i> {{ stats.getAvecSite() }} 
                    </span>
                    commerces avec site web renseigné.
                </div>
                <div class="col-md-3 col-12">
                    <span class="badge bg-primary">
                    <i class="bi bi-arrow-up-right"></i>
                    {{ stats.getAvecAccessibilite() }} 
                    </span>
                    commerces avec accessibilité PMR renseignée.
                </div>
                <div class="col-md-3 col-12">
                    <span class="badge bg-primary">
                    <i class="bi bi-chat-dots"></i> {{ stats.getAvecNote() }} 
                    </span>
                    commerces avec note renseignée.
                </div>
            </div> 
   
   <div id="maploader">
        <div class="spinner-border" role="status">
            <i class="bi bi-load bi-spin"></i>
            <span class="visually-hidden">Chargement de la carte...</span>
        </div>
   </div>
   <div class="d-flex justify-content-end mb-2">
        <div class="btn-group" role="group">
            <button type="button" class="btn btn-outline-primary" id="circleMarkersBtn">
                <i class="bi bi-circle"></i> Cercles
            </button>
            <button type="button" class="btn btn-outline-primary active" id="dropMarkersBtn">
                <i class="bi bi-geo-alt"></i> Gouttes
            </button>
        </div>
   </div>
        <div id="map" class="mt-4" style="height: 400px;"></div>
        <div id="attribution">
            <a href="https://www.openstreetmap.org/copyright">Données OpenStreetMap</a>
        </div>
    </div>
    <div class="card mt-4">


    
    <div id="distribution_completion" class="mt-4 mb-4"></div>


    <div class="row">
        <div class="col-md-6 col-12">
            <h1 class="card-title p-4">Tableau des {{ stats.places |length }} lieux</h1>
        </div>
        <div class="col-md-6 col-12">
            <a class="btn btn-primary pull-right mt-4" href="{{ path('app_admin_export_csv', {'zip_code': stats.zone}) }}" class="btn btn-primary">
            <i class="bi bi-filetype-csv"></i>
            Exporter en CSV
            </a>
        </div>
    </div>
        <table class="table table-bordered table-striped table-hover table-responsive js-sort-table">
            {% include 'admin/stats/table-head.html.twig' %}
            <tbody>
                {% for commerce in stats.places %}
                    {% include 'admin/stats/row.html.twig' %}
                {% endfor %}
            </tbody>
        </table>
    </div>

    <h2>requête overpass</h2>
    <pre class="p-4 bg-light">
    {{query_places|raw}}
    </pre>
     </div>
</div>

<!-- Bouton caché pour JOSM -->
<a id="josmButton" style="display: none;"></a>

<script src='{{ asset('js/maplibre/maplibre-gl.js') }}'></script>
<script src='{{ asset('js/turf/turf.min.js') }}'></script>
<script src="{{ asset('js/chartjs/chart.umd.js') }}"></script>
<script src="{{ asset('js/app.js') }}"></script>
<script>
    const request = `{{query_places|raw}}`; 
    const zip_code = `{{stats.zone}}`;
    let mapElements = [];
    let map_is_loaded = false;
    let features = [];
    let maplibre;
    let map;
    let overpassData = {}; // Stockage des données Overpass
    let currentMarkerType = 'drop'; // Type de marqueur actuel
    let dropMarkers = []; // Tableau pour stocker les marqueurs en goutte
    let contextMenu = null; // Menu contextuel

    function getCompletionColor(completion) {
        if (completion === undefined || completion === null) {
            return '#808080'; // Gris pour pas d'information
        }
        // Convertir le pourcentage en couleur verte (0% = blanc, 100% = vert foncé)
        const intensity = Math.floor((completion / 100) * 255);
        return `rgb(0, ${intensity}, 0)`;
    }

    function calculateCompletion(element) {
        let completionCount = 0;
        let totalFields = 0;
        
        const fieldsToCheck = [
            'name',
            'contact:street', 
            'contact:housenumber',
            'opening_hours',
            'contact:website',
            'contact:phone',
            'wheelchair'
        ];

        fieldsToCheck.forEach(field => {
            totalFields++;
            if (element.tags && element.tags[field]) {
                completionCount++;
            }
        });

        return (completionCount / totalFields) * 100;
    }

    function createPopupContent(element) {
        let content = `
            <div class="mb-2">
                <a class="btn btn-primary" href="/admin/placeType/${element.type}/${element.id}">
                    <i class="bi bi-pencil"></i> ${element.tags?.name || 'Sans nom'}
                </a>
                <a class="btn btn-secondary ms-2" href="https://openstreetmap.org/${element.type}/${element.id}">
                    <i class="bi bi-map"></i> OSM
                </a>
            </div>
        `;
        
        content += '<table class="table table-sm">';
        
        // Ajouter tous les tags
        if (element.tags) {
            for (const tag in element.tags) {
                content += `<tr><td><strong>${tag}</strong></td><td>${element.tags[tag]}</td></tr>`;
            }
        }

        content += '</table>';
        return content;
    }

    function calculateCompletionDistribution(elements) {
        // Créer des buckets de 10% (0-10%, 10-20%, etc.)
        const buckets = Array(11).fill(0);
        
        elements.forEach(element => {
            const completion = calculateCompletion(element);
            const bucketIndex = Math.floor(completion / 10);
            buckets[bucketIndex]++;
        });

        return buckets;
    }

    function createCompletionChart(elements) {
        const distribution = calculateCompletionDistribution(elements);
        const ctx = document.createElement('canvas');
        document.getElementById('distribution_completion').appendChild(ctx);

        new Chart(ctx, {
            type: 'line',
            data: {
                labels: ['0-10%', '10-20%', '20-30%', '30-40%', '40-50%', '50-60%', '60-70%', '70-80%', '80-90%', '90-100%'],
                datasets: [{
                    label: 'Nombre de commerces',
                    data: distribution,
                    backgroundColor: 'rgba(0, 128, 0, 0.1)',
                    borderColor: 'rgba(0, 128, 0, 1)',
                    borderWidth: 2,
                    tension: 0.4,
                    fill: true,
                    pointBackgroundColor: 'rgba(0, 128, 0, 1)',
                    pointBorderColor: '#fff',
                    pointBorderWidth: 2,
                    pointRadius: 4,
                    pointHoverRadius: 6
                }]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                scales: {
                    y: {
                        beginAtZero: true,
                        title: {
                            display: true,
                            text: 'Nombre de commerces'
                        }
                    },
                    x: {
                        title: {
                            display: true,
                            text: 'Taux de complétion'
                        }
                    }
                },
                plugins: {
                    title: {
                        display: true,
                        text: 'Distribution du taux de complétion des commerces'
                    }
                }
            }
        });
    }

    function createJOSMQuery(elements){
        let query = '';
        elements.forEach(element => {
            query += `${element.type}${element.id},`;
        });
        // Enlever la virgule finale
        query = query.replace(/,$/, '');
        console.log('josm query', query);
        return query;
    }

    let josm_elements = [];
    features = []; 

    async function loadPlaces(map) {
        try {
            const request = `{{query_places |raw}}`;
            const response = await fetch('https://overpass-api.de/api/interpreter', {
                method: 'POST',
                body: request
            });
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            const data = await response.json();
            console.log('Données reçues:', data);

            // Stocker les données Overpass
            data.elements.forEach(element => {
                overpassData[element.id] = element;
            });

            // Mettre à jour les marqueurs
            features = [];
            josm_elements = [];
            data.elements.forEach(element => {
                const lat = element.lat || (element.center && element.center.lat);
                const lon = element.lon || (element.center && element.center.lon);
                if (lat && lon) {
                    const completion = calculateCompletion(element);
                     
                    const feature = {
                        id: `marker-${element.id}`,
                        type: 'Feature',
                        properties: {
                            id: element.id,
                            name: element.tags?.name || 'Sans nom',
                            completion: completion,
                            center: [lon, lat]
                        },
                        geometry: {
                            type: 'Point',
                            coordinates: [lon, lat]
                        }
                    };
                    features.push(feature);
                    josm_elements.push(element);
                }
            });

            // Afficher les marqueurs selon le type actuel
            updateMarkers();

            // Ajuster la vue pour inclure tous les points
            const points = features.map(f => f.properties.center);
            if (points.length > 0) {
                const bounds = new maplibregl.LngLatBounds(points[0], points[0]);
                points.forEach(point => bounds.extend(point));
                
                if (bounds?._sw && bounds?._ne) {
                    map.fitBounds(bounds, {
                        padding: 50,
                        maxZoom: 15
                    });
                } else {
                    console.warn('Bounds invalides, utilisation des coordonnées par défaut');
                }
            }
 
            createCompletionChart(data.elements);

            // Cacher le spinner une fois le chargement terminé
            document.getElementById('maploader').style.display = 'none';

        } catch (error) {
            console.error('Erreur lors du chargement des lieux:', error);
        }
    }

    function updateMarkers() {
        // Supprimer tous les marqueurs existants
        features.forEach(feature => {
            const layerId = `marker-${feature.properties.id}`;
            // Supprimer d'abord la couche
            if (map.getLayer(layerId)) {
                map.removeLayer(layerId);
            }
            // Puis supprimer la source
            if (map.getSource(layerId)) {
                map.removeSource(layerId);
            }
        });

        // Supprimer tous les marqueurs en goutte existants
        dropMarkers.forEach(marker => marker.remove());
        dropMarkers = [];

        if (currentMarkerType === 'circle') {
            // Afficher les cercles
            features.forEach(feature => {
                const layerId = `marker-${feature.properties.id}`;
                const circle = turf.circle(
                    feature.properties.center,
                    5/1000,
                    { steps: 64, units: 'kilometers' }
                );

                map.addSource(layerId, {
                    'type': 'geojson',
                    'data': circle
                });

                map.addLayer({
                    'id': layerId,
                    'type': 'fill',
                    'source': layerId,
                    'paint': {
                        'fill-color': getCompletionColor(feature.properties.completion),
                        'fill-opacity': 0.7
                    }
                });
            });

            // Ajouter les popups sur les cercles
            map.on('click', function(e) {
                const clickedFeatures = map.queryRenderedFeatures(e.point, {
                    layers: features.map(f => `marker-${f.properties.id}`)
                });

                if (clickedFeatures.length > 0) {
                    const feature = clickedFeatures[0];
                    const elementId = feature.layer.id.replace('marker-', '');
                    const element = overpassData[elementId];
                    
                    if (element) {
                        // Créer le contenu de la popup
                        const popupContent = createPopupContent(element);

                        new maplibregl.Popup()
                            .setLngLat(e.lngLat)
                            .setHTML(popupContent)
                            .addTo(map);
                    }
                }
            });
        } else {
            // Afficher les marqueurs en goutte
            features.forEach(feature => {
                const element = overpassData[feature.properties.id];
                const popupContent = element ? createPopupContent(element) : `<h1>${feature.properties.name}</h1>`;
                
                const marker = new maplibregl.Marker({
                    color: getCompletionColor(feature.properties.completion)
                })
                .setLngLat(feature.properties.center)
                .setPopup(new maplibregl.Popup({ offset: 25 })
                    .setHTML(popupContent))
                .addTo(map);
                dropMarkers.push(marker);
            });
        }
    }

    function draw_circle_containing_all_features(map) {
        if (features.length === 0) return;

        // Calculer le centre à partir de toutes les features
        const center = features.reduce((acc, feature) => {
            return [
                acc[0] + feature.properties.center[0],
                acc[1] + feature.properties.center[1]
            ];
        }, [0, 0]).map(coord => coord / features.length);

        // Calculer le rayon nécessaire pour couvrir tous les points
        const radius = features.reduce((maxRadius, feature) => {
            const distance = turf.distance(
                center,
                feature.properties.center,
                { units: 'kilometers' }
            );
            return Math.max(maxRadius, distance);
        }, 0);

        const circle = turf.circle(center, radius, { steps: 64, units: 'kilometers' });
        map.addSource('circle', { type: 'geojson', data: circle });
        map.addLayer({ 
            id: 'circle', 
            type: 'fill', 
            source: 'circle', 
            paint: { 
                'fill-color': 'blue', 
                'fill-opacity': 0.25 
            } 
        });

        // Ajouter un marqueur au centre du cercle
        new maplibregl.Marker()
            .setLngLat(center)
            .addTo(map);
    }

    function updateCircles(map) {
        if (!map) return;

        const zoom = map.getZoom();
        // Ajuster la taille de base en fonction du zoom
        // Plus le zoom est faible (loin), plus le rayon est grand
        const baseRadius = Math.min(100, 200 / Math.pow(1.2, zoom));

        features.forEach(feature => {
            const source = map.getSource(feature.id);
            if (!source) return;

            const completion = feature.properties.completion;
            const radius = baseRadius * (1 + (completion / 100));
            
            // Mettre à jour le rayon du cercle
            const circle = turf.circle(
                feature.properties.center,
                0.5* radius / 1000, // Convertir en kilomètres
                { steps: 64, units: 'kilometers' }
            );
            
            // Mettre à jour la source avec le nouveau cercle
            source.setData(circle);

            // Mettre à jour la couleur du cercle
            const layer = map.getLayer(feature.id);
            if (layer) {
                map.setPaintProperty(feature.id, 'fill-color', getCompletionColor(completion));
            }
        });
    }

    function openJOSMQuery(map, query) {
        const bounds = map.getBounds();
 
        const josmUrl = `http://localhost:8111/load_object?` +
   
            `objects=${query}`;

        // Créer un élément <a> temporaire
        const tempLink = document.createElement('a');
        tempLink.style.display = 'none';
        document.body.appendChild(tempLink);

        console.log('josmUrl', josmUrl);
        
        tempLink.href = josmUrl;
        tempLink.click();
        document.body.removeChild(tempLink);
    }

    function openInJOSM() {
        if (josm_elements.length === 0) {
            alert('Veuillez sélectionner au moins un élément');
            return;
        }
        const query = createJOSMQuery(josm_elements);
        console.log('map', map);
        openJOSMQuery(map, query);
    }

    document.addEventListener('DOMContentLoaded', function() {
        console.log('DOMContentLoaded');

        maplibre = new maplibregl.Map({
            container: 'map',
            style: 'https://api.maptiler.com/maps/streets-v2/style.json?key={{ maptiler_token }}',
            center: [2.3488, 48.8534],
            zoom: 12
        });
        map = maplibre;

        // Créer le menu contextuel
        contextMenu = document.createElement('div');
        contextMenu.id = 'context-menu';
        contextMenu.style.display = 'none';
        contextMenu.style.position = 'absolute';
        contextMenu.style.backgroundColor = 'white';
        contextMenu.style.border = '1px solid #ccc';
        contextMenu.style.padding = '10px';
        contextMenu.style.borderRadius = '4px';
        contextMenu.style.boxShadow = '0 2px 4px rgba(0,0,0,0.2)';
        contextMenu.style.zIndex = '1000';
        document.body.appendChild(contextMenu);

        // Gestionnaire de clic droit sur la carte
        map.on('contextmenu', async function(e) {
            e.preventDefault();
            
            // Vérifier si le clic est sur un marqueur
            const clickedFeatures = map.queryRenderedFeatures(e.point, {
                layers: features.map(f => `marker-${f.properties.id}`)
            });

            if (clickedFeatures.length > 0) {
                return; // Ne rien faire si on clique sur un marqueur
            }

            // Afficher le menu contextuel
            contextMenu.style.display = 'block';
            
            // Obtenir la position de la carte dans la page
            const mapContainer = map.getContainer();
            const mapRect = mapContainer.getBoundingClientRect();
            
            // Calculer la position relative au conteneur de la carte
            const x = e.point.x + mapRect.left;
            const y = e.point.y + mapRect.top;
            
            // Positionner le menu contextuel
            contextMenu.style.left = `${x}px`;
            contextMenu.style.top = `${y}px`;
            
            contextMenu.innerHTML = '<div class="spinner-border spinner-border-sm" role="status"></div> Recherche du code INSEE...';

            try {
                // Récupérer les coordonnées du clic
                const { lng, lat } = e.lngLat;

                // Appeler l'API pour obtenir le code INSEE
                const response = await fetch(`https://api-adresse.data.gouv.fr/reverse/?lon=${lng}&lat=${lat}`);
                const data = await response.json();

                if (data.features && data.features.length > 0) {
                    const feature = data.features[0];
                    const city = feature.properties.city;
                    const inseeCode = feature.properties.citycode;

                    contextMenu.innerHTML = `
                        <div class="mb-2">
                            <strong>Ville :</strong> ${city}<br>
                            <strong>Code INSEE :</strong> ${inseeCode}
                        </div>
                        <a href="/admin/labourer/${inseeCode}" class="btn btn-primary btn-sm">
                            <i class="bi bi-tractor"></i> Labourer cette zone
                        </a>
                    `;
                } else {
                    contextMenu.innerHTML = 'Aucune information trouvée pour cette position';
                }
            } catch (error) {
                console.error('Erreur lors de la recherche du code INSEE:', error);
                contextMenu.innerHTML = 'Erreur lors de la recherche du code INSEE';
            }
        });

        // Fermer le menu contextuel lors d'un clic ailleurs
        document.addEventListener('click', function(e) {
            if (contextMenu && !contextMenu.contains(e.target)) {
                contextMenu.style.display = 'none';
            }
        });

        // Gestionnaires d'événements pour les boutons de type de marqueur
        document.getElementById('circleMarkersBtn').addEventListener('click', function() {
            currentMarkerType = 'circle';
            this.classList.add('active');
            document.getElementById('dropMarkersBtn').classList.remove('active');
            updateMarkers();
        });

        document.getElementById('dropMarkersBtn').addEventListener('click', function() {
            currentMarkerType = 'drop';
            this.classList.add('active');
            document.getElementById('circleMarkersBtn').classList.remove('active');
            updateMarkers();
        });

        document.getElementById('openInJOSM').addEventListener('click', openInJOSM);

        // Attendre que la carte soit chargée avant d'ajouter les écouteurs d'événements
        map.on('load', function() {
            console.log('Map loaded');
            map_is_loaded = true;
            // Changer le curseur au survol des marqueurs
            map.on('mouseenter', function(e) {
                const hoveredFeatures = map.queryRenderedFeatures(e.point, {
                    layers: features.map(f => `marker-${f.properties.id}`)
                });
                if (hoveredFeatures.length > 0) {
                    map.getCanvas().style.cursor = 'pointer';
                }
            });

            map.on('mouseleave', function(e) {
                const hoveredFeatures = map.queryRenderedFeatures(e.point, {
                    layers: features.map(f => `marker-${f.properties.id}`)
                });
                if (hoveredFeatures.length === 0) {
                    map.getCanvas().style.cursor = '';
                }
            });

            // Charger les lieux
            loadPlaces(map);

            draw_circle_containing_all_features(map);
        });

        sortTable();
    });
</script>
{% endblock %}