# FICHIER DEPRECATED : Ce fichier n'est plus utilisé.

import random
import parameters as params


def place_snow(G):
    """
    Place de la neige sur les egdes du graphe
    Parameters:
        G (voir quel type on veut utiliser): le graphe des routes
    Returns:
        None: le graphe est modifié en place
    """
    # WARNING: je ne suis pas sûr de cette manière de faire qui me semble boffe, je pense qu'une manière plus random (mais plus sale/lente) serait de shuffle la liste d'edges. Le soucis avec la méthode actuelle c'est que si G.egdes(...) ordonne les arcs/arêtes d'une manière prédéfinie, alors le début/la fin de la liste sera composé de beacoup/peu de neige, ce qui n'est pas uniforme
    edges = list(G.edges(keys=True, data=True))
    n = len(edges)
    random.shuffle(edges)
    amount_to_cover = int(params.SNOW_PERCENTAGE * n)
    quantity: float = 0

    for u, v, k, data in edges:
        if (amount_to_cover == 0):  # we should place > 2.5cm snow
            quantity = random.uniform(
                params.SNOW_THRESHOLD + 0.01, params.SNOW_MAX)
        else:  # we do not care
            quantity = random.uniform(params.SNOW_MIN, params.SNOW_MAX)

        if (quantity >= params.SNOW_THRESHOLD):
            amount_to_cover -= 1

        data['snow'] = quantity


def place_snow_v2(G):
    """
    Place de la neige sur les egdes du graphe, moins opti que la v1 mais gère les cas (u,v) et (v,u) (plus réaliste)
    Parameters:
        G (voir quel type on veut utiliser): le graphe des routes
    Returns:
        (int, int): (nb_edges_oriented, nb_edges_nonoriented), renvoie le nombre d'edges qui ont plus de 2.5 cm de neige (utile pour débug les drônes)
    """
    edges = list(G.edges(keys=True, data=True))
    n = len(edges)
    random.shuffle(edges)
    amount_to_cover = int(params.SNOW_PERCENTAGE * n)
    TO_DELETE = amount_to_cover  # pls delete once testing is finished
    quantity: float = 0

    res_oriented = 0
    res_unoriented = 0
    visited = {}  # (u,v) => quantity

    for u, v, k, data in edges:
        if (v, u) in visited:
            data['snow'] = visited[(v, u)]
            amount_to_cover -= 1

            res_unoriented += 1
            # we do not increment res_oriented since (u,v) and (v,u) are the same thing
            # => check to_undirected but should be good
        elif (u, v) in visited:
            data['snow'] = visited[(u, v)]
            # WARNING: this implementation might not be the most accurate/best

            amount_to_cover -= 1
            # TODO : wtf do I do with the counters ... technically nothing ?
        else:
            if (amount_to_cover <= 0):  # we should place > 2.5cm snow
                quantity = random.uniform(
                    params.SNOW_THRESHOLD + 0.01, params.SNOW_MAX)
            else:  # we do not care
                quantity = random.uniform(params.SNOW_MIN, params.SNOW_MAX)

            if (quantity >= params.SNOW_THRESHOLD):
                amount_to_cover -= 1

            data['snow'] = quantity
            visited[(u, v)] = quantity

            res_unoriented += 1
            res_oriented += 1

    # assert (TO_DELETE == res_unoriented) => need to check how to handle duplicate of the form (u,v)
    return res_oriented, res_unoriented