main.py

import datetime
import time
from dataclasses import dataclass, field
from typing import Dict, List

import filters
from classes import Engin, Intervention, InterventionSimulee, Secteur
from data import get_data
from statistiques import combien_de_fois_on_envoie_un_vhl_diff, print_statistiques
from fonction_calcul_trajet import reset_stats as reset_trajet_stats


# -----------------------------------------------------------------------------
# SimulationResult — encapsule tout l'état d'une simulation
# -----------------------------------------------------------------------------

@dataclass
class SimulationResult:
    """Résultat complet d'une simulation. Remplace les anciennes variables globales."""
    interventions_simulees: List[InterventionSimulee] = field(default_factory=list)
    simulation_processing_time: float = 0.0
    cs_match_count: int = 0
    cs_total_count: int = 0
    cs_mismatch_details: List[Dict] = field(default_factory=list)

    def clear(self):
        """Réinitialise tous les résultats."""
        self.interventions_simulees.clear()
        self.simulation_processing_time = 0.0
        self.cs_match_count = 0
        self.cs_total_count = 0
        self.cs_mismatch_details.clear()


# Instance globale unique — conserve la rétro-compatibilité avec le code
# existant qui accède à  main_module.interventions_simulees  etc.
_last_result = SimulationResult()

# Propriétés de rétro-compatibilité au niveau du module
interventions_simulees = _last_result.interventions_simulees
simulation_processing_time: float = 0.0
cs_match_count: int = 0
cs_total_count: int = 0
cs_mismatch_details: List[Dict] = []


def _sync_globals_from_result(result: SimulationResult):
    """Synchronise les anciennes variables globales depuis un SimulationResult."""
    global interventions_simulees, simulation_processing_time
    global cs_match_count, cs_total_count, cs_mismatch_details, _last_result
    _last_result = result
    interventions_simulees = result.interventions_simulees
    simulation_processing_time = result.simulation_processing_time
    cs_match_count = result.cs_match_count
    cs_total_count = result.cs_total_count
    cs_mismatch_details = result.cs_mismatch_details


# -----------------------------------------------------------------------------
# MAIN
# -----------------------------------------------------------------------------


# Configuration
LIMITE_INTERVENTIONS = None  # Limite pour tests rapides (None = toutes)

def main(progress_callback=None, interventions=None, indisponibilites=None, engins=None, skip_cstc_priority=False):
    """
    Lance la simulation et retourne (interventions, engins, result).
    
    Le SimulationResult est aussi synchronisé vers les variables globales du module
    pour la rétro-compatibilité (main_module.interventions_simulees, etc.).
    """
    result = SimulationResult()

    # Si interventions/indisponibilités non fournies, les charger
    if interventions is None or indisponibilites is None:
        interventions_tmp, secteurs, engins_tmp, indisponibilites_tmp = get_data()
        if interventions is None:
            interventions = interventions_tmp
        if indisponibilites is None:
            indisponibilites = indisponibilites_tmp
        if engins is None:
            engins = engins_tmp
    else:
        # Charger uniquement secteurs et engins si non fournis
        from data import get_secteurs, get_engins, get_raw_interventions
        from classes import Intervention, Secteur, Engin
        
        # Assigner les attributs de classe nécessaires
        Intervention.df = get_raw_interventions()
        Secteur.df = None  # Sera assigné par get_secteurs()
        Engin.df = None     # Sera assigné par get_engins()
        
        secteurs = get_secteurs()
        if engins is None:
            engins = get_engins()

    print(f"Nombre d'engins: {len(engins)}")

    # --- Reset de l'état accumulé des simulations précédentes ---
    for _, engin in engins.items():
        engin.reset_simulation_state()
    filters.reset_secteurs_proches()
    reset_trajet_stats()

    for _, engin in engins.items():
        secteurs[engin.cs].add_engin(engin)

    for indisponibilite in indisponibilites:
        secteurs[indisponibilite.cs].ajouter_indisponibilite(indisponibilite)

    for _, engin in engins.items():
        engin.indisponibilites.set_up()

    i = 0
    print_every = 1000

    start_time = time.time()
    
    interventions_a_traiter = interventions[:LIMITE_INTERVENTIONS] if LIMITE_INTERVENTIONS else interventions
    total_interventions = len(interventions_a_traiter)
    
    for intervention in interventions_a_traiter:
        if intervention.cstc == "NR":
            print("Intervention avec cstc NR")
            continue
        engin = filters.attribuer(intervention, secteurs, skip_cstc_priority=skip_cstc_priority)
        if engin is not None:
            temps_aller, temps_retour = engin.attribuer_a(intervention)
            result.interventions_simulees.append(
                InterventionSimulee.from_Intervention(
                    intervention, engin, temps_aller, temps_retour
                )
            )
            
            # Comparer le CS assigné avec le CS réel
            cs_reel = getattr(intervention, "cs_vhl", None)
            if cs_reel is not None:
                result.cs_total_count += 1
                if engin.cs == cs_reel:
                    result.cs_match_count += 1
                else:
                    # Enregistrer les premiers 100 cas d'erreur pour diagnostic
                    if len(result.cs_mismatch_details) < 100:
                        result.cs_mismatch_details.append({
                            'intervention_id': getattr(intervention, 'id', i),
                            'date': intervention.date,
                            'cs_reel': cs_reel,
                            'cs_attribue': engin.cs,
                            'type_vhl_envoye': engin.type_engin,
                            'cstc': intervention.cstc,
                            'fem_mma': intervention.fem_mma,
                            'x': intervention.x,
                            'y': intervention.y,
                        })
        i += 1
        if i % print_every == 0:
            print(datetime.datetime.now(), i)
        
        # Callback pour la progression
        if progress_callback and i % 100 == 0:  # Mise à jour tous les 100 interventions
            progress_callback(i, total_interventions)

    result.simulation_processing_time = time.time() - start_time
    
    # Synchroniser les variables globales pour la rétro-compatibilité
    _sync_globals_from_result(result)
    
    print("Fini.", i)
    print(f"Temps de traitement: {result.simulation_processing_time:.1f}s")
    return interventions, engins


if __name__ == "__main__":
    # ---- Toggle profiling by setting USE_PROFILE = True ----
    USE_PROFILE = True
    if USE_PROFILE:
        import cProfile
        import io
        import pstats

        pr = cProfile.Profile()
        pr.enable()
        interventions_reelles, engins = main()
        pr.disable()
        print_statistiques(interventions_simulees, engins)
        combien_de_fois_on_envoie_un_vhl_diff(interventions_simulees)
        s = io.StringIO()
        ps = pstats.Stats(pr, stream=s).sort_stats("cumulative")
        ps.print_stats(40)  # top 40 hotspots
        print(s.getvalue())
    else:
        main()