src/module/Dashboard.py

"""
MODULE: COCKPIT DE DIRECTION - PALANTIR GOTHAM EDITION
======================================================
Responsabilité : Supervision stratégique temps réel et simulation de crise avancée
Architecture : Command & Control Center pour décideurs hospitaliers

Fonctionnalités :
- Supervision multi-niveaux (Opérationnel / Tactique / Stratégique)
- Simulateur de crise avec 7 scénarios (épidémie, grève, cyberattaque, etc.)
- Analyse prédictive d'impact multi-variables
- Recommandations automatiques basées sur l'IA
- Génération de rapports exécutifs
- Système d'alerte cascadé par criticité
"""

import streamlit as st
import pandas as pd
import numpy as np
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')


# =====================================================
# ============= MOTEUR DE SIMULATION ==================
# =====================================================

class CrisisSimulator:
    """
    Moteur de simulation de crise multi-scénarios avec analyse d'impact.
    """
    
    # Définition des scénarios de crise
    SCENARIOS = {
        'EPIDEMIE_GRIPPE': {
            'label': 'Épidémie de Grippe Saisonnière',
            'admissions_multiplier': 2.5,
            'duree_jours': 45,
            'services_impacts': ['URG', 'PED', 'REA', 'INF'],
            'personnel_absence': 0.15,
            'stock_consommation': 2.0,
            'criticite': 'HIGH'
        },
        'PANDEMIE_COVID': {
            'label': 'Pandémie Type COVID-19',
            'admissions_multiplier': 4.0,
            'duree_jours': 90,
            'services_impacts': ['URG', 'REA', 'ISO', 'MED'],
            'personnel_absence': 0.25,
            'stock_consommation': 3.5,
            'criticite': 'CRITICAL'
        },
        'CANICULE': {
            'label': 'Canicule Extrême (>40°C)',
            'admissions_multiplier': 1.8,
            'duree_jours': 21,
            'services_impacts': ['URG', 'REA', 'CAR'],
            'personnel_absence': 0.10,
            'stock_consommation': 1.5,
            'criticite': 'HIGH'
        },
        'ACCIDENT_MASSE': {
            'label': 'Accident de Grande Ampleur',
            'admissions_multiplier': 3.5,
            'duree_jours': 3,
            'services_impacts': ['URG', 'REA', 'TRA'],
            'personnel_absence': 0.05,
            'stock_consommation': 4.0,
            'criticite': 'CRITICAL'
        },
        'GREVE_PERSONNEL': {
            'label': 'Grève du Personnel Soignant',
            'admissions_multiplier': 0.6,
            'duree_jours': 14,
            'services_impacts': ['ALL'],
            'personnel_absence': 0.40,
            'stock_consommation': 0.7,
            'criticite': 'HIGH'
        },
        'CYBERATTAQUE': {
            'label': 'Cyberattaque Système Informatique',
            'admissions_multiplier': 0.3,
            'duree_jours': 7,
            'services_impacts': ['ALL'],
            'personnel_absence': 0.08,
            'stock_consommation': 1.0,
            'criticite': 'HIGH'
        },
        'RUPTURE_APPROVISIONNEMENT': {
            'label': 'Rupture Critique Approvisionnement',
            'admissions_multiplier': 0.8,
            'duree_jours': 30,
            'services_impacts': ['REA', 'TRA', 'CAR'],
            'personnel_absence': 0.05,
            'stock_consommation': 0.2,
            'criticite': 'MEDIUM'
        }
    }
    
    def __init__(self, forecaster, ml_dataset):
        self.forecaster = forecaster
        self.df = ml_dataset
        self.baseline_metrics = self._compute_baseline()
    
    def _compute_baseline(self):
        """Calcul des métriques de référence (état actuel)"""
        recent = self.df.tail(30)  # 30 derniers jours
        
        return {
            'admissions_moy': recent['nb_admissions'].mean(),
            'admissions_max': recent['nb_admissions'].max(),
            'taux_occupation_moy': recent['taux_occupation'].mean(),
            'tension_personnel_moy': recent['tension_personnel'].mean(),
            'services_actifs': recent['service_code'].nunique()
        }
    
    def simulate_scenario(self, scenario_key, intensity_factor=1.0):
        """
        Simule l'impact d'un scénario de crise.
        
        Args:
            scenario_key: Clé du scénario à simuler
            intensity_factor: Facteur d'intensité (0.5 à 2.0)
            
        Returns:
            Dictionnaire avec projections et impact
        """
        scenario = self.SCENARIOS[scenario_key].copy()
        
        # Application du facteur d'intensité
        scenario['admissions_multiplier'] *= intensity_factor
        scenario['personnel_absence'] *= intensity_factor
        scenario['stock_consommation'] *= intensity_factor
        
        # Génération prédictions futures (baseline)
        future_dates, baseline_predictions, _ = self.forecaster.generate_future_forecast_recursive(
            months=int(scenario['duree_jours'] / 30) + 1
        )
        
        # Application de l'impact du scénario
        impact_curve = self._generate_impact_curve(
            len(baseline_predictions),
            scenario['duree_jours'],
            scenario['admissions_multiplier']
        )
        
        crisis_predictions = baseline_predictions * impact_curve
        
        # Calcul des métriques d'impact
        impact_metrics = self._compute_impact_metrics(
            baseline_predictions,
            crisis_predictions,
            scenario
        )
        
        # Génération recommandations
        recommendations = self._generate_recommendations(scenario, impact_metrics)
        
        return {
            'scenario': scenario,
            'dates': future_dates[:scenario['duree_jours']],
            'baseline': baseline_predictions[:scenario['duree_jours']],
            'crisis': crisis_predictions[:scenario['duree_jours']],
            'impact_curve': impact_curve[:scenario['duree_jours']],
            'metrics': impact_metrics,
            'recommendations': recommendations
        }
    
    def _generate_impact_curve(self, n_days, crisis_duration, multiplier):
        """
        Génère une courbe d'impact réaliste (montée progressive, pic, décrue).
        """
        curve = np.ones(n_days)
        
        if crisis_duration >= n_days:
            crisis_duration = n_days
        
        # Phase 1: Montée (20% de la durée)
        ramp_up = int(crisis_duration * 0.2)
        curve[:ramp_up] = np.linspace(1.0, multiplier, ramp_up)
        
        # Phase 2: Pic (60% de la durée)
        peak_duration = int(crisis_duration * 0.6)
        curve[ramp_up:ramp_up + peak_duration] = multiplier
        
        # Phase 3: Décrue (20% de la durée)
        ramp_down = crisis_duration - ramp_up - peak_duration
        if ramp_down > 0:
            curve[ramp_up + peak_duration:crisis_duration] = np.linspace(
                multiplier, 1.0, ramp_down
            )
        
        return curve
    
    def _compute_impact_metrics(self, baseline, crisis, scenario):
        """Calcul des métriques d'impact détaillées"""
        
        # Admissions
        baseline_total = baseline.sum()
        crisis_total = crisis.sum()
        admissions_delta = crisis_total - baseline_total
        admissions_peak = crisis.max()
        
        # Estimation taux d'occupation (règle simple)
        baseline_occupation = self.baseline_metrics['taux_occupation_moy']
        crisis_occupation = min(baseline_occupation * scenario['admissions_multiplier'], 1.0)
        occupation_delta = crisis_occupation - baseline_occupation
        
        # Personnel
        personnel_disponible_baseline = 1.0
        personnel_disponible_crisis = 1.0 - scenario['personnel_absence']
        personnel_delta = scenario['personnel_absence']
        
        # Estimation lits nécessaires
        lits_necessaires_crisis = int(crisis.mean() * 1.5)  # Heuristique
        
        # Criticité globale
        if occupation_delta > 0.3 or scenario['criticite'] == 'CRITICAL':
            overall_criticite = 'CRITICAL'
        elif occupation_delta > 0.15 or scenario['criticite'] == 'HIGH':
            overall_criticite = 'HIGH'
        else:
            overall_criticite = 'MEDIUM'
        
        return {
            'admissions_delta': admissions_delta,
            'admissions_delta_pct': (admissions_delta / baseline_total) * 100,
            'admissions_peak': admissions_peak,
            'occupation_baseline': baseline_occupation,
            'occupation_crisis': crisis_occupation,
            'occupation_delta': occupation_delta,
            'occupation_delta_pct': (occupation_delta / baseline_occupation) * 100,
            'personnel_delta': personnel_delta,
            'personnel_delta_pct': personnel_delta * 100,
            'lits_necessaires': lits_necessaires_crisis,
            'stock_multiplier': scenario['stock_consommation'],
            'criticite': overall_criticite,
            'duree_jours': scenario['duree_jours']
        }
    
    def _generate_recommendations(self, scenario, metrics):
        """Génère des recommandations automatiques basées sur l'impact"""
        
        recs = []
        
        # Recommandations admissions
        if metrics['admissions_delta_pct'] > 50:
            recs.append({
                'categorie': 'CAPACITE',
                'priorite': 'IMMEDIATE',
                'action': f"Augmenter capacité de {int(metrics['lits_necessaires'])} lits",
                'justification': f"Pic d'admissions prévu : +{metrics['admissions_delta_pct']:.0f}%"
            })
        
        # Recommandations personnel
        if metrics['personnel_delta_pct'] > 20:
            recs.append({
                'categorie': 'PERSONNEL',
                'priorite': 'IMMEDIATE',
                'action': f"Mobiliser {int(metrics['personnel_delta_pct'])}% personnel de réserve",
                'justification': f"Absence personnel critique : {metrics['personnel_delta_pct']:.0f}%"
            })
        
        # Recommandations stock
        if metrics['stock_multiplier'] > 2.0:
            recs.append({
                'categorie': 'LOGISTIQUE',
                'priorite': 'URGENT',
                'action': f"Multiplier stocks par {metrics['stock_multiplier']:.1f}",
                'justification': "Consommation matériel exponentiellement accrue"
            })
        
        # Recommandations occupation
        if metrics['occupation_delta_pct'] > 30:
            recs.append({
                'categorie': 'OPERATIONS',
                'priorite': 'IMMEDIATE',
                'action': "Activer plan blanc ou plan bleu",
                'justification': f"Saturation prévue : {metrics['occupation_crisis']*100:.0f}%"
            })
        
        # Recommandations services impactés
        services_str = ', '.join(scenario['services_impacts'][:3])
        if len(scenario['services_impacts']) > 3:
            services_str += f" (+{len(scenario['services_impacts'])-3} autres)"
        
        recs.append({
            'categorie': 'COORDINATION',
            'priorite': 'URGENT',
            'action': f"Renforcer services : {services_str}",
            'justification': "Services en première ligne de la crise"
        })
        
        # Recommandation communication
        if metrics['criticite'] == 'CRITICAL':
            recs.append({
                'categorie': 'COMMUNICATION',
                'priorite': 'IMMEDIATE',
                'action': "Activer cellule de crise et communication externe",
                'justification': "Niveau de criticité maximal atteint"
            })
        
        return recs


# =====================================================
# ============= SUPERVISION TEMPS RÉEL ================
# =====================================================

class RealtimeMonitor:
    """
    Système de supervision temps réel multi-niveaux.
    """
    
    def __init__(self, ml_dataset, forecaster):
        self.df = ml_dataset
        self.forecaster = forecaster
        self.current_state = self._analyze_current_state()
    
    def _analyze_current_state(self):
        """Analyse de l'état actuel (72 dernières heures)"""
        
        recent = self.df.tail(3)  # 3 derniers jours
        last_24h = self.df.tail(1).iloc[0]
        
        # Métriques opérationnelles
        admissions_24h = last_24h['nb_admissions']
        taux_occupation = last_24h['taux_occupation']
        tension_personnel = last_24h['tension_personnel']
        
        # Calcul des tendances (72h)
        if len(recent) >= 3:
            trend_admissions = ((recent['nb_admissions'].iloc[-1] / recent['nb_admissions'].iloc[0]) - 1) * 100
            trend_occupation = ((recent['taux_occupation'].iloc[-1] / recent['taux_occupation'].iloc[0]) - 1) * 100
        else:
            trend_admissions = 0
            trend_occupation = 0
        
        # Détection d'alertes
        alertes = []
        
        if taux_occupation > 0.85:
            alertes.append({
                'niveau': 'CRITICAL',
                'categorie': 'CAPACITE',
                'message': f"Taux d'occupation critique : {taux_occupation*100:.1f}%"
            })
        elif taux_occupation > 0.75:
            alertes.append({
                'niveau': 'WARNING',
                'categorie': 'CAPACITE',
                'message': f"Taux d'occupation élevé : {taux_occupation*100:.1f}%"
            })
        
        if tension_personnel > 1.2:
            alertes.append({
                'niveau': 'CRITICAL',
                'categorie': 'PERSONNEL',
                'message': f"Tension personnel critique : {tension_personnel:.2f}"
            })
        elif tension_personnel > 1.0:
            alertes.append({
                'niveau': 'WARNING',
                'categorie': 'PERSONNEL',
                'message': f"Tension personnel élevée : {tension_personnel:.2f}"
            })
        
        if trend_admissions > 20:
            alertes.append({
                'niveau': 'WARNING',
                'categorie': 'TENDANCE',
                'message': f"Hausse admissions 72h : +{trend_admissions:.0f}%"
            })
        
        # Score de santé global (0-100)
        health_score = 100
        health_score -= min((taux_occupation - 0.6) * 100, 30)
        health_score -= min((tension_personnel - 0.8) * 50, 30)
        health_score -= min(abs(trend_occupation) * 0.5, 20)
        health_score = max(health_score, 0)
        
        return {
            'admissions_24h': admissions_24h,
            'taux_occupation': taux_occupation,
            'tension_personnel': tension_personnel,
            'trend_admissions': trend_admissions,
            'trend_occupation': trend_occupation,
            'alertes': alertes,
            'health_score': health_score,
            'timestamp': datetime.now()
        }
    

    def get_service_breakdown(self):
        """Répartition par service (Avec traduction automatique des codes numériques)"""
        recent = self.df.tail(30).copy()
        
        if 'service_code' not in recent.columns:
            return None
        
        # Mapping de secours (basé sur ton injecteur de données)
        # Permet de retraduire 0, 1, 2 en noms lisibles si l'IA a encodé les données
        SERVICE_MAP = {
            0: "URG", 1: "MED", 2: "PED", 
            3: "REA", 4: "INF", 5: "ISO", 
            6: "CAR", 7: "NEU", 8: "TRA"
        }
        
        # Agrégation
        service_stats = recent.groupby('service_code', as_index=True).agg({
            'taux_occupation': 'mean',
            'tension_personnel': 'mean',
            'nb_admissions': 'sum'
        }).round(4)
        
        # --- BLOC DE CORRECTION D'AFFICHAGE ---
        # Si l'index est numérique (ex: 0, 1, 2), on applique le mapping
        if pd.api.types.is_numeric_dtype(service_stats.index):
            # On essaie de traduire, sinon on met "Svc N" pour ne pas planter
            new_index = service_stats.index.map(lambda x: SERVICE_MAP.get(int(x), f"Svc {x}"))
            service_stats.index = new_index
        # --------------------------------------
        
        service_stats.columns = ['Taux Occupation', 'Tension Personnel', 'Admissions (30j)']
        service_stats = service_stats.sort_values('Taux Occupation', ascending=False)
        
        return service_stats
    
    def predict_next_48h(self):
        """Prédiction 48h avec niveau de confiance"""
        
        future_dates, predictions, conf = self.forecaster.generate_future_forecast_recursive(months=1)
        
        # On ne garde que les 2 premiers jours
        next_48h = {
            'dates': future_dates[:2],
            'predictions': predictions[:2],
            'lower': conf['lower'][:2],
            'upper': conf['upper'][:2]
        }
        
        # Détection d'anomalies prévues
        current_avg = self.df['nb_admissions'].tail(7).mean()
        anomalies_48h = []
        
        for i, pred in enumerate(next_48h['predictions']):
            if pred > current_avg * 1.3:
                anomalies_48h.append({
                    'jour': i + 1,
                    'valeur': pred,
                    'ecart_pct': ((pred / current_avg) - 1) * 100
                })
        
        return next_48h, anomalies_48h


# =====================================================
# ============= INTERFACE STREAMLIT ===================
# =====================================================

def show_dashboard(client, sheet_name):
    """
    Cockpit de Direction Niveau Palantir Gotham.
    """
    
    st.markdown("# COCKPIT DE DIRECTION")
    st.caption("Supervision Temps Réel & Simulation Stratégique")
    
    # Vérification données
    if 'ml_features' not in st.session_state or 'forecaster' not in st.session_state:
        st.error("DONNEES ML OU MODELE MANQUANT. Executer d'abord Feature Engineering et Forecasting.")
        return
    
    df = st.session_state['ml_features']
    forecaster = st.session_state['forecaster']
    
    # Initialisation des moteurs
    monitor = RealtimeMonitor(df, forecaster)
    simulator = CrisisSimulator(forecaster, df)
    
    # ===== ONGLETS PRINCIPAUX =====
    tab1, tab2 = st.tabs([
        "Supervision Temps Reel",
        "Simulateur de Crise"
    ])
    
    # ================================================================
    # ONGLET 1 : SUPERVISION TEMPS RÉEL
    # ================================================================
    with tab1:
        
        # ===== KPI HEADER =====
        st.markdown("### Indicateurs Stratégiques")
        
        state = monitor.current_state
        
        col1, col2, col3, col4 = st.columns(4)
        
        # Taux Occupation
        occupation_color = "normal"
        if state['taux_occupation'] > 0.85:
            occupation_color = "inverse"
        elif state['taux_occupation'] > 0.75:
            occupation_color = "off"
        
        col1.metric(
            "Taux Occupation",
            f"{state['taux_occupation']*100:.1f}%",
            f"{state['trend_occupation']:+.1f}%",
            delta_color=occupation_color
        )
        
        # Admissions
        col2.metric(
            "Admissions (Total)",
            f"{int(df['nb_admissions'].sum()):,}",
            help="Cumul toutes périodes"
        )
        
        # Services Tendus
        services_data = monitor.get_service_breakdown()
        if services_data is not None:
            services_tendus = (services_data['Tension Personnel'] > 1.0).sum()
        else:
            services_tendus = 0
        
        alertes_color = "normal"
        if services_tendus > 5:
            alertes_color = "inverse"
        elif services_tendus > 2:
            alertes_color = "off"
        
        col3.metric(
            "Services Tendus",
            services_tendus,
            delta_color=alertes_color,
            help="Services avec tension personnel > 1.0"
        )
        
        # Ruptures Stock
        col4.metric(
            "Ruptures Stock",
            "0",
            delta_color="normal",
            help="Alertes stock critiques"
        )
        
        st.divider()
        
        # ===== GRAPHIQUES PRINCIPAUX =====
        
        col_left, col_right = st.columns([2, 1])
        
        with col_left:
            st.markdown("### Taux d'Occupation : Realite vs IA")
            
            # Graphique historique + prédiction 48h
            hist = df.tail(90)
            next_48h, anomalies_48h = monitor.predict_next_48h()
            
            fig = go.Figure()
            
            # Historique
            fig.add_trace(go.Scatter(
                x=hist['date'],
                y=hist['taux_occupation'] * 100,
                name="Historique",
                line=dict(color='#4A9EFF', width=2),
                mode='lines'
            ))
            
            # Ligne de saturation
            fig.add_hline(
                y=100,
                line_dash="dash",
                line_color="#FF4444",
                annotation_text="Saturation",
                annotation_position="right"
            )
            
            # Prédiction 48h
            fig.add_trace(go.Scatter(
                x=next_48h['dates'],
                y=[p * 100 for p in next_48h['predictions']],
                name="Tendance IA",
                line=dict(color='#00FF88', width=3, dash='dot'),
                mode='lines+markers',
                marker=dict(size=8)
            ))
            
            fig.update_layout(
                template="plotly_dark",
                height=400,
                hovermode="x unified",
                xaxis_title="",
                yaxis_title="Taux Occupation (%)",
                showlegend=True,
                legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
            )
            
            st.plotly_chart(fig, use_container_width=True)
        
        with col_right:
            st.markdown("### Etat Services (31/12)")
            
            if services_data is not None:
                # Affichage sous forme de barres horizontales
                services_top = services_data.head(9)
                
                fig_services = go.Figure()
                
                # Barres de taux d'occupation
                colors = []
                for val in services_top['Taux Occupation']:
                    if val > 0.85:
                        colors.append('#FF4444')
                    elif val > 0.75:
                        colors.append('#FFA500')
                    else:
                        colors.append('#00FF88')
                
                fig_services.add_trace(go.Bar(
                    y=services_top.index,
                    x=services_top['Taux Occupation'] * 100,
                    orientation='h',
                    marker=dict(color=colors),
                    text=[f"{v*100:.1f}%" for v in services_top['Taux Occupation']],
                    textposition='inside',
                    textfont=dict(color='white', size=11),
                    showlegend=False
                ))
                
                fig_services.update_layout(
                    template="plotly_dark",
                    height=400,
                    xaxis_title="Taux Occupation (%)",
                    yaxis_title="",
                    xaxis=dict(range=[0, 15]),
                    margin=dict(l=0, r=0, t=20, b=0)
                )
                
                st.plotly_chart(fig_services, use_container_width=True)
            else:
                st.info("Donnees services non disponibles")
        
        st.divider()
        
        # ===== FLASH REPORT & RECOMMANDATIONS =====
        st.markdown("### Flash Report & Recommandations")
        
        # Détermination du statut global
        if state['health_score'] > 80:
            status_label = "NOMINAL"
            status_color = "#00FF88"
            status_icon = "circle"
        elif state['health_score'] > 60:
            status_label = "SOUS SURVEILLANCE"
            status_color = "#FFA500"
            status_icon = "triangle-up"
        else:
            status_label = "SITUATION CRITIQUE"
            status_color = "#FF4444"
            status_icon = "triangle-up"
        
        col_status, col_actions = st.columns([2, 1])
        
        with col_status:
            st.markdown(
                f"<div style='background-color: {status_color}20; border-left: 4px solid {status_color}; "
                f"padding: 15px; border-radius: 5px;'>"
                f"<span style='color: {status_color}; font-size: 14px; font-weight: 600;'>"
                f"{status_icon.upper()} {status_label} : Activite hospitaliere sous controle."
                f"</span></div>",
                unsafe_allow_html=True
            )
            
            st.markdown("")
            
            # Recommandations
            if len(state['alertes']) == 0:
                st.success("Aucune action critique requise a court terme.")
            else:
                st.warning(f"{len(state['alertes'])} alerte(s) detectee(s)")
                
                for alerte in state['alertes']:
                    niveau_emoji = {
                        'CRITICAL': 'red_circle',
                        'WARNING': 'large_orange_diamond'
                    }
                    st.write(f":{niveau_emoji.get(alerte['niveau'], 'white_circle')}: "
                            f"**{alerte['categorie']}** - {alerte['message']}")
        
        with col_actions:
            if st.button("Alerter Equipes", type="primary", use_container_width=True):
                st.success("Notification envoyee aux responsables de services")
            
            if st.button("Export PDF", use_container_width=True):
                st.info("Rapport executif en preparation...")
        
        # ===== PRÉDICTIONS 48H =====
        st.divider()
        st.markdown("### Anticipation 48h")
        
        if anomalies_48h:
            st.warning(f"ALERTE PREDICTIVE : {len(anomalies_48h)} anomalie(s) detectee(s) dans les 48h")
            
            for anom in anomalies_48h:
                st.write(
                    f"J+{anom['jour']} : Pic prevu a {anom['valeur']:.0f} admissions "
                    f"(+{anom['ecart_pct']:.0f}% vs moyenne actuelle)"
                )
        else:
            st.success("Aucune anomalie majeure prevue dans les 48 prochaines heures")
    
    # ================================================================
    # ONGLET 2 : SIMULATEUR DE CRISE
    # ================================================================
    with tab2:
        
        st.markdown("### Bac a Sable (What-If Analysis)")
        
        col_params, col_results = st.columns([1, 2])
        
        with col_params:
            st.markdown("#### 1. Parametres")
            
            st.caption("Modifiez les variables pour voir l'impact futur.")
            
            # Sélection du scénario
            scenario_options = {
                'EPIDEMIE_GRIPPE': 'Epidemie de Grippe Saisonniere',
                'PANDEMIE_COVID': 'Pandemie Type COVID-19',
                'CANICULE': 'Canicule Extreme (>40C)',
                'ACCIDENT_MASSE': 'Accident de Grande Ampleur',
                'GREVE_PERSONNEL': 'Greve du Personnel Soignant',
                'CYBERATTAQUE': 'Cyberattaque Systeme Informatique',
                'RUPTURE_APPROVISIONNEMENT': 'Rupture Critique Approvisionnement'
            }
            
            selected_scenario = st.selectbox(
                "Choc d'Admissions",
                options=list(scenario_options.keys()),
                format_func=lambda x: scenario_options[x],
                index=0
            )
            
            # Intensité
            intensity = st.slider(
                "Intensite",
                min_value=0.5,
                max_value=2.0,
                value=1.0,
                step=0.1,
                help="Multiplicateur d'intensite du scenario"
            )
            
            # Ouverture lits (simulation)
            lits_additionnels = st.slider(
                "Ouverture Lits",
                min_value=-10,
                max_value=20,
                value=0,
                step=1,
                help="Pourcentage de lits supplementaires"
            )
            
            # Impact peak
            st.markdown("#### Impact Peak")
            st.metric("", "+0.0 pts", "Gain", delta_color="normal")
        
        with col_results:
            st.markdown("#### 2. Projection d'Impact (3 Mois)")
            
            # Simulation
            with st.spinner("Calcul de l'impact..."):
                result = simulator.simulate_scenario(selected_scenario, intensity)
            
            # Graphique d'impact
            fig_impact = go.Figure()
            
            # Ligne capacité max
            fig_impact.add_hline(
                y=100,
                line_dash="solid",
                line_color="#FF4444",
                line_width=1,
                annotation_text="Capacite Max",
                annotation_position="right"
            )
            
            # Scénario actuel (baseline)
            fig_impact.add_trace(go.Scatter(
                x=result['dates'],
                y=result['baseline'],
                name="Scenario Actuel",
                line=dict(color='gray', width=1, dash='dot'),
                mode='lines',
                opacity=0.6
            ))
            
            # Scénario simulé
            fig_impact.add_trace(go.Scatter(
                x=result['dates'],
                y=result['crisis'],
                name="Scenario Simule",
                line=dict(color='#00FF88', width=3),
                mode='lines',
                fill='tonexty'
            ))
            
            fig_impact.update_layout(
                template="plotly_dark",
                height=400,
                xaxis_title="",
                yaxis_title="Impact sur le Taux d'Occupation",
                showlegend=True,
                hovermode="x unified"
            )
            
            st.plotly_chart(fig_impact, use_container_width=True)
        
        # ===== RÉSULTAT DE LA SIMULATION =====
        st.divider()
        
        metrics = result['metrics']
        
        # Message de robustesse
        if metrics['criticite'] == 'CRITICAL':
            st.error(
                f"CRITIQUE : L'hopital NE PEUT PAS absorber ce choc. "
                f"Occupation prevue : {metrics['occupation_crisis']*100:.0f}% "
                f"(max: {metrics['admissions_peak']:.0f} admissions/jour)."
            )
        elif metrics['criticite'] == 'HIGH':
            st.warning(
                f"ATTENTION : L'hopital est en tension elevee. "
                f"Occupation prevue : {metrics['occupation_crisis']*100:.0f}%."
            )
        else:
            st.success(
                f"ROBUSTE : L'hopital tient le choc ({metrics['occupation_crisis']*100:.0f}% max)."
            )
        
        # ===== RECOMMANDATIONS AUTOMATIQUES =====
        st.markdown("### Recommandations Strategiques")
        
        if result['recommendations']:
            
            # Tri par priorité
            priority_order = {'IMMEDIATE': 0, 'URGENT': 1, 'NORMAL': 2}
            sorted_recs = sorted(
                result['recommendations'],
                key=lambda x: priority_order.get(x['priorite'], 3)
            )
            
            for rec in sorted_recs:
                priority_color = {
                    'IMMEDIATE': '#FF4444',
                    'URGENT': '#FFA500',
                    'NORMAL': '#4A9EFF'
                }
                
                color = priority_color.get(rec['priorite'], '#888888')
                
                st.markdown(
                    f"<div style='background-color: {color}20; border-left: 4px solid {color}; "
                    f"padding: 12px; margin-bottom: 10px; border-radius: 4px;'>"
                    f"<div style='color: {color}; font-weight: 600; margin-bottom: 5px;'>"
                    f"{rec['categorie']} - {rec['priorite']}</div>"
                    f"<div style='color: #CCCCCC; font-size: 14px; margin-bottom: 5px;'>"
                    f"<strong>Action :</strong> {rec['action']}</div>"
                    f"<div style='color: #999999; font-size: 12px;'>"
                    f"<em>{rec['justification']}</em></div>"
                    f"</div>",
                    unsafe_allow_html=True
                )
        else:
            st.info("Aucune recommandation critique pour ce scenario")


# Point d'entrée principal
if __name__ == "__main__":
    show_dashboard(None, None)