classes.py

import bisect
import datetime
import math
from abc import ABC, abstractmethod
from typing import Dict, List, Tuple

import geopandas as gpd
import numpy as np

from fonction_calcul_trajet import infer as calcul_trajet

POMPE, PSE, VSAV = "POMPE", "PSE", "VSAV"
global compteur
compteur = 0


class Intervention:
    df: gpd.GeoDataFrame

    def __init__(
        self,
        proc,
        id,
        x: float,
        y: float,
        x_final: float,
        y_final: float,
        retour: datetime.timedelta,
        date: datetime.datetime,
        traitement: datetime.timedelta,
        trajet: datetime.timedelta,
        fem_mma: str,
        cstc: str,
        inter_id_original: str,
        cs_vhl: str | None = None,
        date_int: int | None = None,   # accepté via **vars() mais recalculé ci-dessous
        depart: datetime.timedelta = datetime.timedelta(),  # temps de départ (préparation)
    ) -> None:

        self.x = x
        self.y = y
        self.x_final = x_final
        self.y_final = y_final
        self.date = date
        self.traitement = traitement
        self.trajet = trajet
        self.fem_mma = fem_mma
        self.cstc = cstc
        self.cs_vhl = cs_vhl
        self.id = id
        self.proc = proc
        self.retour = retour
        self.inter_id_original = inter_id_original
        self.depart = depart  # temps de départ sanitisé

        # Conversion datetime → int pré-calculée une seule fois.
        # Évite ~N appels redondants à date_to_int() dans est_disponible().
        self.date_int: int = int(date.replace(tzinfo=datetime.timezone.utc).timestamp())

    @property
    def duree_sur_place(self):
        # Variables calculees
        return self.traitement


class Indisponibilite:
    def __init__(self, date: datetime.datetime, cs: str, time:datetime.timedelta):
        self.date: datetime.datetime = date
        self.cs: str = cs
        self.time: datetime.timedelta = time

        self.types: List[Tuple[str, int]] = [("VSAV", 1)]

class IndisponibiliteEngin:

    """
    On fait le choix ici de transformer les datetime en int depuis epoch pour permettre une recherche en O(log n) efficace
    """
    def __init__(self):
        self._indisponibilites: List[Tuple[int, int]] = []
        self.has_set_up_run = False

        self._starts: List[int] = []
        self._ends: List[int] = []

    @staticmethod
    def date_to_int(date: datetime.datetime) -> int:
        dt = date.replace(tzinfo=datetime.timezone.utc)
        return int(dt.timestamp())

    @staticmethod
    def timedelta_to_int(time: datetime.timedelta) -> int:
        return int(time.total_seconds())

    def add_indisponibilite(self, date: datetime.datetime, time: datetime.timedelta) -> None:
        date_in_int = self.date_to_int(date)
        self._indisponibilites.append((date_in_int, date_in_int + self.timedelta_to_int(time)))

    def set_up(self) -> None:
        raw = []

        for s, e in self._indisponibilites:
            assert s <= e # si ca donne erreur cest que le debut de l intervalle d indispo est apres la fin
            raw.append((s, e))

        raw.sort()

        merged: List[Tuple[int, int]] = []

        for a, b in raw:
            if not merged or a > merged[-1][1]:
                merged.append((a, b))
            else:
                merged[-1] = (merged[-1][0], max(merged[-1][1], b))

        self._starts = [a for a, _ in merged]
        self._ends = [b for _, b in merged]
        # TODO: verifier que les intervalles qui se touchent se fusionnent en un
        self.has_set_up_run = True

    def est_indisponible(self, date: datetime.datetime) -> bool:
        if not self.has_set_up_run:
            raise RuntimeError("Les indisponibilites n'ont pas ete chargees")

        date_int = self.date_to_int(date)

        i = bisect.bisect_right(self._starts, date_int) - 1

        return i >= 0 and date_int < self._ends[i]

    def est_indisponible_int(self, date_int: int) -> bool:
        """Version rapide : accepte un int pré-calculé (via Intervention.date_int)."""
        i = bisect.bisect_right(self._starts, date_int) - 1
        return i >= 0 and date_int < self._ends[i]




class Engin(ABC):
    df: gpd.GeoDataFrame

    def __init__(self, _id, cs, x_cs, y_cs) -> None:
        ## Données

        # Les _ indiquent variables privées (notation)
        self.id: float = _id
        self.x_cs: float = x_cs
        self.y_cs: float = y_cs
        self.cs: str = cs

        self.modularite = None

        self.indisponibilites: IndisponibiliteEngin = IndisponibiliteEngin()

        ## Fonctionnement
        self._en_caserne: datetime.datetime = (
            datetime.datetime.min
        )  # Date à partir de laquelle il est à la caserne
        self._plus_en_inter: datetime.datetime = (
            datetime.datetime.min
        )  # Date à partir de laquelle il a fini son intervention
        # Normalement, self._en_caserne > self._en_inter

        self._intervention: Intervention | None = None
        self._interventions: List[Intervention] = []
        self.temps_de_sorties_de_la_caserne: List[datetime.datetime] = []
        self.temps_de_retour_a_la_caserne: List[datetime.datetime] = []

        ## Variables pour économiser du temps de calcul
        self.X = 0
        self.Y = 0
        self.DEPART_DEPUIS_CASERNE = 1
        self.x_enregistres: Dict[datetime.datetime, Tuple[float, bool]] = {}
        self.y_enregistres: Dict[datetime.datetime, Tuple[float, bool]] = {}

    def reset_simulation_state(self) -> None:
        """Réinitialise l'état accumulé pendant une simulation,
        sans toucher aux données permanentes (id, cs, modularité)."""
        self._en_caserne = datetime.datetime.min
        self._plus_en_inter = datetime.datetime.min
        self._intervention = None
        self._interventions.clear()
        self.temps_de_sorties_de_la_caserne.clear()
        self.temps_de_retour_a_la_caserne.clear()
        self.x_enregistres.clear()
        self.y_enregistres.clear()
        # Réinitialiser les indisponibilités pour éviter l'accumulation
        # entre simulations successives
        self.indisponibilites = IndisponibiliteEngin()

    def is_in_caserne(self, date) -> bool:
        """
        Retourne vrai ssi l'engin est dans sa caserne
        :param date:
        :return:
        """
        return date >= self._en_caserne

    @property
    @abstractmethod
    def type_engin(self) -> str: ...

    def nombre_de_sorties(self):
        assert len(self.temps_de_sorties_de_la_caserne) == len(
            self.temps_de_retour_a_la_caserne
        )
        return len(self.temps_de_sorties_de_la_caserne)

    def derniere_intervention(self) -> Intervention:
        return self._intervention

    def est_disponible(self, intervention: Intervention) -> bool:
        date = intervention.date
        if self._plus_en_inter > date:
            return False
        return not self.indisponibilites.est_indisponible_int(intervention.date_int)

    def distance_euclidienne_au_carre(self, intervention: Intervention) -> float:
        """
        Renvoie la distance euclienne au carré (evite de faire la racine).
        Fast-path : si l'engin est en caserne, utilise directement x_cs/y_cs
        sans passer par x(date)/y(date) et leur dict-lookup.
        """
        x, y = intervention.x, intervention.y

        # ~80-90% des cas : l'engin est à sa caserne
        if intervention.date >= self._en_caserne:
            return (self.x_cs - x) ** 2 + (self.y_cs - y) ** 2

        # Cas rare : en route (retour caserne) — interpolation nécessaire
        return (self.x(intervention.date)[self.X] - x) ** 2 + (self.y(intervention.date)[self.Y] - y) ** 2

    @abstractmethod
    def set_modularite(self, engin) -> None: ...

    def x(self, date) -> Tuple[float, bool]:  # x, depart_depuis_caserne?
        if date in self.x_enregistres:
            return self.x_enregistres[date]

        if date >= self._en_caserne:  # S'il est à la caserne
            return self.x_cs, True

        if date <= self._plus_en_inter:
            assert self._intervention != None
            return self._intervention.x_final, False

        # self._pas_en_inter <= date <= self._en_caserne
        # il est en train de rentrer

        pourcentage = (date - self._plus_en_inter) / (
            self._en_caserne - self._plus_en_inter
        )

        assert self._intervention != None

        x_estimated = (
            1 - pourcentage
        ) * self._intervention.x_final + pourcentage * self.x_cs

        self.x_enregistres[date] = x_estimated, False
        return x_estimated, False  # Il part pas depuis sa caserne

    def y(self, date) -> Tuple[float, bool]:
        if date in self.y_enregistres:
            return self.y_enregistres[date]

        if date >= self._en_caserne:  # S'il est à la caserne
            return self.y_cs, True

        if date <= self._plus_en_inter:
            assert self._intervention != None
            return self._intervention.y_final, False

        # self._pas_en_inter <= date <= self._en_caserne
        # il est en train de rentrer

        pourcentage = (date - self._plus_en_inter) / (
            self._en_caserne - self._plus_en_inter
        )

        assert self._intervention != None

        y_estimated = (
            1 - pourcentage
        ) * self._intervention.y_final + pourcentage * self.y_cs

        self.y_enregistres[date] = y_estimated, False
        return y_estimated, False

    def temps_trajet(
        self, intervention: Intervention
    ) -> Tuple[datetime.timedelta, datetime.timedelta]:

        # Fast-path caserne (~80% des cas) : position connue sans dict lookup
        if intervention.date >= self._en_caserne:
            x_vhl, y_vhl = self.x_cs, self.y_cs
        else:
            x_vhl = self.x(intervention.date)[self.X]
            y_vhl = self.y(intervention.date)[self.Y]

        raw_aller = calcul_trajet(
                x_vhl,
                y_vhl,
                intervention.x,
                intervention.y,
                intervention.date,
                cs_vhl=self.cs or getattr(intervention, "cs_vhl", None)
        )
        # Sécurité : NaN dans les données CSV → timedelta(seconds=NaN) crash
        if math.isnan(raw_aller):
            raw_aller = 0.0
        temps_aller = datetime.timedelta(seconds=raw_aller)

        raw_retour = calcul_trajet(
                intervention.x_final,
                intervention.y_final,
                self.x_cs,
                self.y_cs,
                intervention.date + temps_aller + intervention.duree_sur_place,
                cs_vhl=None,
        )
        if math.isnan(raw_retour):
            raw_retour = 0.0
        temps_retour = datetime.timedelta(seconds=raw_retour)

        return temps_aller, temps_retour

    def attribuer_a(
        self, intervention: Intervention
    ) -> Tuple[datetime.timedelta, datetime.timedelta]:

        # TODO passer un PSE en VSAV quand son pair part.

        self._interventions.append(intervention)
        self._intervention = intervention
        temps_aller, temps_retour = self.temps_trajet(
            intervention
        )  # On récupère la position de l'engin au momement où il se fait appeler pour aller en intervention

        ### Premier bout de logique pour prendre les stats de l'engin
        remplacer = False
        if self._en_caserne <= intervention.date:
            self.temps_de_sorties_de_la_caserne.append(intervention.date)
        elif self._plus_en_inter <= intervention.date <= self._en_caserne:
            remplacer = True
        else:
            raise ValueError(
                "L'intervention qu'on essaie d'attribuer a lieu avant que l'engin ne finisse son intervention précédente"
            )
        ### ================================================

        self._plus_en_inter = (intervention.date + temps_aller + intervention.duree_sur_place)
        self._en_caserne = (intervention.date + temps_aller + intervention.duree_sur_place + temps_retour)

        # Deuxieme bout
        if remplacer:
            self.temps_de_retour_a_la_caserne[-1] = self._en_caserne
        else:
            self.temps_de_retour_a_la_caserne.append(self._en_caserne)
        # -===================

        return temps_aller, temps_retour


class POMPE_Engin(Engin):
    def __init__(self, _id, cs, x_cs, y_cs) -> None:
        super().__init__(_id, cs, x_cs, y_cs)

    def __repr__(self) -> str:
        return "POMPE(id={}, cs={})".format(self.id, self.cs)

    def set_modularite(self, engin: None | Engin) -> None:
        assert engin is None

    @property
    def type_engin(self):
        return "POMPE"


class VSAV_Engin(Engin):
    def __init__(self, _id, cs, x_cs, y_cs) -> None:
        super().__init__(_id, cs, x_cs, y_cs)

    def __repr__(self) -> str:
        return "VSAV(id={}, cs={})".format(self.id, self.cs)

    def set_modularite(self, engin: None | Engin) -> None:
        assert isinstance(engin, PSE_Engin)
        self.modularite = engin

    def est_disponible(self, intervention: Intervention) -> bool:
        date = intervention.date

        if self.indisponibilites.est_indisponible_int(intervention.date_int):
            return False

        if not self.modularite:  # si le VSAV est modulaire la variable contient son pair, sinon elle contient None
            return super().est_disponible(intervention)

        if date <= self._plus_en_inter:
            return False

        if plage_interdite_nuit(
            date
        ):  # Un véhicule VSAV couplé un PSE ne part jamais en intervention à ces heures-là
            return False

        # Là il faut voir si le PSE est en intervention:
        #   -> s il est a la caserne  on part
        #   -> s il est pas dans la caserne en tant que VSAV on part

        if self.modularite.is_in_caserne(date):
            # le PSE pair est a la caserne
            return True
        # il est pas a la caserne
        if self.modularite.is_VSAV(date):
            return True

    @property
    def type_engin(self):
        return "VSAV"


class PSE_Engin(Engin):
    def __init__(self, _id, cs, x_cs, y_cs) -> None:
        super().__init__(_id, cs, x_cs, y_cs)

    def __repr__(self) -> str:
        return "PSE(id={}, cs={})".format(self.id, self.cs)

    def set_modularite(self, engin: None | Engin) -> None:
        assert isinstance(engin, VSAV_Engin)
        self.modularite = engin

    def is_VSAV(self, date) -> bool:
        if not self.is_in_caserne(date):
            return (
                self.derniere_intervention().fem_mma == VSAV
            )  # Si jamais ca retourne un None cest parce quil faut revoir la facon dont on stocke les interventions, peut etre les passer a une liste ou creer une variable derniere intervention

        else:
            raise NotImplementedError(
                "On pose cette question uniquement si le PSE n'est pas dans la caserne"
            )

    def est_disponible(self, intervention: Intervention) -> bool:
        date = intervention.date
        if self.indisponibilites.est_indisponible_int(intervention.date_int):
            return False

        fem_mma = intervention.fem_mma
        code_rouge = intervention.proc == "R"
        if not self.modularite:
            return super().est_disponible(intervention)

        if date <= self._plus_en_inter:
            return False

        if fem_mma == POMPE:
            return self.modularite.is_in_caserne(date)

        if fem_mma == VSAV:
            if plage_interdite_nuit(date):
                return code_rouge
            else:
                return True

    @property
    def type_engin(self):
        return "PSE"


# Constantes pré-allouées pour plage_interdite_nuit (évite de recréer des objets à chaque appel)
_T00 = datetime.time(0, 0)
_T07 = datetime.time(7, 0)
_T08 = datetime.time(8, 0)
_T23 = datetime.time(23, 0)
_LUNDI, _JEUDI, _VENDREDI, _SAMEDI, _DIMANCHE = 0, 3, 4, 5, 6


def plage_interdite_nuit(date: datetime.datetime) -> bool:
    heure, jour = date.time(), date.weekday()

    # Lun-Ven : 0h-8h interdit
    if _LUNDI <= jour <= _VENDREDI:
        if _T00 <= heure <= _T08:
            return True

    # Dim ou Lun-Jeu : 23h-minuit interdit
    if jour == _DIMANCHE or _LUNDI <= jour <= _JEUDI:
        if heure >= _T23:          # FIX: avant c'était time(23) <= h <= time(0) → toujours False
            return True

    # Sam-Dim : 0h-7h interdit
    if _SAMEDI <= jour <= _DIMANCHE:
        if _T00 <= heure <= _T07:
            return True

    return False


class InterventionSimulee(Intervention):
    def __init__(
        self, engin: Engin, temps_aller: datetime.timedelta, temps_retour, **kwargs
    ) -> None:
        super().__init__(**kwargs)
        self.engin = engin
        self.aller = temps_aller
        self.retour = temps_retour
        # Pré-calcul du temps de réponse (départ + trajet) pour perf
        self._temps_reponse_s: float = self.depart.total_seconds() + self.aller.total_seconds()

    @property
    def temps_reponse_seconds(self) -> float:
        """Temps de réponse total = temps de départ + temps de trajet simulé."""
        return self._temps_reponse_s

    @classmethod
    def from_Intervention(
        cls,
        intervention: Intervention,
        engin: Engin,
        temps_aller: datetime.timedelta,
        temps_retour: datetime.timedelta,
    ):
        return cls(engin, temps_aller, temps_retour, **vars(intervention))

    def __repr__(self) -> str:
        # Supporte à la fois un vrai Engin et un EnginSnapshot (dataclass légère)
        type_name = getattr(self.engin, 'type_engin', self.engin.__class__.__name__)
        return "InterventionSimulee(id={}, engin_id={}, type_engin={}, date={})".format(
            self.id, self.engin.id, type_name, self.date
        )


class Secteur:
    df: gpd.GeoDataFrame

    def __init__(self, id, x, y):
        self.id = id
        self.x = x
        self.y = y

        self._engins: Dict[str, List[Engin]] = {
            "PSE": [],
            "POMPE": [],
            "VSAV": [],
            "POMPE+PSE": [],
            "VSAV+PSE": [],
        }  # {type: engin}

        self._engins_mis_indispos_dict_heure_final: Dict[datetime.datetime, Dict[str, List[Engin]]] = {}
        # {date1: {"VSAV": [Engin1, ...], "POMPE": [Engin2, ...]}, ... }
        # pour la clef date on associe tous les engins qui finissent d etre indispos a ce moment la

    def __repr__(self):
        return self.id

    def add_engin(self, engin: Engin):
        if engin.type_engin == "POMPE":
            self._engins["POMPE"].append(engin)
            self._engins["POMPE+PSE"].append(engin)
        if engin.type_engin == "VSAV":
            self._engins["VSAV"].append(engin)
            self._engins["VSAV+PSE"].append(engin)
        if engin.type_engin == "PSE":
            self._engins["PSE"].append(engin)
            self._engins["POMPE+PSE"].append(engin)
            self._engins["VSAV+PSE"].append(engin)

    def engins_for_type_intervention(self, fem_mma: str) -> List[Engin]:
        if self._engins == {}:
            raise Exception(
                "Le secteur est vide ou plus probablement les engins de ce secteur n'ont pas été importés."
            )
        elif fem_mma == "POMPE":
            return self._engins["POMPE+PSE"]
        elif fem_mma == "VSAV":
            return self._engins["VSAV+PSE"]
        raise Exception("Normalement ya que POMPE et VSAV")

    def engins_par_type(self, type: str) -> List[Engin]:
        match type:
            case "VSAV":    return self._engins["VSAV"]
            case "PSE":     return self._engins["PSE"]
            case "POMPE":   return self._engins["POMPE"]
        raise NotImplementedError()

    def ajouter_indisponibilite(self, indispo: Indisponibilite):
        # TODO utiliser self._engins_mis_indispos_dict_heure_final: Dict[datetime.datetime, Dict[str, List[Engin]]] pour
        # faire en sorte que deux indispos de une heure suivies correspondent au meme engin
        engins = set()
        for type, nombre in indispo.types:
            # Vérifie qu'il y a assez de véhicules disponibles
            disponibles = len(self._engins.get(type, []))
            if disponibles == 0:
                # Aucun véhicule de ce type dans le secteur, on ignore silencieusement
                continue
            
            # Ajuste le nombre si pas assez de véhicules
            nombre_a_indisposer = min(nombre, disponibles)
            
            try:
                for engin in np.random.choice(self._engins[type], size=nombre_a_indisposer, replace=False):
                    engins.add(engin)
            except ValueError as e:
                # En cas d'erreur, on ignore silencieusement plutôt que crasher
                print(f"Avertissement: Impossible de rendre indisponible {nombre} {type} dans le secteur (seulement {disponibles} disponibles)")
                continue

        for engin in engins:
            engin.indisponibilites.add_indisponibilite(indispo.date, indispo.time)