Update src/module/Indicateurs_DQ.py

src/module/Indicateurs_DQ.py

@@ -1,14 +1,27 @@
 """
-MODULE: INDICATEURS DATA QUALITY (DQ)
-=====================================
-Responsabilité : Audit, Détection d'anomalies, Visualisation des erreurs.
-Ne modifie pas les données, les juge.
+MODULE: DATA QUALITY DASHBOARD - VERSION AMÉLIORÉE
+===================================================
+Responsabilité : Audit complet, détection d'anomalies, analyses spécifiques hospitalières.
+Style : Gotham UI + Analyses médicales avancées
+
+Améliorations :
+- Chargement direct depuis Excel (pas de filtrage ETL)
+- 6 sections complètes d'analyse DQ
+- Métriques hospitalières spécifiques
+- Visualisations enrichies
+- Analyses temporelles des anomalies
 """
+
 import streamlit as st
 import pandas as pd
+import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
-from module.Validation_Contract import ETL_Engine
+from plotly.subplots import make_subplots
+from datetime import datetime
+import warnings
+warnings.filterwarnings('ignore')
+
 
 # =====================================================
 # ================== OUTILS SÉCURITÉ ==================
@@ -45,203 +58,709 @@ def safe_pct(num, den):
 
 
 # =====================================================
-# ================= DASHBOARD DATA QUALITY ============
+# ================= CHARGEMENT DONNÉES ================
 # =====================================================
 
-def show_dq_dashboard(client, sheet_name):
-    st.markdown("## 🛡️ CENTRE DE CONTRÔLE DATA QUALITY")
+@st.cache_data(ttl=3600)
+def load_excel_data_direct(file_path: str) -> dict:
+    """
+    Charge DIRECTEMENT depuis Excel sans passer par ETL.
+    Garantit qu'aucune anomalie n'est filtrée.
+    """
+    sheets = {}
+    try:
+        # Chargement de toutes les feuilles nécessaires
+        sheets['patients'] = pd.read_excel(file_path, sheet_name='patients')
+        sheets['sejours'] = pd.read_excel(file_path, sheet_name='sejours')
+        sheets['ressources_jour'] = pd.read_excel(file_path, sheet_name='ressources_jour')
+        sheets['stock_materiel_jour'] = pd.read_excel(file_path, sheet_name='stock_materiel_jour')
+        sheets['admissions_jour'] = pd.read_excel(file_path, sheet_name='admissions_jour')
+        sheets['scenarios_calendrier'] = pd.read_excel(file_path, sheet_name='scenarios_calendrier')
+        
+        # Conversion des dates
+        for sheet_name, df in sheets.items():
+            if 'date' in df.columns:
+                df['date'] = pd.to_datetime(df['date'], errors='coerce')
+            if 'date_entree' in df.columns:
+                df['date_entree'] = pd.to_datetime(df['date_entree'], errors='coerce')
+            if 'date_sortie' in df.columns:
+                df['date_sortie'] = pd.to_datetime(df['date_sortie'], errors='coerce')
+            if 'date_naissance' in df.columns:
+                df['date_naissance'] = pd.to_datetime(df['date_naissance'], errors='coerce')
+        
+        return sheets
+    except Exception as e:
+        st.error(f"❌ Erreur chargement Excel : {str(e)}")
+        return {}
 
-    # ================= CHARGEMENT ETL =================
-    etl = ETL_Engine(client, sheet_name)
 
-    if 'data_explorer' not in st.session_state or not st.session_state.data_explorer.dataframes:
-        st.info("Chargement des données pour Audit...")
-        success, data_explorer = etl.run_etl()
-        if not success:
-            st.error(f"Erreur chargement : {data_explorer}")
-            return
+# =====================================================
+# ============ ANALYSES DATA QUALITY ==================
+# =====================================================
+
+class HospitalDataQualityAnalyzer:
+    """Analyseur complet de qualité des données hospitalières"""
+    
+    def __init__(self, dataframes: dict):
+        self.df_pat = dataframes.get('patients')
+        self.df_sej = dataframes.get('sejours')
+        self.df_res = dataframes.get('ressources_jour')
+        self.df_stock = dataframes.get('stock_materiel_jour')
+        self.df_adm = dataframes.get('admissions_jour')
+        self.df_scenarios = dataframes.get('scenarios_calendrier')
+        
+        self.metrics = {}
+        self._compute_all_metrics()
+    
+    def _compute_all_metrics(self):
+        """Calcul de toutes les métriques DQ"""
+        
+        # ============= PATIENTS =============
+        if self.df_pat is not None and not self.df_pat.empty:
+            self.metrics['patients'] = {
+                'total': len(self.df_pat),
+                'anomalies': safe_int(self.df_pat['dq_is_anomaly'].sum()),
+                'doublons': safe_int(self.df_pat.duplicated(subset=['nom', 'prenom']).sum()),
+                'ages_negatifs': safe_int((self.df_pat['age'] < 0).sum()),
+                'ages_aberrants': safe_int((self.df_pat['age'] > 120).sum()),
+                'missing_birth': safe_int(self.df_pat['date_naissance'].isnull().sum()),
+                'missing_ville': safe_int(self.df_pat['ville'].isnull().sum()),
+                'missing_total': safe_int(self.df_pat.isnull().sum().sum())
+            }
+        else:
+            self.metrics['patients'] = {k: 0 for k in ['total', 'anomalies', 'doublons', 'ages_negatifs', 
+                                                       'ages_aberrants', 'missing_birth', 'missing_ville', 'missing_total']}
+        
+        # ============= SÉJOURS =============
+        if self.df_sej is not None and not self.df_sej.empty:
+            dates_inversees = safe_int((self.df_sej['date_sortie'] < self.df_sej['date_entree']).sum())
+            gravite_aberrante = safe_int(((self.df_sej['gravite_1_5'] > 5) | (self.df_sej['gravite_1_5'] < 0)).sum())
+            
+            self.metrics['sejours'] = {
+                'total': len(self.df_sej),
+                'anomalies': safe_int(self.df_sej['dq_is_anomaly'].sum()),
+                'dates_inversees': dates_inversees,
+                'gravite_aberrante': gravite_aberrante,
+                'equipement_manquant': safe_int(self.df_sej['equipement_principal_code'].isnull().sum()),
+                'missing_total': safe_int(self.df_sej.isnull().sum().sum())
+            }
+        else:
+            self.metrics['sejours'] = {k: 0 for k in ['total', 'anomalies', 'dates_inversees', 
+                                                      'gravite_aberrante', 'equipement_manquant', 'missing_total']}
+        
+        # ============= RESSOURCES =============
+        if self.df_res is not None and not self.df_res.empty:
+            df_res_temp = self.df_res.copy()
+            df_res_temp['lits_occupes_num'] = pd.to_numeric(df_res_temp['lits_occupes'], errors='coerce').fillna(0)
+            suroccupation = safe_int((df_res_temp['lits_occupes_num'] > df_res_temp['lits_total']).sum())
+            
+            self.metrics['ressources'] = {
+                'total': len(self.df_res),
+                'anomalies': safe_int(self.df_res['dq_is_anomaly'].sum()),
+                'suroccupation': suroccupation,
+                'missing_total': safe_int(self.df_res.isnull().sum().sum())
+            }
+        else:
+            self.metrics['ressources'] = {k: 0 for k in ['total', 'anomalies', 'suroccupation', 'missing_total']}
+        
+        # ============= STOCK =============
+        if self.df_stock is not None and not self.df_stock.empty:
+            self.metrics['stock'] = {
+                'total': len(self.df_stock),
+                'anomalies': safe_int(self.df_stock['dq_is_anomaly'].sum()),
+                'alertes': safe_int((self.df_stock['alerte_stock'] == 1).sum()),
+                'missing_total': safe_int(self.df_stock.isnull().sum().sum())
+            }
+        else:
+            self.metrics['stock'] = {k: 0 for k in ['total', 'anomalies', 'alertes', 'missing_total']}
+    
+    def get_anomalies_by_type(self, df_name: str):
+        """Récupère le détail des anomalies par type"""
+        df = getattr(self, f'df_{df_name}', None)
+        
+        if df is None or 'dq_anomaly_type' not in df.columns:
+            return pd.DataFrame()
+        
+        anomalies = df[df['dq_is_anomaly'] == 1]
+        
+        if anomalies.empty:
+            return pd.DataFrame()
         
-        data = data_explorer.dataframes
+        anomaly_counts = anomalies['dq_anomaly_type'].value_counts().reset_index()
+        anomaly_counts.columns = ['Type Anomalie', 'Nombre']
+        
+        return anomaly_counts
+    
+    def get_temporal_anomalies(self, df_name: str):
+        """Analyse temporelle des anomalies"""
+        df = getattr(self, f'df_{df_name}', None)
+        
+        if df is None or 'date' not in df.columns or 'dq_is_anomaly' not in df.columns:
+            return None
+        
+        # Groupement par date
+        temp_anomalies = df.groupby(df['date'].dt.to_period('M'))['dq_is_anomaly'].agg(['sum', 'count']).reset_index()
+        temp_anomalies['date'] = temp_anomalies['date'].dt.to_timestamp()
+        temp_anomalies['pourcentage'] = (temp_anomalies['sum'] / temp_anomalies['count']) * 100
+        
+        return temp_anomalies
+    
+    def get_service_quality_stats(self):
+        """Statistiques de qualité par service"""
+        if self.df_sej is None:
+            return None
+        
+        service_stats = self.df_sej.groupby('service_code').agg({
+            'stay_id': 'count',
+            'dq_is_anomaly': 'sum',
+            'duree_sejour_jours': 'mean',
+            'gravite_1_5': 'mean'
+        }).reset_index()
+        
+        service_stats.columns = ['Service', 'Nb Séjours', 'Anomalies', 'Durée Moy', 'Gravité Moy']
+        service_stats['Taux Anomalie %'] = (service_stats['Anomalies'] / service_stats['Nb Séjours']) * 100
+        
+        return service_stats.round(2)
+    
+    def compute_global_score(self):
+        """Calcul du score global DQ"""
+        
+        # Complétude
+        total_rows = (self.metrics['patients']['total'] + 
+                     self.metrics['sejours']['total'] + 
+                     self.metrics['ressources']['total'])
+        
+        total_missing = (self.metrics['patients']['missing_total'] + 
+                        self.metrics['sejours']['missing_total'] + 
+                        self.metrics['ressources']['missing_total'])
+        
+        completeness_score = safe_pct(total_rows - total_missing, total_rows)
+        
+        # Exactitude
+        total_all_rows = (self.metrics['patients']['total'] + 
+                         self.metrics['sejours']['total'] + 
+                         self.metrics['ressources']['total'] + 
+                         self.metrics['stock']['total'])
+        
+        total_anomalies = (self.metrics['patients']['anomalies'] + 
+                          self.metrics['sejours']['anomalies'] + 
+                          self.metrics['ressources']['anomalies'] + 
+                          self.metrics['stock']['anomalies'])
+        
+        accuracy_score = safe_pct(total_all_rows - total_anomalies, total_all_rows)
+        
+        # Score global
+        global_score = round((completeness_score + accuracy_score) / 2, 2)
+        
+        return {
+            'completeness': completeness_score,
+            'accuracy': accuracy_score,
+            'global': global_score
+        }
 
-    else:
-        data = st.session_state.data_explorer.dataframes
 
-    # ================= RÉCUPÉRATION TABLES =============
-    df_pat = data.get('patients')
-    df_sej = data.get('sejours')
-    df_res = data.get('ressources_jour')
-    df_stock = data.get('stock_materiel_jour')
+# =====================================================
+# ============== VISUALISATIONS =======================
+# =====================================================
 
-    # ================= NORMALISATION DQ ================
-    for df in [df_pat, df_sej, df_res, df_stock]:
-        if df is not None and 'dq_is_anomaly' in df.columns:
-            df['dq_is_anomaly'] = (df['dq_is_anomaly'] == 1).astype(int)
+def plot_anomalies_distribution(analyzer: HospitalDataQualityAnalyzer):
+    """Graphique de distribution des anomalies par table"""
+    
+    data = {
+        'Table': ['Patients', 'Séjours', 'Ressources', 'Stock'],
+        'Anomalies': [
+            analyzer.metrics['patients']['anomalies'],
+            analyzer.metrics['sejours']['anomalies'],
+            analyzer.metrics['ressources']['anomalies'],
+            analyzer.metrics['stock']['anomalies']
+        ],
+        'Total': [
+            analyzer.metrics['patients']['total'],
+            analyzer.metrics['sejours']['total'],
+            analyzer.metrics['ressources']['total'],
+            analyzer.metrics['stock']['total']
+        ]
+    }
+    
+    df_plot = pd.DataFrame(data)
+    df_plot['Pourcentage'] = (df_plot['Anomalies'] / df_plot['Total']) * 100
+    
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=('Nombre d\'Anomalies', 'Taux d\'Anomalies (%)'),
+        specs=[[{"type": "bar"}, {"type": "bar"}]]
+    )
+    
+    # Nombre absolu
+    fig.add_trace(
+        go.Bar(
+            x=df_plot['Table'],
+            y=df_plot['Anomalies'],
+            text=df_plot['Anomalies'],
+            textposition='outside',
+            marker_color='crimson',
+            name='Anomalies'
+        ),
+        row=1, col=1
+    )
+    
+    # Pourcentage
+    fig.add_trace(
+        go.Bar(
+            x=df_plot['Table'],
+            y=df_plot['Pourcentage'],
+            text=[f"{x:.2f}%" for x in df_plot['Pourcentage']],
+            textposition='outside',
+            marker_color='orange',
+            name='Taux %'
+        ),
+        row=1, col=2
+    )
+    
+    fig.update_layout(
+        height=400,
+        showlegend=False,
+        title_text="📊 Distribution des Anomalies par Table"
+    )
+    
+    return fig
+
+
+def plot_temporal_anomalies(analyzer: HospitalDataQualityAnalyzer):
+    """Évolution temporelle des anomalies pour séjours"""
+    
+    temp_data = analyzer.get_temporal_anomalies('sej')
+    
+    if temp_data is None or temp_data.empty:
+        return None
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=temp_data['date'],
+        y=temp_data['pourcentage'],
+        mode='lines+markers',
+        name='Taux Anomalies',
+        line=dict(color='red', width=2),
+        marker=dict(size=8)
+    ))
+    
+    fig.update_layout(
+        title="📈 Évolution Temporelle des Anomalies (Séjours)",
+        xaxis_title="Date",
+        yaxis_title="Taux d'Anomalies (%)",
+        height=400,
+        hovermode='x unified'
+    )
+    
+    return fig
+
+
+def plot_service_quality_heatmap(analyzer: HospitalDataQualityAnalyzer):
+    """Heatmap de qualité par service"""
+    
+    service_stats = analyzer.get_service_quality_stats()
+    
+    if service_stats is None or service_stats.empty:
+        return None
+    
+    fig = px.bar(
+        service_stats.sort_values('Taux Anomalie %', ascending=False).head(10),
+        x='Service',
+        y='Taux Anomalie %',
+        color='Taux Anomalie %',
+        color_continuous_scale='Reds',
+        title="🏥 Taux d'Anomalies par Service (Top 10)",
+        text='Taux Anomalie %'
+    )
+    
+    fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+    fig.update_layout(height=450)
+    
+    return fig
+
+
+def plot_completeness_radar(analyzer: HospitalDataQualityAnalyzer):
+    """Radar chart de complétude par dimension"""
+    
+    metrics = analyzer.metrics
+    
+    # Calcul des complétudes
+    patient_completeness = 100 - safe_pct(metrics['patients']['missing_total'], 
+                                          metrics['patients']['total'] * len(analyzer.df_pat.columns) if analyzer.df_pat is not None else 1)
+    sejour_completeness = 100 - safe_pct(metrics['sejours']['missing_total'], 
+                                        metrics['sejours']['total'] * len(analyzer.df_sej.columns) if analyzer.df_sej is not None else 1)
+    ressource_completeness = 100 - safe_pct(metrics['ressources']['missing_total'], 
+                                           metrics['ressources']['total'] * len(analyzer.df_res.columns) if analyzer.df_res is not None else 1)
+    stock_completeness = 100 - safe_pct(metrics['stock']['missing_total'], 
+                                       metrics['stock']['total'] * len(analyzer.df_stock.columns) if analyzer.df_stock is not None else 1)
+    
+    categories = ['Patients', 'Séjours', 'Ressources', 'Stock']
+    values = [patient_completeness, sejour_completeness, ressource_completeness, stock_completeness]
+    values.append(values[0])  # Fermeture
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatterpolar(
+        r=values,
+        theta=categories + [categories[0]],
+        fill='toself',
+        name='Complétude',
+        line_color='cyan'
+    ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, 100]
+            )
+        ),
+        showlegend=False,
+        title="🎯 Radar de Complétude des Données",
+        height=400
+    )
+    
+    return fig
 
 
+# =====================================================
+# ================= DASHBOARD PRINCIPAL ===============
+# =====================================================
+
+def show_enhanced_dq_dashboard():
+    """
+    Dashboard Data Quality amélioré avec toutes les sections.
+    """
+    st.markdown("## 🛡️ CENTRE DE CONTRÔLE DATA QUALITY")
+    st.caption("Analyse complète de la qualité des données hospitalières")
+    
+    # ================= UPLOAD FICHIER =================
+    st.sidebar.header("⚙️ Configuration")
+    
+    uploaded_file = st.sidebar.file_uploader(
+        "Charger le fichier Excel",
+        type=['xlsx'],
+        help="Fichier bdd_mvp_faker.xlsx"
+    )
+    
+    if uploaded_file is None:
+        st.info("👈 Veuillez charger le fichier Excel dans la barre latérale")
+        return
+    
+    # ================= CHARGEMENT =================
+    with st.spinner("🔄 Chargement des données..."):
+        dataframes = load_excel_data_direct(uploaded_file)
+    
+    if not dataframes:
+        st.error("❌ Erreur lors du chargement des données")
+        return
+    
+    # ================= ANALYSE =================
+    analyzer = HospitalDataQualityAnalyzer(dataframes)
+    scores = analyzer.compute_global_score()
+    
+    st.success(f"✅ Données chargées : {sum(m['total'] for m in analyzer.metrics.values()):,} lignes au total")
+    
     # ==================================================
     # ================= KPI GLOBAUX ====================
     # ==================================================
     st.markdown("### 📊 Synthèse de Santé des Données")
+    
     col1, col2, col3, col4 = st.columns(4)
-
-    # ---------------- PATIENTS ----------------
-    if df_pat is not None and not df_pat.empty:
-        anomalies_patients = int((df_pat['dq_is_anomaly'] == 1).sum())
-        doublons = int(df_pat.duplicated(subset=['nom', 'prenom']).sum())
-        ages_negatifs = int((df_pat['age'] < 0).sum())
-        ages_aberrants = int((df_pat['age'] > 120).sum())
-        missing_birth = int(df_pat['date_naissance'].isnull().sum())
-        missing_ville = int(df_pat['ville'].isnull().sum())
-        total_patients = len(df_pat)
-    else:
-        anomalies_patients = doublons = ages_negatifs = ages_aberrants = missing_birth = missing_ville = total_patients = 0
-
-    # ---------------- SÉJOURS -----------------
-    if df_sej is not None and not df_sej.empty:
-        anomalies_sejours = int((df_sej['dq_is_anomaly'] == 1).sum())
-        dates_inversees = int((df_sej['date_sortie'] < df_sej['date_entree']).sum())
-        gravite_aberrante = int(((df_sej['gravite_1_5'] > 5) | (df_sej['gravite_1_5'] < 1)).sum())
-        equipement_manquant = int(df_sej['equipement_principal_code'].isnull().sum())
-        total_sejours = len(df_sej)
-    else:
-        anomalies_sejours = dates_inversees = gravite_aberrante = equipement_manquant = total_sejours = 0
-
-    # ---------------- RESSOURCES ----------------
-    if df_res is not None and not df_res.empty:
-        anomalies_ressources = int((df_res['dq_is_anomaly'] == 1).sum())
-        df_res['lits_occupes_num'] = pd.to_numeric(df_res['lits_occupes'], errors='coerce').fillna(0)
-        suroccupation = int((df_res['lits_occupes_num'] > df_res['lits_total']).sum())
-        total_ressources = len(df_res)
-    else:
-        anomalies_ressources = suroccupation = total_ressources = 0
-
-    # ---------------- STOCK --------------------
-    if df_stock is not None and not df_stock.empty:
-        anomalies_stock = int((df_stock['dq_is_anomaly'] == 1).sum())
-        total_stock = len(df_stock)
-    else:
-        anomalies_stock = total_stock = 0
-
-    # ---------------- POURCENTAGES -------------
-    pct_anom_pat = safe_pct(anomalies_patients, total_patients)
-    pct_anom_sej = safe_pct(anomalies_sejours, total_sejours)
-    pct_anom_res = safe_pct(anomalies_ressources, total_ressources)
-    pct_anom_stock = safe_pct(anomalies_stock, total_stock)
-
-    col1.metric("🔴 Anomalies Patients", f"{anomalies_patients:,}", f"{pct_anom_pat}%", delta_color="inverse")
-    col2.metric("🔴 Anomalies Séjours", f"{anomalies_sejours:,}", f"{pct_anom_sej}%", delta_color="inverse")
-    col3.metric("🔴 Anomalies Ressources", f"{anomalies_ressources:,}", f"{pct_anom_res}%", delta_color="inverse")
-    col4.metric("🔴 Anomalies Stock", f"{anomalies_stock:,}", f"{pct_anom_stock}%", delta_color="inverse")
-
+    
+    metrics = analyzer.metrics
+    
+    col1.metric(
+        "🔴 Anomalies Patients", 
+        f"{metrics['patients']['anomalies']:,}",
+        f"{safe_pct(metrics['patients']['anomalies'], metrics['patients']['total'])}%",
+        delta_color="inverse"
+    )
+    
+    col2.metric(
+        "🔴 Anomalies Séjours",
+        f"{metrics['sejours']['anomalies']:,}",
+        f"{safe_pct(metrics['sejours']['anomalies'], metrics['sejours']['total'])}%",
+        delta_color="inverse"
+    )
+    
+    col3.metric(
+        "🔴 Anomalies Ressources",
+        f"{metrics['ressources']['anomalies']:,}",
+        f"{safe_pct(metrics['ressources']['anomalies'], metrics['ressources']['total'])}%",
+        delta_color="inverse"
+    )
+    
+    col4.metric(
+        "🔴 Anomalies Stock",
+        f"{metrics['stock']['anomalies']:,}",
+        f"{safe_pct(metrics['stock']['anomalies'], metrics['stock']['total'])}%",
+        delta_color="inverse"
+    )
+    
+    # Graphique distribution anomalies
+    st.plotly_chart(plot_anomalies_distribution(analyzer), use_container_width=True)
+    
     st.divider()
-
+    
     # ==================================================
-    # ================= COMPLÉTUDE =====================
+    # ========== 1️⃣ COMPLÉTUDE DES DONNÉES ============
     # ==================================================
     st.subheader("1️⃣ Complétude des Données (Missing Values)")
+    
     tab1, tab2, tab3, tab4 = st.tabs(["📋 Patients", "🏥 Séjours", "⚕️ Ressources", "📦 Stock"])
-
-    with tab1:
-        if df_pat is not None and not df_pat.empty:
-            total_missing_cells = int(df_pat.isnull().sum().sum())
-            st.caption(f"Total cellules manquantes : {total_missing_cells}")
+    
+    for tab, df_name, df in [(tab1, 'Patients', analyzer.df_pat), 
+                             (tab2, 'Séjours', analyzer.df_sej),
+                             (tab3, 'Ressources', analyzer.df_res),
+                             (tab4, 'Stock', analyzer.df_stock)]:
+        with tab:
+            if df is not None and not df.empty:
+                missing_df = (df.isnull().mean() * 100).reset_index()
+                missing_df.columns = ['Colonne', 'Pourcentage Manquant']
+                missing_df = missing_df[missing_df['Pourcentage Manquant'] > 0]
+                
+                if not missing_df.empty:
+                    st.caption(f"📊 {len(missing_df)} colonnes avec données manquantes")
+                    
+                    fig = px.bar(
+                        missing_df.sort_values('Pourcentage Manquant', ascending=False),
+                        x='Colonne', 
+                        y='Pourcentage Manquant',
+                        title=f"Données manquantes - {df_name}",
+                        color='Pourcentage Manquant',
+                        color_continuous_scale='Reds',
+                        text='Pourcentage Manquant'
+                    )
+                    fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
+                    fig.update_layout(xaxis_tickangle=-45, height=400)
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.success(f"✅ Aucune donnée manquante dans {df_name}")
+            else:
+                st.warning(f"⚠️ Aucune donnée {df_name} disponible")
+    
+    # Radar de complétude
+    st.plotly_chart(plot_completeness_radar(analyzer), use_container_width=True)
+    
+    st.divider()
+    
+    # ==================================================
+    # ========== 2️⃣ COHÉRENCE DES DONNÉES =============
+    # ==================================================
+    st.subheader("2️⃣ Cohérence et Validité des Données")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### 👥 Cohérence Patients")
+        st.metric("Âges négatifs", metrics['patients']['ages_negatifs'], delta_color="inverse")
+        st.metric("Âges aberrants (>120 ans)", metrics['patients']['ages_aberrants'], delta_color="inverse")
+        st.metric("Doublons (nom+prénom)", metrics['patients']['doublons'], delta_color="inverse")
+    
+    with col2:
+        st.markdown("#### 🏥 Cohérence Séjours")
+        st.metric("Dates inversées (sortie < entrée)", metrics['sejours']['dates_inversees'], delta_color="inverse")
+        st.metric("Gravité aberrante (<0 ou >5)", metrics['sejours']['gravite_aberrante'], delta_color="inverse")
+        st.metric("Équipement manquant", metrics['sejours']['equipement_manquant'], delta_color="inverse")
+    
+    # Graphique qualité par service
+    fig_service = plot_service_quality_heatmap(analyzer)
+    if fig_service:
+        st.plotly_chart(fig_service, use_container_width=True)
+    
+    st.divider()
+    
+    # ==================================================
+    # ========== 3️⃣ ANALYSE DES ANOMALIES =============
+    # ==================================================
+    st.subheader("3️⃣ Analyse Détaillée des Anomalies")
+    
+    tab1, tab2, tab3, tab4 = st.tabs(["📋 Patients", "🏥 Séjours", "⚕️ Ressources", "📦 Stock"])
+    
+    for tab, df_label in [(tab1, 'pat'), (tab2, 'sej'), (tab3, 'res'), (tab4, 'stock')]:
+        with tab:
+            anomaly_details = analyzer.get_anomalies_by_type(df_label)
             
-            missing_df = (df_pat.isnull().mean() * 100).reset_index()
-            missing_df.columns = ['Colonne', 'Pourcentage Manquant']
-            missing_df = missing_df[missing_df['Pourcentage Manquant'] > 0]
-
-            if not missing_df.empty:
-                fig = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant',
-                             title="Données manquantes - Patients",
-                             color='Pourcentage Manquant', color_continuous_scale='Reds',
-                             text='Pourcentage Manquant')
-                fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-                fig.update_layout(xaxis_tickangle=-45)
+            if not anomaly_details.empty:
+                st.dataframe(anomaly_details, use_container_width=True)
+                
+                fig = px.pie(
+                    anomaly_details,
+                    values='Nombre',
+                    names='Type Anomalie',
+                    title=f"Répartition des Types d'Anomalies"
+                )
                 st.plotly_chart(fig, use_container_width=True)
             else:
-                st.success("✅ Aucune donnée manquante")
-        else:
-            st.warning("Aucune donnée patient disponible")
-
-    with tab2:
-        if df_sej is not None and not df_sej.empty:
-            missing_df = (df_sej.isnull().mean() * 100).reset_index()
-            missing_df.columns = ['Colonne', 'Pourcentage Manquant']
-            missing_df = missing_df[missing_df['Pourcentage Manquant'] > 0]
-            if not missing_df.empty:
-                fig = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant',
-                             title="Données manquantes - Séjours",
-                             color='Pourcentage Manquant', color_continuous_scale='Oranges',
-                             text='Pourcentage Manquant')
-                fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-                fig.update_layout(xaxis_tickangle=-45)
+                st.success(f"✅ Aucune anomalie détectée")
+    
+    # Évolution temporelle
+    fig_temporal = plot_temporal_anomalies(analyzer)
+    if fig_temporal:
+        st.plotly_chart(fig_temporal, use_container_width=True)
+    
+    st.divider()
+    
+    # ==================================================
+    # ========== 4️⃣ SPÉCIFICITÉS HOSPITALIÈRES ========
+    # ==================================================
+    st.subheader("4️⃣ Analyses Spécifiques Hospitalières")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### 🛏️ Ressources")
+        if analyzer.df_res is not None:
+            st.metric("Cas de suroccupation", metrics['ressources']['suroccupation'], delta_color="inverse")
+            
+            # Taux occupation moyen par service
+            if 'service_code' in analyzer.df_res.columns and 'taux_occupation' in analyzer.df_res.columns:
+                taux_moy = analyzer.df_res.groupby('service_code')['taux_occupation'].mean().reset_index()
+                taux_moy.columns = ['Service', 'Taux Occupation Moyen']
+                taux_moy = taux_moy.sort_values('Taux Occupation Moyen', ascending=False)
+                
+                fig = px.bar(
+                    taux_moy.head(10),
+                    x='Service',
+                    y='Taux Occupation Moyen',
+                    title="Top 10 Services - Taux Occupation",
+                    color='Taux Occupation Moyen',
+                    color_continuous_scale='RdYlGn_r'
+                )
                 st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.success("✅ Aucune donnée manquante")
-        else:
-            st.warning("Aucune donnée séjour disponible")
-
-    with tab3:
-        if df_res is not None and not df_res.empty:
-            missing_df = (df_res.isnull().mean() * 100).reset_index()
-            missing_df.columns = ['Colonne', 'Pourcentage Manquant']
-            missing_df = missing_df[missing_df['Pourcentage Manquant'] > 0]
-            if not missing_df.empty:
-                fig = px.bar(missing_df, x='Colonne', y='Pourcentage Manquant',
-                             title="Données manquantes - Ressources",
-                             color='Pourcentage Manquant', color_continuous_scale='Blues',
-                             text='Pourcentage Manquant')
-                fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-                fig.update_layout(xaxis_tickangle=-45)
+    
+    with col2:
+        st.markdown("#### 📦 Stock")
+        st.metric("Alertes stock actives", metrics['stock']['alertes'], delta_color="inverse")
+        
+        # Distribution des alertes par matériel
+        if analyzer.df_stock is not None and 'alerte_stock' in analyzer.df_stock.columns:
+            alertes = analyzer.df_stock[analyzer.df_stock['alerte_stock'] == 1]
+            if not alertes.empty and 'materiel_code' in alertes.columns:
+                alert_counts = alertes['materiel_code'].value_counts().reset_index()
+                alert_counts.columns = ['Matériel', 'Nombre Alertes']
+                
+                fig = px.bar(
+                    alert_counts.head(10),
+                    x='Matériel',
+                    y='Nombre Alertes',
+                    title="Top 10 Matériels en Alerte",
+                    color='Nombre Alertes',
+                    color_continuous_scale='Oranges'
+                )
                 st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.success("✅ Aucune donnée manquante")
-        else:
-            st.warning("Aucune donnée ressource disponible")
-
-    with tab4:
-        if df_stock is not None and not df_stock.empty:
-            missing_df = (df_stock.isnull().mean() * 100).reset_index()
-            missing_df.columns = ['Colonne', 'Pourcentage Manquant']
-            missing_df = missing_df[missing_df['Pourcentage Manquant'] > 0]
-            if not missing_df.empty:
-                st.dataframe(missing_df, use_container_width=True)
-            else:
-                st.success("✅ Aucune donnée manquante")
-        else:
-            st.warning("Aucune donnée stock disponible")
-
+    
+    st.divider()
+    
     # ==================================================
-    # ================= RÉSUMÉ GLOBAL ==================
+    # ========== 5️⃣ RÉSUMÉ EXÉCUTIF ===================
     # ==================================================
-    st.divider()
-    st.subheader("4️⃣ Résumé Exécutif Data Quality")
-
-    total_missing = 0
-    for df in [df_pat, df_sej, df_res]:
-        if df is not None:
-            total_missing += int(df.isnull().sum().sum())
-
-    total_rows = total_patients + total_sejours + total_ressources
-    completeness_score = safe_pct(total_rows - total_missing, total_rows)
-
-    total_anomalies = anomalies_patients + anomalies_sejours + anomalies_ressources + anomalies_stock
-    total_all_rows = total_patients + total_sejours + total_ressources + total_stock
-    accuracy_score = safe_pct(total_all_rows - total_anomalies, total_all_rows)
-
-    global_score = round((completeness_score + accuracy_score) / 2, 2)
-
-    st.metric("Score de complétude", f"{completeness_score}%")
-    st.metric("Score d'exactitude", f"{accuracy_score}%")
-
+    st.subheader("5️⃣ Résumé Exécutif Data Quality")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    col1.metric("Score de Complétude", f"{scores['completeness']:.2f}%")
+    col2.metric("Score d'Exactitude", f"{scores['accuracy']:.2f}%")
+    
+    global_score = scores['global']
+    
     if global_score >= 95:
         status = "🟢 EXCELLENT"
+        color = "green"
     elif global_score >= 85:
         status = "🟡 BON"
+        color = "blue"
     elif global_score >= 70:
         status = "🟠 MOYEN"
+        color = "orange"
     else:
         status = "🔴 CRITIQUE"
-
-    st.markdown(f"### Score Global Data Quality : {global_score}% — {status}")
+        color = "red"
+    
+    col3.markdown(f"**Score Global**")
+    col3.markdown(f"<h2 style='color: {color};'>{global_score:.2f}%</h2>", unsafe_allow_html=True)
+    
+    st.markdown(f"### {status}")
     st.progress(global_score / 100)
+    
+    # Recommandations
+    st.markdown("#### 💡 Recommandations")
+    
+    recommendations = []
+    
+    if metrics['patients']['anomalies'] > 0:
+        recommendations.append(f"⚠️ **{metrics['patients']['anomalies']} anomalies patients** détectées - Vérifier les données de naissance et villes manquantes")
+    
+    if metrics['sejours']['dates_inversees'] > 0:
+        recommendations.append(f"🔴 **{metrics['sejours']['dates_inversees']} séjours avec dates inversées** - Corriger les dates d'entrée/sortie")
+    
+    if metrics['ressources']['suroccupation'] > 0:
+        recommendations.append(f"🚨 **{metrics['ressources']['suroccupation']} cas de suroccupation** - Revoir la capacité des services")
+    
+    if metrics['stock']['alertes'] > 0:
+        recommendations.append(f"📦 **{metrics['stock']['alertes']} alertes stock** - Réapprovisionner les matériels critiques")
+    
+    if global_score < 85:
+        recommendations.append("📊 **Score global < 85%** - Lancer un plan d'action Data Quality urgent")
+    
+    if recommendations:
+        for rec in recommendations:
+            st.markdown(rec)
+    else:
+        st.success("✅ Aucune action critique nécessaire - Qualité des données satisfaisante")
+    
+    st.divider()
+    
+    # ==================================================
+    # ========== 6️⃣ EXPORT DES RÉSULTATS ==============
+    # ==================================================
+    st.subheader("6️⃣ Export et Documentation")
+    
+    # Création du rapport
+    report_data = {
+        'Métrique': [],
+        'Valeur': []
+    }
+    
+    for category, cat_metrics in analyzer.metrics.items():
+        for metric_name, value in cat_metrics.items():
+            report_data['Métrique'].append(f"{category}_{metric_name}")
+            report_data['Valeur'].append(value)
+    
+    # Ajout scores
+    report_data['Métrique'].extend(['score_completeness', 'score_accuracy', 'score_global'])
+    report_data['Valeur'].extend([scores['completeness'], scores['accuracy'], scores['global']])
+    
+    report_df = pd.DataFrame(report_data)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        csv = report_df.to_csv(index=False).encode('utf-8')
+        st.download_button(
+            label="📥 Télécharger Rapport DQ (CSV)",
+            data=csv,
+            file_name=f'data_quality_report_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv',
+            mime='text/csv'
+        )
+    
+    with col2:
+        # Export des anomalies détectées
+        if metrics['patients']['anomalies'] > 0:
+            anomalies_df = analyzer.df_pat[analyzer.df_pat['dq_is_anomaly'] == 1][
+                ['patient_id', 'nom', 'prenom', 'dq_anomaly_type', 'dq_anomaly_detail']
+            ]
+            anomalies_csv = anomalies_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="📥 Télécharger Anomalies Patients (CSV)",
+                data=anomalies_csv,
+                file_name=f'anomalies_patients_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv',
+                mime='text/csv'
+            )
+
+
+# Point d'entrée
+if __name__ == "__main__":
+    show_enhanced_dq_dashboard()