2_Optimisation.py

import datetime
import os
import threading

import folium
import numpy as np
import streamlit as st

import main as main_module
import fonction_calcul_trajet as fct
from data import get_interventions
from optimisation.interface_helper import optimize_allocation_from_interface, get_optimization_profiles
from ui.common import (
    ensure_session_state_initialized,
    load_secteurs_and_gdf,
    ensure_secteur_df_loaded,
    render_simulation_date_range_sidebar,
    convert_session_engins_to_objects,
    set_gdal_env_if_needed,
)
from ui.utilisation import summarise_utilisation_for_window


st.set_page_config(layout="wide", page_title="Optimisation")
set_gdal_env_if_needed()

# --- Pre-chargement GPU data en arriere-plan ---
def _preload_gpu_data():
    """Charge les donnees GPU et cree le cache pickle si necessaire."""
    try:
        import sys
        from pathlib import Path
        sys.path.insert(0, str(Path(__file__).parent.parent / "Reflets_gpu"))
        from data_loader import load_data
        load_data()
    except Exception:
        pass

if "gpu_preload_started" not in st.session_state:
    st.session_state.gpu_preload_started = True
    threading.Thread(target=_preload_gpu_data, daemon=True).start()

st.title("Optimisation")
st.caption("Page dédiée aux paramètres d’optimisation (métrique, algorithme, profil, etc.).")

ensure_session_state_initialized()
secteurs_initiaux, _gdf = load_secteurs_and_gdf()
ensure_secteur_df_loaded()

render_simulation_date_range_sidebar()
st.sidebar.markdown("---")

st.sidebar.caption("Les réglages d’optimisation sont sur la page (centre).")

profiles = get_optimization_profiles()
profile_names = {k: v["name"] for k, v in profiles.items()}

default_algo = st.session_state.get("optimization_algorithm", "simulated_annealing")
default_profile = st.session_state.get("optimization_profile", "rapide")
default_metric = st.session_state.get("optimization_metric", "temps_moyen")

st.subheader("Configuration")
with st.form("optim_config", clear_on_submit=False, border=True):
    c1, c2, c3 = st.columns(3)
    with c1:
        algo_key = st.selectbox(
            "Algorithme",
            options=["simulated_annealing", "genetic"],
            index=0 if default_algo == "simulated_annealing" else 1,
            format_func=lambda x: "Recuit simulé"
            if x == "simulated_annealing"
            else "Algorithme génétique",
        )
    with c2:
        profile_options = list(profile_names.keys())
        profile_index = (
            profile_options.index(default_profile)
            if default_profile in profile_options
            else 1
        )
        selected_profile_key = st.selectbox(
            "Profil",
            options=profile_options,
            index=profile_index,
            format_func=lambda x: profile_names[x],
            help="Compromis vitesse/qualité",
        )
    with c3:
        metric_key = st.selectbox(
            "Métrique (objectif)",
            options=["temps_moyen", "taux_couverture", "manque_local_ratio", "mixte"],
            index=["temps_moyen", "taux_couverture", "manque_local_ratio", "mixte"].index(
                default_metric if default_metric in {"temps_moyen", "taux_couverture", "manque_local_ratio", "mixte"} else "temps_moyen"
            ),
            help="UI prête pour brancher le calcul de score sur une métrique différente.",
        )

    selected_profile = profiles[selected_profile_key]
    st.caption(f"{selected_profile['description']} - {selected_profile['use_case']}")

    if metric_key != "temps_moyen":
        st.info(
            "Le choix de métrique est enregistré, mais le score actuel de l’optimiseur "
            "reste basé sur le temps moyen (à brancher côté `eval_window`)."
        )

    run = st.form_submit_button("Lancer l’optimisation (séquentiel)", type="primary")

st.session_state["optimization_algorithm"] = algo_key
st.session_state["optimization_profile"] = selected_profile_key
st.session_state["optimization_metric"] = metric_key

# --- Optimisation GPU ---
st.markdown("---")
st.subheader("Optimisation GPU")

with st.form("gpu_config", clear_on_submit=False, border=True):
    gc1, gc2, gc3 = st.columns(3)
    with gc1:
        gpu_metric = st.selectbox(
            "Métrique GPU",
            options=["temps_moyen", "p95_vsav", "p99_vsav", "std_q95_pression", "taux_couverture", "manque_local"],
            index=0,
        )
    with gc2:
        gpu_algo = st.selectbox("Algorithme GPU", options=["sa", "ga"], format_func=lambda x: "Recuit simulé" if x == "sa" else "Génétique")
    with gc3:
        gpu_iter = st.number_input("Itérations", min_value=1, max_value=2000, value=5)

    gc4, gc5 = st.columns(2)
    with gc4:
        gpu_window = st.number_input("Fenêtre (nb inter)", min_value=100, max_value=478898, value=1000)
    with gc5:
        gpu_batch = st.number_input("Batch size", min_value=32, max_value=2048, value=512)

    run_gpu = st.form_submit_button("Lancer l’optimisation GPU", type="primary")

if run_gpu:
    import subprocess, sys
    from pathlib import Path

    gpu_script = Path(__file__).parent.parent / "Reflets_gpu" / "run_gpu_optim.py"
    if not gpu_script.exists():
        st.error(f"Script GPU introuvable: {gpu_script}")
    else:
        # Utiliser le meme Python que celui qui fait tourner Streamlit
        python_exe = sys.executable
        cmd = [
            python_exe, str(gpu_script),
            "--algo", gpu_algo,
            "--metric", gpu_metric,
            "--max_iter", str(gpu_iter),
            "--window_size", str(gpu_window),
            "--n_batch", str(gpu_batch),
        ]

        import re
        import plotly.graph_objects as pgo

        st.markdown("---")
        st.subheader("Optimisation GPU en cours...")
        st.caption(" ".join(cmd))

        progress_bar = st.progress(0)
        progress_text = st.empty()

        # Metriques header
        col_m1, col_m2, col_m3, col_m4 = st.columns(4)
        ph_init = col_m1.empty()
        ph_current = col_m2.empty()
        ph_best = col_m3.empty()
        ph_temp = col_m4.empty()

        # Graphe
        chart_ph = st.empty()

        # Logs
        log_expander = st.expander("Logs", expanded=False)
        log_area = log_expander.empty()

        try:
            env = {**os.environ, "KMP_DUPLICATE_LIB_OK": "TRUE", "PYTHONUNBUFFERED": "1"}
            proc = subprocess.Popen(
                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                text=True, bufsize=1, env=env,
            )

            lines = []
            iterations = []
            current_scores = []
            best_scores = []
            initial_score = None

            # Pattern pour parser les logs SA:
            # [SA] it=  10  T= 80.00  score=540.1  best=538.2  n_moves=3  accept=Y  12s
            sa_pattern = re.compile(
                r"\[SA\]\s+it=\s*(\d+)\s+T=\s*([\d.]+)\s+score=([\d.]+)\s+best=([\d.]+)"
            )

            for line in proc.stdout:
                line = line.rstrip()
                lines.append(line)

                # Parser le score initial
                if "Score allocation initiale:" in line:
                    try:
                        initial_score = float(line.split(":")[-1].strip())
                        ph_init.metric("Score initial", f"{initial_score:.1f}")
                    except ValueError:
                        pass

                # Parser les iterations SA
                m = sa_pattern.search(line)
                if m:
                    it = int(m.group(1))
                    temp = float(m.group(2))
                    score = float(m.group(3))
                    best = float(m.group(4))

                    iterations.append(it)
                    current_scores.append(score)
                    best_scores.append(best)

                    # Progression
                    progress_bar.progress(min(it / gpu_iter, 1.0))
                    progress_text.text(f"Itération {it}/{gpu_iter}")

                    # Metriques
                    ph_current.metric("Score actuel", f"{score:.1f}")
                    if initial_score:
                        delta = best - initial_score
                        pct = 100 * delta / initial_score if initial_score else 0
                        ph_best.metric("Meilleur score", f"{best:.1f}",
                                       delta=f"{delta:.1f} ({pct:.1f}%)", delta_color="inverse")
                    else:
                        ph_best.metric("Meilleur score", f"{best:.1f}")
                    ph_temp.metric("Température", f"{temp:.2f}")

                    # Graphe (pas trop souvent pour ne pas ralentir)
                    if len(iterations) % 5 == 0 or it <= 10:
                        fig = pgo.Figure()
                        fig.add_trace(pgo.Scatter(
                            x=iterations, y=current_scores,
                            mode="lines", name="Score actuel",
                            line=dict(color="lightblue", width=1), opacity=0.6,
                        ))
                        fig.add_trace(pgo.Scatter(
                            x=iterations, y=best_scores,
                            mode="lines", name="Meilleur score",
                            line=dict(color="green", width=3),
                        ))
                        if initial_score:
                            fig.add_hline(y=initial_score, line_dash="dash",
                                          line_color="red", annotation_text="initial")
                        fig.update_layout(
                            xaxis_title="Itération", yaxis_title="Score",
                            height=300, margin=dict(l=50, r=20, t=30, b=40),
                            showlegend=True, legend=dict(x=0.02, y=0.98),
                        )
                        chart_ph.plotly_chart(fig, use_container_width=True)

                # Logs
                log_area.code("\n".join(lines[-20:]), language="text")

            proc.wait()
            progress_bar.progress(1.0)
            progress_text.text("Terminé !")

            if proc.returncode == 0:
                st.success("Optimisation GPU terminée ! Résultats dans Reflets_gpu/results/")
            else:
                st.error(f"Erreur GPU (code {proc.returncode})")
                st.code("\n".join(lines[-50:]), language="text")

        except Exception as e:
            st.error(f"Erreur lancement GPU: {e}")


def _filter_interventions_by_date(interventions):
    sim_start = st.session_state.get("simulation_start")
    sim_end = st.session_state.get("simulation_end")
    if not sim_start and not sim_end:
        return interventions
    return [
        i
        for i in interventions
        if (sim_start is None or i.date >= sim_start)
        and (sim_end is None or i.date <= sim_end)
    ]


if run:
    try:
        interventions = get_interventions()
    except Exception as e:
        st.error(f"Impossible de charger les interventions: {e}")
        interventions = []

    if interventions:
        interventions_valides = [
            i for i in interventions if hasattr(i, "cstc") and i.cstc != "NR"
        ]
        nb_filtrees = len(interventions) - len(interventions_valides)
        if nb_filtrees > 0:
            st.info(f"{nb_filtrees} interventions ignorées (CSTC non renseigné)")
        interventions = interventions_valides

        st.markdown("---")
        st.subheader("Résultats optimisation")

        try:
            updated_engins, metrics = optimize_allocation_from_interface(
                interventions=interventions,
                secteurs=secteurs_initiaux,
                current_engins_state=st.session_state.engins,
                profile=selected_profile_key,
                algorithm=algo_key,
            )

            st.session_state.engins = updated_engins
            st.session_state.allocation_dirty = False

            st.success(
                f"Optimisation terminée ! Amélioration: {metrics['improvement']:.2f}% "
                f"({metrics['total_iterations']} itérations)"
            )

            with st.expander("Détails", expanded=False):
                st.json(
                    {
                        "profil": selected_profile_key,
                        "algorithme": algo_key,
                        "metrique_choisie": metric_key,
                        "metrics": metrics,
                    }
                )

            st.markdown("### Simulation avec la nouvelle allocation")
            try:
                main_module.interventions_simulees.clear()
            except Exception:
                pass

            fct.reset_stats()

            interventions_filtered = _filter_interventions_by_date(interventions)

            progress_bar = st.progress(0)
            progress_text = st.empty()

            def update_progress(current, total):
                progress = current / total if total else 1.0
                progress_bar.progress(progress)
                progress_text.text(
                    f"Simulation : {current}/{total} interventions ({progress*100:.1f}%)"
                )

            engins_dict = convert_session_engins_to_objects(secteurs_initiaux)

            main_module.main(
                progress_callback=update_progress,
                interventions=interventions_filtered,
                indisponibilites=st.session_state.indisponibilites_data,
                engins=engins_dict,
            )

            progress_bar.progress(1.0)
            progress_text.text("Simulation terminée !")

            stats = fct.get_stats()
            st.session_state.simulation_time = main_module.simulation_processing_time
            st.session_state.cache_stats = stats
            st.session_state.progress = 1
            st.session_state.map_needs_update = True

            reponses_s = [i.temps_reponse_seconds for i in main_module.interventions_simulees]
            if reponses_s:
                mean_reponse = float(sum(reponses_s) / len(reponses_s))
                st.metric("Temps de réponse moyen (départ + trajet)", f"{mean_reponse:.1f} s")
                st.caption(f"{len(reponses_s)} interventions simulées")

            # Carte utilisation (pression 08h->08h) — provisoire après simulation
            engaged = getattr(main_module, "engaged_seconds_by_cs_by_window", None) or {}
            vehicle_counts = getattr(main_module, "vehicle_counts_by_cs", None) or {}
            all_windows = sorted({w for cs_map in engaged.values() for w in cs_map.keys()})
            if all_windows:
                selected_w = all_windows[0]
                ratio_by_cs, _hours_by_cs = summarise_utilisation_for_window(
                    engaged_seconds_by_cs_by_window=engaged,
                    window_start=selected_w,
                    vehicle_counts_by_cs=vehicle_counts,
                )
                st.markdown("---")
                st.subheader("Carte d'utilisation des véhicules (pression 08h → 08h)")
                st.caption(
                    f"Fenêtre affichée: {selected_w:%Y-%m-%d} 08:00 → {(selected_w + datetime.timedelta(days=1)):%Y-%m-%d} 08:00"
                )

                util_map = folium.Map(location=[48.8566, 2.3522], zoom_start=9)
                ratios = [
                    v
                    for v in ratio_by_cs.values()
                    if v is not None and isinstance(v, (int, float)) and not np.isnan(v)
                ]
                rmin = float(min(ratios)) if ratios else 0.0
                rmax = float(max(ratios)) if ratios else 1.0
                if rmax == rmin:
                    rmax = rmin + 1e-9

                def style_util(f):
                    cs = f["properties"]["nom"]
                    v = ratio_by_cs.get(cs, float("nan"))
                    if v is None or (isinstance(v, float) and np.isnan(v)):
                        return {
                            "fillColor": "#999999",
                            "color": "black",
                            "weight": 1,
                            "fillOpacity": 0.25,
                        }
                    t = max(0.0, min(1.0, (float(v) - rmin) / (rmax - rmin)))
                    r = int(255 * t)
                    g = int(255 * (1 - t))
                    return {
                        "fillColor": f"#{r:02X}{g:02X}00",
                        "color": "black",
                        "weight": 1,
                        "fillOpacity": 0.6,
                    }

                folium.GeoJson(
                    _gdf,
                    style_function=style_util,
                    tooltip=folium.GeoJsonTooltip(fields=["nom"], aliases=["Secteur"]),
                ).add_to(util_map)

                st.components.v1.html(util_map._repr_html_(), width=700, height=500)

        except Exception as e:
            st.error(f"Erreur lors de l'optimisation: {e}")
            import traceback

            with st.expander("Détails de l'erreur"):
                st.code(traceback.format_exc())
    else:
        st.warning("Aucune intervention à optimiser")