Update src/module/Dashboard.py

src/module/Dashboard.py

@@ -1,19 +1,19 @@
 """
 MODULE: EXECUTIVE DASHBOARD (DIRECTOR VIEW)
 ===========================================
-Responsabilité : Vue synthétique et décisionnelle pour la direction.
-Agrège : ETL (Passé) + Forecasting (Futur) + DQ (Qualité).
-Style : Gotham UI (Haute Visibilité)
+Responsabilité : Cockpit de pilotage + Simulateur de crise.
+Agrège : ETL (Passé) + Forecasting (Futur) + Simulation (Hypothèses).
+Style : Gotham UI
 """
 
 import streamlit as st
 import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
-from datetime import timedelta
 import numpy as np
+from datetime import timedelta
 
-# Import pour charger les données si nécessaire
+# Import pour charger les données
 from module.Validation_Contract import ETL_Engine
 
 class HospitalDashboard:
@@ -26,7 +26,7 @@ class HospitalDashboard:
         
     def load_data(self):
         """Charge les données via le cache ou l'ETL"""
-        # 1. Tenter de récupérer depuis le session_state (Data Explorer)
+        # 1. Tenter de récupérer depuis le session_state
         if 'data_explorer' in st.session_state and hasattr(st.session_state.data_explorer, 'dataframes'):
             dfs = st.session_state.data_explorer.dataframes
             self.df_res = dfs.get('ressources_jour')
@@ -46,26 +46,17 @@ class HospitalDashboard:
 
     def _get_kpis(self):
         """Calcule les indicateurs MACRO pour le bandeau"""
-        # On prend la dernière date disponible (Aujourd'hui simulé)
         last_date = pd.to_datetime(self.df_res['date']).max()
-        
-        # Filtre sur "Aujourd'hui"
         df_today = self.df_res[pd.to_datetime(self.df_res['date']) == last_date]
         df_adm_today = self.df_adm[pd.to_datetime(self.df_adm['date']) == last_date]
         
-        # 1. Taux d'Occupation Global
-        # Somme des lits occupés / Somme des lits totaux
         total_lits = df_today['lits_total'].sum()
         total_occupes = df_today['lits_occupes'].sum()
         taux_global = (total_occupes / total_lits * 100) if total_lits > 0 else 0
         
-        # 2. Admissions du jour
         nb_adm = df_adm_today['nb_admissions'].sum()
-        
-        # 3. Services en Tension (Occupation > 85%)
         nb_tension = df_today[df_today['taux_occupation'] > 0.85].shape[0]
         
-        # 4. Alertes Stock (Dernière date stock)
         last_date_stock = pd.to_datetime(self.df_stock['date']).max()
         df_stock_today = self.df_stock[pd.to_datetime(self.df_stock['date']) == last_date_stock]
         nb_ruptures = df_stock_today[df_stock_today['alerte_stock'] == 1].shape[0]
@@ -79,185 +70,194 @@ class HospitalDashboard:
         }
 
     def plot_main_chart(self):
-        """Le graphique hybride : Historique + Prédiction (si dispo)"""
-        
+        """Graphique Hybride : Historique + Prédiction Standard"""
         fig = go.Figure()
         
-        # --- A. HISTORIQUE (ETL) ---
-        # On agrège par date pour avoir une courbe globale
+        # Historique
         df_hist = self.df_res.copy()
         df_hist['date'] = pd.to_datetime(df_hist['date'])
         daily_occ = df_hist.groupby('date')['taux_occupation'].mean() * 100
-        
-        # On affiche les 30 derniers jours
         daily_occ = daily_occ.tail(30)
         
         fig.add_trace(go.Scatter(
             x=daily_occ.index, y=daily_occ.values,
-            mode='lines+markers',
-            name='Historique',
+            mode='lines+markers', name='Historique',
             line=dict(color='#58a6ff', width=3),
-            fill='tozeroy',
-            fillcolor='rgba(88, 166, 255, 0.1)'
+            fill='tozeroy', fillcolor='rgba(88, 166, 255, 0.1)'
         ))
         
-        # --- B. PRÉDICTION (Forecasting Module) ---
-        # On vérifie si une prédiction a été générée dans Forecasting
+        # Prédiction IA (si dispo)
         has_forecast = False
         if 'forecaster' in st.session_state:
             forecaster = st.session_state['forecaster']
-            # On génère 30 jours de forecast à la volée (rapide)
-            # Attention : forecaster travaille sur 'nb_admissions' ou 'taux_occupation' selon le choix
-            # Pour l'exemple dashboard, on suppose qu'on veut afficher ce qui a été entraîné
             try:
+                # On génère 1 mois par défaut pour la vue supervision
                 f_dates, f_values = forecaster.generate_future_forecast(months=1)
-                
-                # Si le modèle a prédit le taux d'occupation (valeurs ~0.8), on multiplie par 100
-                if np.mean(f_values) < 2: 
-                    f_values = f_values * 100
+                # Adaptation d'échelle si nécessaire (si le modèle sort 0.8 au lieu de 80)
+                if np.mean(f_values) < 2: f_values = f_values * 100
                     
                 fig.add_trace(go.Scatter(
                     x=f_dates, y=f_values,
-                    mode='lines',
-                    name='Projection IA',
+                    mode='lines', name='Tendance IA',
                     line=dict(color='#00E676', width=3, dash='dot')
                 ))
                 has_forecast = True
-            except:
-                pass # Si erreur forecast, on affiche juste l'historique
+            except: pass
 
-        # Ligne de seuil critique (100%)
         fig.add_hline(y=100, line_dash="dash", line_color="#FF5252", annotation_text="Saturation")
         
-        title = "Taux d'Occupation : Réalité vs Projection IA" if has_forecast else "Taux d'Occupation (Historique Récent)"
-        
-        fig.update_layout(
-            title=title,
-            template="plotly_dark",
-            height=350,
-            margin=dict(l=20, r=20, t=40, b=20),
-            hovermode="x unified",
-            yaxis_title="Occupation (%)"
-        )
+        title = "Taux d'Occupation : Réalité vs IA" if has_forecast else "Taux d'Occupation (Historique)"
+        fig.update_layout(title=title, template="plotly_dark", height=350, margin=dict(l=20, r=20, t=40, b=20))
         return fig
 
     def plot_service_tension(self):
-        """Bar chart des services les plus chargés aujourd'hui"""
+        """Top Flop des services"""
         last_date = pd.to_datetime(self.df_res['date']).max()
         df_today = self.df_res[pd.to_datetime(self.df_res['date']) == last_date].copy()
-        
         df_today['taux_pct'] = df_today['taux_occupation'] * 100
-        df_sorted = df_today.sort_values('taux_pct', ascending=True) # Ascending pour barh
+        df_sorted = df_today.sort_values('taux_pct', ascending=True)
         
-        # Couleurs conditionnelles
         colors = ['#FF5252' if x >= 100 else '#FFA726' if x >= 85 else '#66BB6A' for x in df_sorted['taux_pct']]
         
         fig = go.Figure(go.Bar(
-            x=df_sorted['taux_pct'],
-            y=df_sorted['service_code'],
-            orientation='h',
-            marker_color=colors,
-            text=df_sorted['taux_pct'].round(1).astype(str) + '%',
-            textposition='auto'
+            x=df_sorted['taux_pct'], y=df_sorted['service_code'],
+            orientation='h', marker_color=colors,
+            text=df_sorted['taux_pct'].round(1).astype(str) + '%', textposition='auto'
         ))
-        
-        fig.update_layout(
-            title=f"État des Services ({last_date.strftime('%d/%m')})",
-            template="plotly_dark",
-            height=350,
-            margin=dict(l=20, r=20, t=40, b=20),
-            xaxis_title="% Occupation"
-        )
+        fig.update_layout(title=f"État Services ({last_date.strftime('%d/%m')})", template="plotly_dark", height=350, margin=dict(l=20, r=20, t=40, b=20))
         return fig
 
+    def run_simulation(self, impact_admission, impact_lits):
+        """Calcul de la simulation (What-If Analysis)"""
+        if 'forecaster' not in st.session_state:
+            return None, None, None
+            
+        forecaster = st.session_state['forecaster']
+        
+        # 1. On récupère la prédiction de base (3 mois)
+        f_dates, f_values = forecaster.generate_future_forecast(months=3)
+        
+        # Si le modèle prédit un taux (0-1), on met en %
+        if np.mean(f_values) < 2: f_values = f_values * 100
+            
+        # 2. Application des modificateurs
+        # Facteur admission (Numérateur)
+        factor_adm = 1 + (impact_admission / 100)
+        # Facteur capacité (Dénominateur)
+        factor_capa = 1 + (impact_lits / 100)
+        
+        simulated_values = (f_values * factor_adm) / factor_capa
+        
+        return f_dates, f_values, simulated_values
+
 
 def show_dashboard(client, sheet_name):
     st.markdown("## 🚁 COCKPIT DE DIRECTION")
-    st.caption("Vue synthétique en temps réel de l'hôpital.")
+    st.caption("Supervision Temps Réel & Simulation Stratégique")
     
     dashboard = HospitalDashboard(client, sheet_name)
     
-    # Chargement
-    with st.spinner("Actualisation des données décisionnelles..."):
-        if not dashboard.load_data():
-            st.error("Impossible de charger les données. Vérifiez la connexion.")
-            return
+    # Chargement discret
+    if not dashboard.load_data():
+        st.error("Données indisponibles.")
+        return
 
-    # --- 1. BANDEAU KPIs ---
+    # --- BANDEAU KPIs (Toujours visible) ---
     kpis = dashboard._get_kpis()
-    
-    # Style CSS pour les cartes KPI (Optionnel, sinon st.metric standard)
     k1, k2, k3, k4 = st.columns(4)
     
-    k1.metric(
-        "Taux d'Occupation Global", 
-        f"{kpis['taux_global']:.1f}%", 
-        delta="Critique" if kpis['taux_global'] > 90 else "Stable",
-        delta_color="inverse"
-    )
-    
-    k2.metric(
-        "Admissions du Jour", 
-        f"{int(kpis['nb_adm'])}", 
-        delta="Patients"
-    )
-    
-    k3.metric(
-        "Services en Tension", 
-        f"{kpis['nb_tension']}", 
-        delta="> 85% Occ.",
-        delta_color="inverse"
-    )
-    
-    k4.metric(
-        "Alertes Stock", 
-        f"{kpis['nb_ruptures']}", 
-        delta="Ruptures",
-        delta_color="inverse"
-    )
+    k1.metric("Taux Occupation", f"{kpis['taux_global']:.1f}%", delta="Critique" if kpis['taux_global'] > 90 else "OK", delta_color="inverse")
+    k2.metric("Admissions (J)", f"{int(kpis['nb_adm'])}")
+    k3.metric("Services Tendus", f"{kpis['nb_tension']}", delta="Alertes", delta_color="inverse")
+    k4.metric("Ruptures Stock", f"{kpis['nb_ruptures']}", delta="Alertes", delta_color="inverse")
     
     st.divider()
-    
-    # --- 2. GRAPHIQUES CENTRAUX ---
-    col_main, col_side = st.columns([2, 1])
-    
-    with col_main:
-        # Graphique Temporel (Hybride)
-        st.plotly_chart(dashboard.plot_main_chart(), use_container_width=True)
-        
-    with col_side:
-        # Graphique Services
-        st.plotly_chart(dashboard.plot_service_tension(), use_container_width=True)
 
-    # --- 3. FLASH REPORT & ACTIONS ---
-    st.markdown("### ⚡ Flash Report & Recommandations")
-    
-    col_msg, col_act = st.columns([3, 1])
-    
-    with col_msg:
-        # Logique simple de génération de texte (Simule l'IA Jasmine)
-        if kpis['taux_global'] > 95:
-            msg_status = "🔴 **CRITIQUE :** L'hôpital est proche de la saturation totale."
-            msg_action = "Recommandation : Activer le Plan Blanc et délester les services d'Urgence."
-        elif kpis['taux_global'] > 85:
-            msg_status = "🟠 **ATTENTION :** Tensions fortes sur les capacités."
-            msg_action = "Recommandation : Surveiller les sorties et préparer des lits d'aval."
-        else:
-            msg_status = "🟢 **NOMINAL :** Activité hospitalière sous contrôle."
-            msg_action = "Aucune action critique requise."
+    # --- ONGLETS : SUPERVISION vs SIMULATION ---
+    tab_live, tab_sim = st.tabs(["📡 Supervision Temps Réel", "🎛️ Simulateur de Crise"])
+
+    # === ONGLET 1 : SUPERVISION ===
+    with tab_live:
+        col_main, col_side = st.columns([2, 1])
+        with col_main:
+            st.plotly_chart(dashboard.plot_main_chart(), use_container_width=True)
+        with col_side:
+            st.plotly_chart(dashboard.plot_service_tension(), use_container_width=True)
             
-        st.info(f"{msg_status}\n\n{msg_action}")
+        # --- FLASH REPORT DYNAMIQUE (RESTORÉ) ---
+        st.markdown("### ⚡ Flash Report & Recommandations")
+        col_msg, col_act = st.columns([3, 1])
         
-    with col_act:
-        st.markdown("**Actions Rapides**")
-        if st.button("📢 Alerter Chefs de Service"):
-            st.toast("Notification envoyée aux 12 chefs de service.", icon="📨")
-        
-        if st.button("📊 Rapport PDF Complet"):
-            st.toast("Génération du PDF en cours...", icon="📄")
+        with col_msg:
+            # Logique d'IA Textuelle (Restaurée)
+            if kpis['taux_global'] > 95:
+                msg_status = "🔴 **CRITIQUE :** L'hôpital est proche de la saturation totale."
+                msg_action = "👉 **ACTION REQUISE :** Activer le Plan Blanc et délester les services d'Urgence."
+            elif kpis['taux_global'] > 85:
+                msg_status = "🟠 **ATTENTION :** Tensions fortes sur les capacités."
+                msg_action = "👉 **ACTION REQUISE :** Surveiller les sorties et préparer des lits d'aval."
+            else:
+                msg_status = "🟢 **NOMINAL :** Activité hospitalière sous contrôle."
+                msg_action = "✅ Aucune action critique requise à court terme."
+                
+            st.info(f"{msg_status}\n\n{msg_action}")
             
+        with col_act:
+            if st.button("📢 Alerter Equipes"):
+                st.toast("Alerte envoyée aux chefs de service.", icon="📨")
+            if st.button("📊 Export PDF"):
+                st.toast("Rapport généré.", icon="📄")
+
+    # === ONGLET 2 : SIMULATEUR ===
+    with tab_sim:
+        st.markdown("### 🧪 Bac à Sable (What-If Analysis)")
+        
         if 'forecaster' not in st.session_state:
-            st.warning("⚠️ Prévisions IA non disponibles")
-            if st.button("Activer l'IA Prédictive"):
-                st.switch_page("src/streamlit_app.py") # Astuce pour rediriger vers le module forecasting si besoin
-                # En vrai on demanderait à l'utilisateur d'aller dans l'onglet Forecasting
+            st.warning("⚠️ Le module 'Simulateur' nécessite que l'IA soit activée.")
+            if st.button("Activer l'IA maintenant"):
+                st.error("Veuillez d'abord visiter l'onglet 'Forecasting' pour entraîner le modèle.")
+        else:
+            col_params, col_viz = st.columns([1, 3])
+            
+            with col_params:
+                st.markdown("#### 1. Paramètres")
+                st.caption("Modifiez les variables pour voir l'impact futur.")
+                
+                choc_adm = st.slider("🌊 Choc d'Admissions", -20, +50, 0, format="%+d%%", help="Ex: Grippe, Plan Blanc (+30%)")
+                choc_lits = st.slider("🛏️ Ouverture Lits", -20, +20, 0, format="%+d%%", help="Ex: Ouverture d'une aile (+10%)")
+                
+                st.markdown("---")
+                
+                # Calcul impact
+                dates, base, simu = dashboard.run_simulation(choc_adm, choc_lits)
+                
+                if simu is not None:
+                    delta_max = np.max(simu) - np.max(base)
+                    st.metric("Impact Peak", f"{delta_max:+.1f} pts", delta="Risque" if delta_max > 0 else "Gain", delta_color="inverse")
+
+            with col_viz:
+                st.markdown("#### 2. Projection d'Impact (3 Mois)")
+                if simu is not None:
+                    fig_sim = go.Figure()
+                    
+                    # Courbe de base
+                    fig_sim.add_trace(go.Scatter(x=dates, y=base, name="Scénario Actuel", line=dict(color='gray', dash='dot')))
+                    
+                    # Courbe simulée
+                    color_sim = '#FF5252' if np.max(simu) > 100 else '#00E676'
+                    fig_sim.add_trace(go.Scatter(x=dates, y=simu, name="Scénario Simulé", line=dict(color=color_sim, width=3), fill='tonexty'))
+                    
+                    # Seuil
+                    fig_sim.add_hline(y=100, line_color="white", annotation_text="Capacité Max")
+                    
+                    fig_sim.update_layout(template="plotly_dark", height=400, hovermode="x unified", title="Impact sur le Taux d'Occupation")
+                    st.plotly_chart(fig_sim, use_container_width=True)
+                    
+                    # Conclusion automatique de simulation
+                    max_val = np.max(simu)
+                    if max_val > 100:
+                        st.error(f"🚨 **ALERTE CRITIQUE :** Ce scénario entraîne une saturation à **{max_val:.1f}%**. Il faut augmenter la capacité d'au moins **{max_val-100:.1f}%**.")
+                    elif max_val > 85:
+                        st.warning(f"⚠️ **TENSION :** Ce scénario provoque une tension forte ({max_val:.1f}%). Surveillance requise.")
+                    else:
+                        st.success(f"✅ **ROBUSTE :** L'hôpital tient le choc ({max_val:.1f}% max).")