import matplotlib
matplotlib.use('TkAgg') # KEEP - Eviter erreur avc WSL
import osmnx as ox
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt

# Variables globales pour stocker la graphique et son état
fig = None
ax = None

def init_display():
    global fig, ax
    if fig is None and ax is None:
        plt.ion()  # Création du graphique par défaut s'il n'existe pas
        fig = plt.figure(figsize=(12, 8))
        ax = fig.add_subplot(111)
        plt.show(block=False)

def edge_in_list(edge, edge_list):
            if edge_list is None:
                return False
            for e in edge_list:
                if (e[0] == edge[0] and e[1] == edge[1]) or \
                    (e[0] == edge[1] and e[1] == edge[0]):
                    return True
            return False

def display_graph(G, place_name, reversed_legend, highlight_edges=None, current_edges=None, last_call=False, double_sens=False):
    """
    Affiche le graphe G avec la quantité de neige sur chaque arête et les habitations.
    Parameters:
        G : Le graphe à afficher.
        place_name : Nom du lieu
        reversed_legend : Si True, la légende est à droite
        highlight_edges : Liste des arêtes à mettre en surbrillance
        current_edges : Liste des arêtes visitées
        last_call : Si True, le graphique est affiché indéfiniment
    """
    global fig, ax
    
    # Initialisation du graphique si premier appel
    init_display()
    
    # Suppression du graphique actuel
    ax.clear()

    # Récupérer les quantités de neige sur les arêtes
    snow_quantities = []
    for u, v, k, data in G.edges(keys=True, data=True):
        snow_quantities.append(data.get('snow', 0))

    # Affecter une couleur à chaque arête en fonction de la quantité de neige et habitation
    legend_labels = ['<2.5cm', '<5cm', '<10cm', '+10cm']#, 'Habitations']
    legend_colors = ['red', 'deepskyblue', 'dodgerblue', 'navy']#, 'green']
    if double_sens:
        legend_labels= ["double sens", "une direction"]
        legend_colors= ['green', 'black']
    snow_colors = []
    if snow_quantities:
        for i, (u, v, k) in enumerate(G.edges(keys=True)):
            snow = snow_quantities[i]
            edge = (u, v, k)
            if double_sens:
                if any((v, u, k) == edge for edge in G.edges(keys=True)):
                    snow_colors.append('green')
                else:
                    snow_colors.append('black')
                continue

            # Déterminer la couleur de l'arête
            elif current_edges and edge in current_edges:
                # Si c'est la dernière arête visitée
                snow_colors.append("purple")
            elif last_call or (highlight_edges and edge_in_list(edge, highlight_edges)):
                # Si c'est une arête enneigée
                     if snow < 2.5:
                        snow_colors.append('red')
                     elif snow < 5:
                        snow_colors.append('deepskyblue')
                     elif snow < 10:
                        snow_colors.append('dodgerblue')
                     else:
                        snow_colors.append('navy')
            else:
                # Couleur normale basée sur la neige
                snow_colors.append("white")
    else:
        snow_colors = 'b'

    # Tracer toutes les arêtes sur le graphique
    ox.plot_graph(G, edge_color=snow_colors, edge_linewidth=2, ax=ax, show=False, close=False)
    
    # Configurer le titre et la légende
    ax.set_title('Graphe | ' + place_name)

    # Mise à jour de la légende & ajout des couleurs
    for i in range(len(legend_colors)):
        ax.plot([], [], color=legend_colors[i], linewidth=4, label=legend_labels[i])
    if highlight_edges:
        if current_edges:
            ax.plot([], [], color="purple", linewidth=4, label='Chemin actuel')
    if double_sens:
        ax.legend(title='Sens de circulation', loc='lower ' + ("right" if reversed_legend else "left"))
    else:
        ax.legend(title='Quantité de neige', loc='lower ' + ("right" if reversed_legend else "left"))

    # Sauvegarder l'image pour le debug
    plt.savefig('temp/debug_graph.png', dpi=300)

    # Mettre à jour l'affichage
    fig.canvas.draw()
    fig.canvas.flush_events()
    if not last_call:
        plt.pause(0.01)  # Délai pour pas tout exploser
    else:
        plt.pause(120) # Temporaire pour dernier affichage car destruction massive si pas de pause longue