import requests
import json
import sys
import os
import subprocess

# Configuration
OVERPASS_API = "https://overpass-api.de/api/interpreter"

import argparse

def parse_arguments():
    parser = argparse.ArgumentParser(description="Récupère les données OpenStreetMap pour une ville")
    parser.add_argument("city_id", type=str, help="Identifiant OpenStreetMap de la ville ou nom de la ville", nargs="+")
    parser.add_argument("--no-compute", action="store_true", help="Ne pas exécuter compute.py après la récupération des données")
    parser.add_argument("--output", "-o", type=str, default="summary_results.json", help="Fichier de sortie pour les résultats de compute.py (défaut: summary_results.json)")
    parser.add_argument("--verbose", "-v", action="store_true", help="Afficher plus d'informations pendant l'exécution")
    return parser.parse_args()

args = parse_arguments()


city_overpass_id = args.city_id  # ID de la ville
from find_city_osm_id import search_city, get_relation_id

# Vérifier si l'argument est un nombre ou un nom de ville
if len(city_overpass_id) == 1 and city_overpass_id[0].isdigit():
    # Si c'est un nombre, l'utiliser directement comme ID
    city_overpass_id = int(city_overpass_id[0])
    if args.verbose:
        print(f"Utilisation de l'ID OpenStreetMap: {city_overpass_id}")
else:
    # Si c'est un nom de ville, faire une recherche
    city_name = " ".join(city_overpass_id)
    print(f"Recherche de la ville: {city_name}")
    
    # Effectuer la recherche
    results = search_city(city_name)
    
    if not results:
        print("Aucune ville trouvée")
        sys.exit(1)
        
    # Prendre le premier résultat
    first_result = results[0]
    osm_type = first_result.get('osm_type', '').capitalize()
    osm_id = first_result.get('osm_id', '')
    
    # Obtenir l'ID de relation si nécessaire
    if osm_type != 'Relation':
        print(f"L'élément trouvé est de type {osm_type}, recherche de l'ID de relation associé...")
        relation_id = get_relation_id(osm_type, osm_id)
        if relation_id:
            osm_id = relation_id
            print(f"ID de relation trouvé: {osm_id}")
        else:
            print("Aucune relation trouvée pour ce résultat. Utilisation de l'ID original.")
            
    city_overpass_id = osm_id
    print(f"ID OpenStreetMap utilisé: {city_overpass_id}")


# Convertir l'ID en format Overpass (ajouter 3600000000 pour les relations)
city_overpass_id = 3600000000 + city_overpass_id

def fetch_overpass_data():
    # Requête Overpass pour obtenir les routes et bâtiments de la ville
    overpass_query = f'''
    [out:json][timeout:25];area(id:{city_overpass_id})->.searchArea;(way["building"](area.searchArea);nwr["amenity"="bicycle_parking"](area.searchArea);nwr["amenity"="charging_station"](area.searchArea);nwr["man_made"="charge_point"](area.searchArea);nwr["amenity"="parking"](area.searchArea);way["highway"]["highway"~"residential|primary|secondary|tertiary|service|footway|unclassified|cycleway|roundabout|mini_roundabout"](area.searchArea););out geom;
    '''

    print("Récupération des données OpenStreetMap...")
    response = requests.post(OVERPASS_API, data={"data": overpass_query}, headers={"X-Requested-With": "overpass-turbo"})

    if response.status_code == 200:
        data = response.json()
        with open('overpass_data.json', 'w') as file:
            json.dump(data, file, ensure_ascii=False, indent=4)
        print("Données Overpass récupérées et sauvegardées dans overpass_data.json")
        return True
    else:
        print(f"Échec de la requête Overpass. Code d'erreur: {response.status_code}", response.text)
        return False

def run_compute():
    """
    Exécute le script compute.py pour analyser les données récupérées
    et générer les statistiques.
    
    Returns:
        bool: True si l'exécution a réussi, False sinon
    """
    try:
        print("\n--- Exécution de compute.py pour analyser les données ---")
        
        # Vérifier si compute.py existe
        if not os.path.exists("compute.py"):
            print("Erreur: Le script compute.py n'a pas été trouvé.")
            return False
        
        # Exécuter compute.py avec l'ID OpenStreetMap
        cmd = ["python", "compute.py", "--osm-id", str(city_overpass_id)]
        
        # Ajouter les options si nécessaire
        if args.verbose:
            print(f"Commande: {' '.join(cmd)}")
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        # Vérifier si la commande a réussi
        if result.returncode == 0:
            print("Analyse des données terminée avec succès.")
            
            # Vérifier si le fichier de résultats a été généré
            if os.path.exists("summary_results.json"):
                # Copier le fichier vers le chemin spécifié par l'utilisateur
                if args.output != "summary_results.json":
                    with open("summary_results.json", "r") as src_file:
                        with open(args.output, "w") as dest_file:
                            dest_file.write(src_file.read())
                    print(f"Résultats sauvegardés dans {args.output}")
                else:
                    print("Résultats sauvegardés dans summary_results.json")
                
                # Afficher un résumé des résultats
                with open("summary_results.json", "r") as file:
                    results = json.load(file)
                    print("\n--- Résumé des résultats ---")
                    print(f"Ville: {results.get('city_name', 'Non spécifié')}")
                    print(f"Nombre de bâtiments: {results.get('building_count', 0)}")
                    print(f"Longueur totale des routes: {results.get('longueur_route_km', 0):.2f} km")
                    print(f"Longueur des pistes cyclables: {results.get('road_cycleway_km', 0):.2f} km")
                    print(f"Nombre de places de parking: {results.get('car_parking_capacity_provided', 0)}")
                    print(f"Nombre de stations de recharge: {results.get('charging_stations', 0)}")
                
                return True
            else:
                print("Avertissement: Le fichier summary_results.json n'a pas été généré.")
                return False
        else:
            print(f"Erreur lors de l'exécution de compute.py (code {result.returncode}):")
            print(result.stderr)
            return False
    
    except Exception as e:
        print(f"Erreur lors de l'exécution de compute.py: {str(e)}")
        return False

if __name__ == "__main__":
    # Récupérer les données OpenStreetMap
    success = fetch_overpass_data()
    
    # Exécuter compute.py si la récupération a réussi et que l'option --no-compute n'est pas activée
    if success and not args.no_compute:
        run_compute()
        print("\nPour générer un rapport HTML à partir des résultats, exécutez:")
        print(f"python present.py {args.output}")
        
        print("\nPour générer une carte de la ville, exécutez:")
        print(f"python generate_city_map.py {city_overpass_id - 3600000000} -o carte_ville.html --folium")
    elif not success:
        print("Impossible d'exécuter compute.py car la récupération des données a échoué.")
    elif args.no_compute:
        print("\nL'option --no-compute est activée, compute.py n'a pas été exécuté.")
        print("Pour exécuter compute.py manuellement, utilisez la commande:")
        print("python compute.py")