if EDA_AVAILABLE:
    from scipy import stats

    corr_vars = [
        "suren_depot_taux", "chomage_taux", "revenu_median_uc",
        "taux_pauvrete", "rsa_taux", "part_locataires",
        "part_familles_mono", "interdecile_d9d1", "score_fragilite",
    ]
    corr_vars_available = [v for v in corr_vars if v in df_2021.columns]
    df_corr = df_2021[corr_vars_available].copy()

    # Convertir en numérique
    for col in corr_vars_available:
        df_corr[col] = pd.to_numeric(df_corr[col], errors="coerce")
    df_corr = df_corr.dropna(how="all")

    # Filtrer les colonnes avec suffisamment de données
    min_obs = 10
    cols_ok = [
        c for c in corr_vars_available
        if df_corr[c].notna().sum() >= min_obs
    ]
    df_corr = df_corr[cols_ok].dropna()

    if len(df_corr) >= min_obs and len(cols_ok) >= 2:
        # Matrice de corrélation Pearson
        corr_matrix = df_corr.corr(method="pearson")

        # Matrice de p-values
        pval_matrix = pd.DataFrame(
            np.ones_like(corr_matrix),
            index=corr_matrix.index,
            columns=corr_matrix.columns,
        )
        for i in corr_matrix.index:
            for j in corr_matrix.columns:
                if i != j:
                    valid = df_corr[[i, j]].dropna()
                    if len(valid) >= 5:
                        _, p = stats.pearsonr(valid[i], valid[j])
                        pval_matrix.loc[i, j] = p

        # Heatmap
        fig, ax = plt.subplots(figsize=(10, 8))
        im = ax.imshow(
            corr_matrix, cmap="coolwarm", vmin=-1, vmax=1, aspect="auto"
        )
        plt.colorbar(im, ax=ax, label="Coefficient de corrélation de Pearson")

        labels = [v.replace("_", "\n") for v in cols_ok]
        ax.set_xticks(range(len(labels)))
        ax.set_yticks(range(len(labels)))
        ax.set_xticklabels(labels, fontsize=8, rotation=45, ha="right")
        ax.set_yticklabels(labels, fontsize=8)

        # Annotations avec étoiles de significativité
        for i in range(len(corr_matrix)):
            for j in range(len(corr_matrix)):
                val = corr_matrix.iloc[i, j]
                p   = pval_matrix.iloc[i, j]
                star = (
                    "***" if p < 0.001
                    else ("**" if p < 0.01
                    else ("*" if p < 0.05 else ""))
                )
                color = "black" if abs(val) < 0.7 else "white"
                ax.text(
                    j, i, f"{val:.2f}{star}",
                    ha="center", va="center",
                    fontsize=7, color=color,
                )

        ax.set_title(
            f"Matrice de corrélation de Pearson — Variables départementales ({YEAR_TARGET})\n"
            "* p<0,05   ** p<0,01   *** p<0,001",
            fontsize=11, pad=15,
        )
        fig.text(
            0.5, -0.03,
            f"Source : Banque de France, INSEE, DREES — année de référence {YEAR_TARGET}. "
            "Les variables présentant les corrélations les plus fortes avec le taux "
            "de surendettement sont identifiées.",
            ha="center", fontsize=8, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()

        # Tableau récapitulatif
        if "suren_depot_taux" in corr_matrix.columns:
            corr_target = (
                corr_matrix["suren_depot_taux"]
                .drop("suren_depot_taux", errors="ignore")
                .sort_values(key=abs, ascending=False)
            )
            print("\nCorrélations avec le taux de surendettement :")
            print(f"{'Variable':<30} {'r':>8}  {'Sig.'}")
            print("-" * 50)
            for var, corr_val in corr_target.items():
                p   = pval_matrix.loc[var, "suren_depot_taux"]
                sig = (
                    "***" if p < 0.001
                    else ("**" if p < 0.01
                    else ("*" if p < 0.05 else "(ns)"))
                )
                print(f"{var:<30} {corr_val:+8.3f}  {sig}")
    else:
        print(
            f"⚠️ Données insuffisantes pour la matrice de corrélation "
            f"({len(df_corr)} obs., {len(cols_ok)} variables disponibles)."
        )
else:
    print("⚠️ Données EDA non disponibles — exécuter les scripts 01-04 d'abord.")

if EDA_AVAILABLE:
    plot_vars = [
        ("suren_depot_taux",  "Taux de surendettement",     suren_unit_label,       f"BdF {YEAR_TARGET}"),
        ("chomage_taux",      "Taux de chômage",            "%",                    f"INSEE {YEAR_TARGET}"),
        ("taux_pauvrete",     "Taux de pauvreté (seuil 60%)", "%",                  f"FiLoSoFi {YEAR_FILOSOFI}"),
        ("rsa_taux",          "Part allocataires RSA",       "%",                    f"DREES {YEAR_TARGET}"),
        ("part_locataires",   "Part des ménages locataires", "%",                    f"RP {YEAR_TARGET}"),
        ("part_familles_mono","Part familles monoparentales","%",                    f"RP {YEAR_TARGET}"),
    ]

    available_plot_vars = [
        (col, label, unit, src)
        for col, label, unit, src in plot_vars
        if col in df_2021.columns
        and pd.to_numeric(df_2021[col], errors="coerce").notna().sum() >= 10
    ]

    if available_plot_vars:
        n_vars = len(available_plot_vars)
        n_cols = 3
        n_rows = (n_vars + n_cols - 1) // n_cols
        fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 4 * n_rows))
        axes = axes.flatten()

        for idx, (col, label, unit, src) in enumerate(available_plot_vars[:6]):
            ax  = axes[idx]
            data = pd.to_numeric(df_2021[col], errors="coerce").dropna()
            ax.hist(data, bins=20, color=_CYAN, edgecolor="none", alpha=0.8)
            ax.axvline(
                data.median(), color=_AMBER, linestyle="--", linewidth=1.5,
                label=f"Médiane : {data.median():.1f}",
            )
            ax.set_xlabel(f"{label} ({unit})", fontsize=9)
            ax.set_ylabel("Nombre de départements", fontsize=9)
            ax.set_title(label, fontsize=10, fontweight="bold")
            ax.legend(fontsize=8)
            ax.text(
                0.02, 0.98, f"Source : {src}",
                transform=ax.transAxes, fontsize=7, va="top", style="italic",
            )

        # Masquer les axes inutilisés
        for idx in range(len(available_plot_vars), len(axes)):
            axes[idx].set_visible(False)

        fig.suptitle(
            f"Distribution des variables clés par département ({YEAR_TARGET})",
            fontsize=12, fontweight="bold", y=1.02,
        )
        fig.text(
            0.5, -0.01,
            "Les distributions révèlent une forte hétérogénéité territoriale pour "
            "le surendettement et la pauvreté, suggérant des effets de clustering géographique.",
            ha="center", fontsize=9, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()
    else:
        print("⚠️ Aucune variable disponible pour les distributions (données manquantes).")
else:
    print("⚠️ Données EDA non disponibles — exécuter les scripts 01-04 d'abord.")

if DATA_AVAILABLE and len(df) > 0:
    trend_vars = ["suren_depot_taux", "chomage_taux", "taux_pauvrete"]
    available_trend = [v for v in trend_vars if v in df.columns]

    # Convertir en numérique
    for v in available_trend:
        df[v] = pd.to_numeric(df[v], errors="coerce")

    if available_trend and df["annee"].nunique() >= 2:
        trend_data = (
            df.groupby("annee")[available_trend].median().reset_index()
        )

        colors = {
            "suren_depot_taux": _RED,
            "chomage_taux":     _CYAN,
            "taux_pauvrete":    _AMBER,
        }
        labels_fr = {
            "suren_depot_taux": suren_axis_label,
            "chomage_taux":     "Taux de chômage (%)",
            "taux_pauvrete":    "Taux de pauvreté (%)",
        }

        fig, ax = plt.subplots(figsize=(10, 5))
        ax2 = ax.twinx()

        for var in available_trend:
            if trend_data[var].notna().sum() < 2:
                continue
            target_ax = ax2 if var == "suren_depot_taux" else ax
            target_ax.plot(
                trend_data["annee"], trend_data[var],
                marker="o", linewidth=2,
                color=colors.get(var, _CHALK_DIM),
                label=labels_fr.get(var, var),
            )

        ax.set_xlabel("Année", fontsize=10)
        ax.set_ylabel("Taux (%)", fontsize=10)
        ax2.set_ylabel(suren_axis_label, fontsize=10, color=_RED)
        ax2.tick_params(axis="y", labelcolor=_RED)

        # Légende combinée
        lines1, labels1 = ax.get_legend_handles_labels()
        lines2, labels2 = ax2.get_legend_handles_labels()
        ax.legend(lines1 + lines2, labels1 + labels2, loc="upper right", fontsize=9)

        ax.set_title(
            "Évolution médiane des indicateurs départementaux (2019–2024)",
            fontsize=11, fontweight="bold",
        )
        ax.set_xticks(trend_data["annee"])
        ax.grid(axis="y", alpha=0.3)

        fig.text(
            0.5, -0.04,
            "Source : Banque de France, INSEE. Médiane des 96 départements métropolitains. "
            "Le recul du surendettement post-2018 coïncide avec la baisse du chômage.",
            ha="center", fontsize=8, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()

    elif available_trend:
        print(
            f"⚠️ Une seule année disponible ({df['annee'].unique()}) "
            "— graphique de tendance non produit."
        )
    else:
        print("⚠️ Variables de tendance non disponibles dans le dataset.")
else:
    print("⚠️ Données non disponibles — exécuter les scripts 01-04 d'abord.")

if OLS_AVAILABLE and "zscore" in ols_results:
    model_z = ols_results["zscore"]["model"]
    params = model_z.params.drop("const", errors="ignore")
    pvals  = model_z.pvalues.drop("const", errors="ignore")
    conf   = model_z.conf_int().drop("const", errors="ignore")

    # Trier par valeur absolue
    order  = params.abs().sort_values(ascending=True).index
    params = params[order]
    pvals  = pvals[order]
    conf   = conf.loc[order]

    colors = [_RED if p < 0.05 else _CHALK_DIM for p in pvals]

    fig, ax = plt.subplots(figsize=(9, max(4, len(params) * 0.6)))
    bars = ax.barh(range(len(params)), params.values, color=colors, edgecolor="none", alpha=0.85)
    ax.errorbar(
        params.values, range(len(params)),
        xerr=[params.values - conf[0].values, conf[1].values - params.values],
        fmt="none", color="black", capsize=4, linewidth=1.2,
    )
    ax.axvline(0, color="black", linewidth=0.8, linestyle="--")
    ax.set_yticks(range(len(params)))
    ax.set_yticklabels(params.index.tolist(), fontsize=9)
    ax.set_xlabel("Coefficient bêta standardisé (IC 95 %)", fontsize=10)
    ax.set_title(
        f"Importance relative des prédicteurs\n(OLS sur z-scores — {YEAR_FILOSOFI})",
        fontsize=11, fontweight="bold",
    )

    # Légende
    from matplotlib.patches import Patch
    legend_elems = [
        Patch(facecolor=_RED,       label="p < 0,05 (significatif)"),
        Patch(facecolor=_CHALK_DIM, label="p ≥ 0,05 (non significatif)"),
    ]
    ax.legend(handles=legend_elems, loc="lower right", fontsize=8)
    ax.grid(axis="x", alpha=0.3)

    fig.text(
        0.5, -0.04,
        f"Source : Banque de France, INSEE, DREES. Données {YEAR_FILOSOFI} — 96 départements métropolitains. "
        "Les coefficients standardisés permettent de comparer l'effet relatif de chaque prédicteur.",
        ha="center", fontsize=8, style="italic", wrap=True,
    )
    plt.tight_layout()
    plt.show()
elif EDA_AVAILABLE:
    print("⚠️ Modèle z-score non disponible — données insuffisantes.")
else:
    print("⚠️ Données non disponibles.")

if CARTO_AVAILABLE and gdf_merged is not None:
    col_map = "suren_depot_nb"
    col_label = "Dossiers déposés (nb)"

    # Utiliser le taux / 10 000 hab. si disponible (RP 2022 PMUN)
    suren_vals = pd.to_numeric(gdf_merged["suren_depot_taux"], errors="coerce")
    if suren_vals.median() < 100:
        col_map = "suren_depot_taux"
        col_label = "Dépôts pour 10 000 habitants"

    gdf_plot = gdf_merged.copy()
    gdf_plot[col_map] = pd.to_numeric(gdf_plot[col_map], errors="coerce")

    fig, ax = plt.subplots(1, 1, figsize=(10, 8))
    divider = make_axes_locatable(ax)
    cax = divider.append_axes("right", size="4%", pad=0.1)
    cax.set_facecolor("none")

    gdf_plot.plot(
        column=col_map,
        cmap="YlOrRd",
        legend=True,
        legend_kwds={"label": col_label, "orientation": "vertical"},
        missing_kwds={"color": _BOARD_LIGHT, "label": "Données manquantes"},
        ax=ax,
        cax=cax,
        linewidth=0.4,
        edgecolor=_BOARD_LIGHTER,
    )
    ax.set_axis_off()
    ax.set_facecolor("none")
    ax.set_title(
        f"Surendettement par département — {YEAR_TARGET}\n({col_label})",
        fontsize=13, fontweight="bold", pad=15,
    )
    fig.text(
        0.5, 0.02,
        f"Source : Banque de France, Synthèses surendettement {YEAR_TARGET}. "
        "96 départements métropolitains (DOM-TOM exclus). "
        "Les zones les plus foncées concentrent les dossiers de surendettement les plus nombreux.",
        ha="center", fontsize=8, style="italic", wrap=True,
    )
    plt.tight_layout()
    plt.show()
else:
    print("⚠️ Cartographie non disponible — GeoDataFrame non chargé ou données manquantes.")

if CARTO_AVAILABLE and gdf_merged is not None:
    carto_vars = [
        ("chomage_taux",      "Taux de chômage (%)",            f"INSEE {YEAR_TARGET}"),
        ("taux_pauvrete",     "Taux de pauvreté (%)",           f"FiLoSoFi {YEAR_FILOSOFI}"),
        ("rsa_taux",          "Part allocataires RSA (%)",      f"DREES {YEAR_TARGET}"),
        ("part_locataires",   "Part ménages locataires (%)",    f"RP {YEAR_TARGET}"),
    ]
    available_carto = [
        (col, label, src)
        for col, label, src in carto_vars
        if col in gdf_merged.columns
        and pd.to_numeric(gdf_merged[col], errors="coerce").notna().sum() >= 30
    ]

    if available_carto:
        n_cols = min(2, len(available_carto))
        n_rows = (len(available_carto) + n_cols - 1) // n_cols
        fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 6 * n_rows))
        if len(available_carto) == 1:
            axes = [[axes]]
        elif n_rows == 1:
            axes = [axes]

        for idx, (col, label, src) in enumerate(available_carto):
            row, col_idx = divmod(idx, n_cols)
            ax = axes[row][col_idx] if n_rows > 1 else axes[0][col_idx]
            gdf_plot = gdf_merged.copy()
            gdf_plot[col] = pd.to_numeric(gdf_plot[col], errors="coerce")
            gdf_plot.plot(
                column=col,
                cmap="viridis",
                legend=True,
                missing_kwds={"color": _BOARD_LIGHT},
                ax=ax,
                linewidth=0.3,
                edgecolor=_BOARD_LIGHTER,
            )
            ax.set_axis_off()
            ax.set_facecolor("none")
            ax.set_title(label, fontsize=10, fontweight="bold")
            ax.text(
                0.02, 0.02, f"Source : {src}",
                transform=ax.transAxes, fontsize=7, style="italic", va="bottom",
            )

        # Masquer axes inutilisés
        for idx in range(len(available_carto), n_rows * n_cols):
            row, col_idx = divmod(idx, n_cols)
            if n_rows > 1:
                axes[row][col_idx].set_visible(False)
            else:
                axes[0][col_idx].set_visible(False)

        fig.suptitle(
            f"Variables explicatives clés — Disparités départementales ({YEAR_TARGET})",
            fontsize=13, fontweight="bold", y=1.01,
        )
        fig.text(
            0.5, -0.01,
            f"Source : INSEE (chômage localisé {YEAR_TARGET}, FiLoSoFi {YEAR_FILOSOFI}), DREES. "
            "Les cartes révèlent une concentration géographique similaire à celle du surendettement.",
            ha="center", fontsize=8, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()
    else:
        print(
            "⚠️ Cartes des variables explicatives non disponibles — "
            "données FiLoSoFi, RP et minimas sociaux absentes.\n"
            "Exécuter scripts/01_download.py pour télécharger les données INSEE."
        )
else:
    print("⚠️ Cartographie non disponible.")

if CARTO_AVAILABLE and gdf_merged is not None:
    gdf_score = gdf_merged.copy()
    gdf_score["score_fragilite"] = pd.to_numeric(gdf_score["score_fragilite"], errors="coerce")

    if gdf_score["score_fragilite"].notna().sum() >= 50:
        # Corrélation spatiale avec surendettement
        gdf_score["suren_depot_nb_num"] = pd.to_numeric(gdf_score["suren_depot_nb"], errors="coerce")
        corr_score_suren = np.nan
        valid_pair = gdf_score[["score_fragilite", "suren_depot_nb_num"]].dropna()
        if len(valid_pair) >= 10:
            from scipy import stats as scipy_stats
            corr_score_suren, _ = scipy_stats.pearsonr(
                valid_pair["score_fragilite"], valid_pair["suren_depot_nb_num"]
            )

        fig, ax = plt.subplots(1, 1, figsize=(10, 8))
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="4%", pad=0.1)
        cax.set_facecolor("none")

        vabs = gdf_score["score_fragilite"].abs().quantile(0.95)
        gdf_score.plot(
            column="score_fragilite",
            cmap="RdYlBu_r",
            vmin=-vabs,
            vmax=vabs,
            legend=True,
            legend_kwds={"label": "Score de fragilité (z-score composite)", "orientation": "vertical"},
            missing_kwds={"color": _BOARD_LIGHT, "label": "Données manquantes"},
            ax=ax,
            cax=cax,
            linewidth=0.4,
            edgecolor=_BOARD_LIGHTER,
        )
        ax.set_axis_off()
        ax.set_facecolor("none")
        ax.set_title(
            f"Score de fragilité financière territoriale ({YEAR_TARGET})\n"
            "chômage×0,3 + pauvreté×0,3 + RSA×0,2 + locataires×0,2 (z-scores)",
            fontsize=12, fontweight="bold", pad=15,
        )
        corr_txt = (
            f"r = {corr_score_suren:.2f} avec le surendettement"
            if not np.isnan(corr_score_suren)
            else "corrélation avec surendettement : données insuffisantes"
        )
        fig.text(
            0.5, 0.02,
            f"Source : Banque de France, INSEE, DREES {YEAR_TARGET}. "
            f"Corrélation de Pearson score–surendettement : {corr_txt}. "
            "Les zones rouges concentrent les multiples facteurs de vulnérabilité financière.",
            ha="center", fontsize=8, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()
    else:
        print("⚠️ Score de fragilité indisponible ou insuffisamment couvert (< 50 départements avec données).")
else:
    print("⚠️ Cartographie non disponible.")

if EDA_AVAILABLE:
    scatter_vars = [
        ("chomage_taux",      "Taux de chômage (%)",            f"INSEE {YEAR_TARGET}"),
        ("taux_pauvrete",     "Taux de pauvreté (%)",           f"FiLoSoFi {YEAR_FILOSOFI}"),
        ("rsa_taux",          "Part allocataires RSA (%)",      f"DREES {YEAR_TARGET}"),
        ("part_locataires",   "Part ménages locataires (%)",    f"RP {YEAR_TARGET}"),
    ]
    y_col_scatter = "suren_depot_nb"
    y_label = "Dossiers de surendettement (nb)"

    available_scatter = [
        (col, label, src) for col, label, src in scatter_vars
        if col in df_2021.columns
        and pd.to_numeric(df_2021[col], errors="coerce").notna().sum() >= 20
    ]

    if available_scatter:
        from scipy import stats as scipy_stats

        n_cols = min(2, len(available_scatter))
        n_rows = (len(available_scatter) + n_cols - 1) // n_cols
        fig, axes = plt.subplots(n_rows, n_cols, figsize=(14, 5 * n_rows))
        if len(available_scatter) == 1:
            axes = [[axes]]
        elif n_rows == 1:
            axes = [axes]

        for idx, (col, label, src) in enumerate(available_scatter):
            row, col_idx = divmod(idx, n_cols)
            ax = axes[row][col_idx] if n_rows > 1 else axes[0][col_idx]

            x_data = pd.to_numeric(df_2021[col], errors="coerce")
            y_data = pd.to_numeric(df_2021[y_col_scatter], errors="coerce")
            valid  = pd.DataFrame({"x": x_data, "y": y_data}).dropna()

            ax.scatter(valid["x"], valid["y"], color=_CYAN, alpha=0.6, s=40)

            if len(valid) >= 5:
                slope, intercept, r_val, p_val, _ = scipy_stats.linregress(valid["x"], valid["y"])
                x_line = np.linspace(valid["x"].min(), valid["x"].max(), 100)
                ax.plot(x_line, intercept + slope * x_line, color=_RED, linewidth=2,
                        label=f"r={r_val:.2f}, p={'<0,001' if p_val < 0.001 else f'{p_val:.3f}'}")
                ax.legend(fontsize=9)

            ax.set_xlabel(label, fontsize=10)
            ax.set_ylabel(y_label, fontsize=10)
            ax.set_title(f"{y_label}\nvs. {label}", fontsize=10, fontweight="bold")
            ax.grid(alpha=0.3)
            ax.text(
                0.98, 0.02, f"Source : {src}",
                transform=ax.transAxes, fontsize=7, style="italic", va="bottom", ha="right",
            )

        for idx in range(len(available_scatter), n_rows * n_cols):
            row, col_idx = divmod(idx, n_cols)
            if n_rows > 1:
                axes[row][col_idx].set_visible(False)
            else:
                axes[0][col_idx].set_visible(False)

        fig.suptitle(
            f"Relations bivariées : surendettement vs. prédicteurs ({YEAR_TARGET})",
            fontsize=13, fontweight="bold", y=1.01,
        )
        fig.text(
            0.5, -0.01,
            f"Source : Banque de France, INSEE, DREES. Données {YEAR_TARGET} — 96 départements métropolitains. "
            "Chaque point représente un département. La droite de régression indique la tendance linéaire.",
            ha="center", fontsize=8, style="italic", wrap=True,
        )
        plt.tight_layout()
        plt.show()
    else:
        print(
            "⚠️ Graphiques bivariés limités aux variables disponibles.\n"
            "Variables FiLoSoFi, RP, minimas sociaux indisponibles — "
            "seul le chômage peut être représenté une fois les données téléchargées."
        )
        # Scatter chômage seul si disponible
        x_data = pd.to_numeric(df_2021["chomage_taux"], errors="coerce")
        y_data = pd.to_numeric(df_2021["suren_depot_nb"], errors="coerce")
        valid  = pd.DataFrame({"x": x_data, "y": y_data}).dropna()
        if len(valid) >= 20:
            from scipy import stats as scipy_stats
            fig, ax = plt.subplots(figsize=(8, 5))
            ax.scatter(valid["x"], valid["y"], color=_CYAN, alpha=0.6, s=40)
            slope, intercept, r_val, p_val, _ = scipy_stats.linregress(valid["x"], valid["y"])
            x_line = np.linspace(valid["x"].min(), valid["x"].max(), 100)
            ax.plot(x_line, intercept + slope * x_line, color=_RED, linewidth=2,
                    label=f"r={r_val:.2f}, p={'<0,001' if p_val < 0.001 else f'{p_val:.3f}'}")
            ax.legend(fontsize=9)
            ax.set_xlabel("Taux de chômage (%)", fontsize=10)
            ax.set_ylabel("Dossiers de surendettement (nb)", fontsize=10)
            ax.set_title(f"Surendettement vs. Chômage ({YEAR_TARGET})", fontsize=11, fontweight="bold")
            ax.grid(alpha=0.3)
            fig.text(
                0.5, -0.04,
                f"Source : Banque de France (surendettement), INSEE chômage localisé (chômage). {YEAR_TARGET} — 96 départements.",
                ha="center", fontsize=8, style="italic"
            )
            plt.tight_layout()
            plt.show()
else:
    print("⚠️ Données EDA non disponibles — exécuter les scripts 01-04 d'abord.")