import geopandas as gpd
import json
import sys
import folium
import requests
import re

def internet_disponivel():
    """Verifica se há conexão com a internet."""
    url = 'http://www.google.com/'
    timeout = 5
    try:
        _ = requests.get(url, timeout=timeout)
        return True
    except requests.ConnectionError:
        return False

# Argumentos e configurações iniciais
pathFiles = sys.argv[1]
fileName = sys.argv[2]
outputName = sys.argv[3]
outputMapName = sys.argv[4]
topico_gps = sys.argv[5]
pastaSaida = 'Python/Output/'

center = [0, 0]

# Verificar se há conexão com a internet
if internet_disponivel():
    m = folium.Map(location=center, zoom_start=12)
else:
    m = folium.Map(location=center, zoom_start=12, tiles=None)

# Salvar o mapa interativo em um arquivo HTML
m.save(pastaSaida + outputMapName)


# Caminho completo para o arquivo HTML gerado
caminho_completo_html = pastaSaida + outputMapName

# Abrir o arquivo HTML para leitura e escrita
with open(caminho_completo_html, 'r+') as arquivo_html:
    # Ler o conteúdo do arquivo
    conteudo_html = arquivo_html.read()
    
    # Usar expressão regular para encontrar o ID do mapa
    padrao_id_mapa = re.compile(r'id="map_(.*?)"')
    resultado_busca = padrao_id_mapa.search(conteudo_html)

    # Verificar se encontrou um ID de mapa
    if resultado_busca:
        id_mapa = 'map_' + resultado_busca.group(1)
    else:
        raise ValueError("Não foi possível encontrar o ID do mapa no arquivo HTML.")

    # Script JavaScript para adicionar ao HTML, com o ID do mapa substituído
    script_desenha_trajeotria = f"""
    <script>
        function trajeto_json_onEachFeature(feature, layer) {{
            layer.on({{
            }});
        }};
        var trajeto_json = L.geoJson(null, {{
                onEachFeature: trajeto_json_onEachFeature,
                style: function(feature) {{
                    return {{color: 'red'}};
                }}
            }}
        );
        function trajeto_json_add (data) {{
            trajeto_json.addData(data);
        }}
        trajeto_json_add({{"features": []}});

        trajeto_json.addTo({id_mapa});

        function adicionarGeometria(novaGeometria) {{
            trajeto_json.addData(novaGeometria);
        }}

        function saoCoordenadasIguais(coord1, coord2, tolerancia) {{
            return Math.abs(coord1[0] - coord2[0]) < tolerancia && Math.abs(coord1[1] - coord2[1]) < tolerancia;
        }}

        function adicionarCoordenada(idGeometria, novaCoordenada) {{
            var feature = trajeto_json.toGeoJSON().features.find(f => f.id === idGeometria);
            if (feature) {{
                var ultima = [0.0,0.0];
                if (feature.geometry.coordinates.length > 0) {{
                    ultima = feature.geometry.coordinates[feature.geometry.coordinates.length - 1];
                }}
                if (!saoCoordenadasIguais(ultima, novaCoordenada, 0.000001)) {{
                    feature.geometry.coordinates.push(novaCoordenada);
                    var ft = feature;
                    trajeto_json.clearLayers();
                    trajeto_json.addData(ft);
                }}
            
            }} else {{
                console.log("Feature com ID " + idGeometria + " não encontrada.");
            }}
        }}

        adicionarGeometria({{
            "type": "Feature",
            "geometry": {{
                "type": "LineString",
                "coordinates": []
            }},
            "properties": {{"Dist1": 0.0, "Dist2": 0.0, "Id": 1517, "Length": 21.724783283, "Name": "Projeto"}},
            "id": "Tj"
        }});

    </script>
    """
    
    # Script JavaScript para adicionar ao HTML, com o ID do mapa substituído
    script_atualizacao_marcador = f"""
    <script src="folium/mqtt.min.js"></script>
    <script src="folium/leaflet.rotatedMarker.js"></script>
    <script>
        let posicaoAtual = {{
            lat: 0, 
            long: 0
        }};
        
        var customIcon = L.icon({{
            iconUrl: 'folium/images/position_marker.png',
            iconSize: [32, 32], 
            iconAnchor: [16, 16], 
            popupAnchor: [0, -16] 
        }});
        
        var marcadorDinamico = L.marker([0, 0], {{
            icon: customIcon
        }}).addTo({id_mapa});
    
        // Conectar ao broker MQTT
        const client = mqtt.connect('ws://localhost:9001'); // Use wss para conexão segura

        // Quando conectado, inscreva-se no tópico desejado
        client.on('connect', function () {{
            console.log('Conectado ao broker MQTT');

            // Inscrever-se no tópico
            client.subscribe('{topico_gps}', function (err) {{
                if (!err) {{
                    console.log("Inscrição bem-sucedida no tópico");
                }} else {{
                    console.error("Falha na inscrição do tópico", err);
                }}
            }});
        }});

        // Lidar com mensagens recebidas para o tópico inscrito
        client.on('message', function (topic, message) {{
            // A mensagem é um Buffer, converta para string ou objeto conforme necessário
            //console.log(`Mensagem recebida no tópico '${{topic}}': ${{message.toString()}}`);
            var dados = JSON.parse(message);
            var novaLatitude = dados.latitude;
            var novaLongitude = dados.longitude;
            var novaPosicao = [novaLatitude, novaLongitude];
            marcadorDinamico.setLatLng(novaPosicao);
            
            // Calcular angulo de rotacao
            var angulo = calcularOrientacao(novaPosicao[0], novaPosicao[1], posicaoAtual.lat, posicaoAtual.long);

            posicaoAtual.lat = novaPosicao[0];
            posicaoAtual.long = novaPosicao[1];

            // Rotacionar o marcador para o angulo calculado
            marcadorDinamico.setRotationAngle(angulo);
            
            adicionarCoordenada("Tj", [novaLongitude, novaLatitude]);
            {id_mapa}.setView(novaPosicao, {id_mapa}.getZoom());
        }});
        
        function calcularOrientacao(P1latitude, P1longitude, P2latitude, P2longitude) {{
            // Converter latitudes e longitudes de graus para radianos
            const latA = P1latitude * (Math.PI / 180.0);
            const lonA = P1longitude * (Math.PI / 180.0);
            const latB = P2latitude * (Math.PI / 180.0);
            const lonB = P2longitude * (Math.PI / 180.0);

            // Calcular a diferença de longitude
            const deltaLon = lonB - lonA;

            // Calcular a direção
            const y = Math.sin(deltaLon) * Math.cos(latB);
            const x = Math.cos(latA) * Math.sin(latB) - Math.sin(latA) * Math.cos(latB) * Math.cos(deltaLon);
            const direcaoRadianos = Math.atan2(y, x);

            // Converter a direção de radianos para graus
            let direcaoGraus = direcaoRadianos * (180.0 / Math.PI);

            // Normalizar a direção para que esteja no intervalo de 0 a 360 graus
            direcaoGraus = (direcaoGraus + 360) % 360;

            return direcaoGraus;
        }}
        
    </script>
    """

# Inserir o script no conteúdo HTML
conteudo_atualizado = conteudo_html.replace('</html>', script_desenha_trajeotria + script_atualizacao_marcador + '</html>')

# Agora, reabrir o arquivo para escrita e sobrescrever o conteúdo com a versão atualizada
with open(caminho_completo_html, 'w') as arquivo_html:
    arquivo_html.write(conteudo_atualizado)