src/Analytics/ML_Feature_Store_Analytics.py

"""
ML_FEATURE_STORE_ANALYTICS.PY  —  Reacteur OAG
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Module d'ingenierie de features pour le futur moteur d'IA OAG.
23 features FL_* calculees silencieusement, utilisables par tout modele ML.

Fonctions publiques :
    enrich_fl(sheets)             -> dict avec colonnes FL_* injectees (silencieux)
    render_feature_store(sheets)  -> UI complète : U0 protocole / U1 ML / U2 export

Prefix FL_* (Feature Library) : jamais affiche directement dans les graphiques metier,
expose uniquement dans la console export OAG et les diagnostics du present module.

Integration Usis.py :
    elif "U3" in mode:
        mla.render_feature_store(sheets)
"""

import streamlit as st
import pandas as pd
import numpy as np
import plotly.graph_objects as go
from datetime import datetime

# ML
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.ensemble import GradientBoostingRegressor

# ── Palette ───────────────────────────────────────────────────────────────────

_C = {
    "bg":       "#0a0e12",
    "card":     "#0f141a",
    "border":   "rgba(80,100,120,0.25)",
    "accent":   "#58a6ff",
    "success":  "#2ecc71",
    "warning":  "#f39c12",
    "critical": "#c0392b",
    "ml":       "#a78bfa",      # violet = signature ML
    "neutral":  "#5a6a7a",
    "text":     "#a8b8c8",
    "subtext":  "#5a6a7a",
    "grid":     "rgba(80,100,120,0.12)",
}
_PAL  = ["#58a6ff","#2ecc71","#f39c12","#c0392b","#a78bfa","#38bdf8","#fb7185","#34d399"]
_FONT = "JetBrains Mono, Courier New, monospace"
_BASE = dict(
    paper_bgcolor=_C["card"], plot_bgcolor=_C["card"],
    font=dict(color=_C["text"], family=_FONT, size=11),
    title_font=dict(size=12, color=_C["text"], family=_FONT),
    margin=dict(t=44, b=36, l=60, r=24),
    legend=dict(bgcolor=_C["bg"], bordercolor=_C["border"], borderwidth=1,
                font=dict(size=10, family=_FONT)),
    xaxis=dict(gridcolor=_C["grid"], zerolinecolor=_C["grid"],
               tickfont=dict(family=_FONT, size=10)),
    yaxis=dict(gridcolor=_C["grid"], zerolinecolor=_C["grid"],
               tickfont=dict(family=_FONT, size=10)),
    colorway=_PAL,
)

# ── Helpers ───────────────────────────────────────────────────────────────────

def _L(**kw):
    m = {**_BASE}
    for ax in ("xaxis", "yaxis"):
        if ax in kw:
            m[ax] = {**m[ax], **kw.pop(ax)}
    m.update(kw)
    return m

def _ef(msg, h=220):
    fig = go.Figure()
    fig.add_annotation(text=msg, xref="paper", yref="paper", x=0.5, y=0.5,
                       showarrow=False, font=dict(size=12, color=_C["subtext"], family=_FONT))
    fig.update_layout(**_L(height=h))
    return fig

def _age(v):
    try:
        d = pd.to_datetime(str(v), dayfirst=True, errors="coerce")
        return int((datetime.today() - d).days / 365.25) if not pd.isna(d) else np.nan
    except Exception:
        return np.nan

def _safe(df, col, default=0):
    return df[col].fillna(default) if col in df.columns else pd.Series(default, index=df.index)

def _norm_statut(v):
    """Normalise Statut_Pro en cle standard."""
    mapping = {
        "cdi": "CDI", "salarie": "SALARIE", "salarié": "SALARIE",
        "etudiant": "ETUDIANT", "étudiant": "ETUDIANT",
        "independant": "INDEPENDANT", "indépendant": "INDEPENDANT",
        "cdd": "CDD", "informel": "INFORMEL", "sans_emploi": "SANS_EMPLOI",
    }
    return mapping.get(str(v).lower().strip(), str(v).upper().strip())

def _title_bar(txt: str, color: str = None):
    c = color or _C["ml"]
    st.markdown(
        f'<div style="border-left:3px solid {c};padding:4px 10px;'
        f'margin:14px 0 8px 0;font-family:{_FONT};font-size:0.62rem;'
        f'letter-spacing:2px;text-transform:uppercase;color:{_C["text"]};">'
        f'{txt}</div>',
        unsafe_allow_html=True,
    )


# ══════════════════════════════════════════════════════════════════════════════
# ENRICHISSEMENT FL_*  (silencieux — 23 features)
# ══════════════════════════════════════════════════════════════════════════════

def enrich_fl(sheets: dict) -> dict:
    """
    Calcule les 23 features FL_* et les injecte dans Clients_KYC.
    Toutes les features sont aggregees au niveau client (une ligne par client).
    Retourne un nouveau dict de DataFrames enrichis.
    """
    s   = {k: df.copy() for k, df in sheets.items() if isinstance(df, pd.DataFrame)}
    cli = s.get("Clients_KYC",           pd.DataFrame())
    prt = s.get("Prets_Master",          pd.DataFrame())
    upd = s.get("Prets_Update",          pd.DataFrame())
    rem = s.get("Remboursements",        pd.DataFrame())
    adj = s.get("Ajustements_Echeances", pd.DataFrame())

    if cli.empty:
        return s

    log = []   # log des transformations pour U2

    # ── 0.1 DEMOGRAPHIQUES ET STABILITE ──────────────────────────────────────

    # Age
    cli["_age"] = cli.get("Date_Naissance", pd.Series(dtype=str)).apply(_age)
    log.append(f"Age calcule depuis Date_Naissance : {cli['_age'].isna().sum()} null(s) impute(s) par mediane")
    cli["_age"] = cli["_age"].fillna(cli["_age"].median())

    # FL_Age_Risk_Index : age × (capital_total / revenu_annuel)
    # Detecte si un jeune emprunte des sommes disproportionnees
    if not prt.empty and "ID_Client" in prt.columns:
        cap_tot = prt.groupby("ID_Client")["Montant_Capital"].sum().to_dict()
    else:
        cap_tot = {}
    rev_ann = (_safe(cli,"Revenus_Mensuels") + _safe(cli,"Autres_Revenus")) * 12
    cli["_cap"] = _safe(cli,"ID_Client").map(cap_tot).fillna(0)
    cli["FL_Age_Risk_Index"] = (
        cli["_age"] * (cli["_cap"] / rev_ann.replace(0, np.nan))
    ).round(3)
    log.append("FL_Age_Risk_Index : age * (capital_total / revenu_annuel)")

    # FL_Job_Seniority_vs_Age : anciennete emploi / age
    cli["FL_Job_Seniority_vs_Age"] = (
        _safe(cli,"Anciennete_Emploi") / cli["_age"].replace(0, np.nan)
    ).round(3)
    log.append("FL_Job_Seniority_vs_Age : anciennete_emploi_mois / age_annees")

    # FL_Social_Network_Density : compte des reseaux fournis (FB/IG/LI/TW/TT/WA)
    def _social_count(v):
        if pd.isna(v) or not str(v).strip():
            return 0
        prefixes = ["FB:", "IG:", "LI:", "TW:", "TT:", "WA:"]
        count = 0
        for p in prefixes:
            idx = str(v).find(p)
            if idx >= 0:
                after = str(v)[idx+3:idx+30].strip()
                if after and not after.startswith("|") and len(after) > 2:
                    count += 1
        return count
    cli["FL_Social_Network_Density"] = cli.get("Reseau_sociaux",
        pd.Series(dtype=str)).apply(_social_count)
    log.append("FL_Social_Network_Density : nb reseaux sociaux renseignes (0-6)")

    # FL_Geographic_Stability_Score : sedentarite — score base sur unicite Ville/Quartier
    if "Ville" in cli.columns and "Quartier" in cli.columns:
        freq_ville = cli["Ville"].value_counts(normalize=True)
        freq_qrt   = cli["Quartier"].value_counts(normalize=True)
        cli["FL_Geographic_Stability_Score"] = (
            cli["Ville"].map(freq_ville).fillna(0) * 0.4 +
            cli["Quartier"].map(freq_qrt).fillna(0) * 0.6
        ).round(3)
    else:
        cli["FL_Geographic_Stability_Score"] = 0.5
    log.append("FL_Geographic_Stability_Score : frequence relative Ville(40%) + Quartier(60%)")

    # FL_Life_Stage_Proxy : etape de vie estimee (0=etudiant, 1=actif junior, 2=actif senior, 3=senior)
    statut_norm = cli.get("Statut_Pro", pd.Series(dtype=str)).apply(_norm_statut)
    def _life_stage(row):
        age   = row["_age"]
        sp    = _norm_statut(row.get("Statut_Pro", ""))
        if sp in ("ETUDIANT",) or age < 25:
            return 0
        elif sp in ("SALARIE","CDI","CDD") and age < 35:
            return 1
        elif sp in ("INDEPENDANT","INFORMEL") or 35 <= age < 50:
            return 2
        else:
            return 3
    cli["FL_Life_Stage_Proxy"] = cli.apply(_life_stage, axis=1)
    log.append("FL_Life_Stage_Proxy : 0=etudiant, 1=actif jr, 2=actif sr, 3=senior (derive age+statut_pro)")

    # ── 0.2 PUISSANCE FINANCIERE ──────────────────────────────────────────────

    rev_tot = _safe(cli,"Revenus_Mensuels") + _safe(cli,"Autres_Revenus")
    charges = _safe(cli,"Charges_Estimees")

    # FL_Net_Disposable_Income
    cli["FL_Net_Disposable_Income"] = (rev_tot - charges).round(0)
    log.append("FL_Net_Disposable_Income : Revenus_Mensuels + Autres_Revenus - Charges_Estimees")

    # FL_Theoretical_Debt_Capacity : 33% du revenu net mensuel (seuil bancaire)
    cli["FL_Theoretical_Debt_Capacity"] = (cli["FL_Net_Disposable_Income"] * 0.33).round(0)
    log.append("FL_Theoretical_Debt_Capacity : 33% du revenu net mensuel (benchmark bancaire)")

    # FL_Income_MultiSource_Index : part des autres revenus dans le total
    cli["FL_Income_MultiSource_Index"] = (
        _safe(cli,"Autres_Revenus") / rev_tot.replace(0, np.nan)
    ).fillna(0).round(3)
    log.append("FL_Income_MultiSource_Index : Autres_Revenus / Revenus_Totaux")

    # FL_Wealth_to_Commitment_Ratio
    # NOTA : Patrimoine_Declare est sur echelle ordinale 0-3 (pas FCFA).
    # Normalise sur 100 (0->0, 1->33, 2->67, 3->100) puis divise par capital normalise.
    patr_norm = (_safe(cli,"Patrimoine_Declare").clip(0,3) / 3.0)
    cap_norm  = (cli["_cap"] / cli["_cap"].replace(0,np.nan).max()).fillna(0) if cli["_cap"].max() > 0 else pd.Series(0.5,index=cli.index)
    cli["FL_Wealth_to_Commitment_Ratio"] = (patr_norm / cap_norm.replace(0, np.nan)).fillna(0).round(3)
    log.append("FL_Wealth_to_Commitment_Ratio : Patrimoine_norm(0-3→0-1) / Capital_norm — NOTE: Patrimoine_Declare est une echelle ordinale 0-3, pas FCFA")

    # FL_Financial_Fragility_Index : charges / revenu total (proximite rupture)
    cli["FL_Financial_Fragility_Index"] = (
        charges / rev_tot.replace(0, np.nan)
    ).fillna(0).round(3)
    log.append("FL_Financial_Fragility_Index : Charges_Estimees / Revenus_Totaux — seuil critique > 0.6")

    # FL_Loan_to_Income_Ratio (ajout strategique)
    cli["FL_Loan_to_Income_Ratio"] = (
        cli["_cap"] / (rev_tot.replace(0, np.nan) * 12)
    ).fillna(0).round(3)
    log.append("FL_Loan_to_Income_Ratio : Capital_total / Revenus_annuels (benchmark < 3.0)")

    # FL_Debt_Service_Coverage (ajout strategique)
    if not prt.empty and "ID_Client" in prt.columns:
        versement_map = prt.groupby("ID_Client")["Montant_Versement"].sum().to_dict()
    else:
        versement_map = {}
    cli["_versement"] = _safe(cli,"ID_Client").map(versement_map).fillna(0)
    cli["FL_Debt_Service_Coverage"] = (
        cli["FL_Net_Disposable_Income"] / cli["_versement"].replace(0, np.nan)
    ).fillna(0).round(3)
    log.append("FL_Debt_Service_Coverage : Revenu_Net / Versement_mensuel — ideal > 2.0")

    # ── 0.3 COMPORTEMENTALES ─────────────────────────────────────────────────

    if not rem.empty and "ID_Client" in rem.columns:

        # FL_Repayment_Punctuality_Rate
        good_mask = rem["Statut_Paiement"].str.upper().isin(["PONCTUEL","ANTICIPE","PAYE"])
        punct_rate = rem.groupby("ID_Client").apply(
            lambda g: good_mask.reindex(g.index).fillna(False).sum() / len(g)
        ).round(3)
        cli["FL_Repayment_Punctuality_Rate"] = _safe(cli,"ID_Client").map(punct_rate)
        n_imp = cli["FL_Repayment_Punctuality_Rate"].isna().sum()
        med_p = punct_rate.median() if not punct_rate.empty else 0.8
        cli["FL_Repayment_Punctuality_Rate"] = cli["FL_Repayment_Punctuality_Rate"].fillna(med_p).round(3)
        log.append(f"FL_Repayment_Punctuality_Rate : % paiements PONCTUEL/ANTICIPE — {n_imp} client(s) sans historique impute(s) par mediane ({med_p:.2f})")

        # FL_Late_Gravity_Score : somme ponderee par severite (retard^1.5)
        def _late_gravity(g):
            jr = g["Jours_Retard"].clip(lower=0)
            return float((jr ** 1.5).sum())
        gravity = rem.groupby("ID_Client").apply(_late_gravity).round(2)
        cli["FL_Late_Gravity_Score"] = _safe(cli,"ID_Client").map(gravity).fillna(0).round(2)
        log.append("FL_Late_Gravity_Score : somme(Jours_Retard_positifs ^ 1.5) par client — penalise les gros retards")

        # FL_Prepayment_Index (ajout strategique)
        prepay = rem.groupby("ID_Client").apply(
            lambda g: (g["Jours_Retard"] < 0).sum() / len(g)
        ).round(3)
        cli["FL_Prepayment_Index"] = _safe(cli,"ID_Client").map(prepay).fillna(0).round(3)
        log.append("FL_Prepayment_Index : % paiements avec Jours_Retard < 0 (paiements anticipes)")

    else:
        for f in ["FL_Repayment_Punctuality_Rate","FL_Late_Gravity_Score","FL_Prepayment_Index"]:
            cli[f] = np.nan
        log.append("FL_Repayment_* : table Remboursements vide — toutes valeurs NaN")

    # FL_Renegotiation_Frequency
    if not upd.empty and "ID_Client" in upd.columns and not prt.empty:
        upd_cnt = upd.groupby("ID_Client").size().to_dict()
        prt_cnt = prt.groupby("ID_Client").size().to_dict()
        cli["FL_Renegotiation_Frequency"] = _safe(cli,"ID_Client").apply(
            lambda cid: round(upd_cnt.get(cid,0) / max(prt_cnt.get(cid,1), 1), 3)
        )
    else:
        cli["FL_Renegotiation_Frequency"] = 0.0
    log.append("FL_Renegotiation_Frequency : nb_modifications / nb_prets (0=stable, >0.5=instable)")

    # FL_Contract_Drift_Rate
    if not upd.empty and not prt.empty and "ID_Client" in upd.columns:
        def _drift(cid):
            orig = prt[prt["ID_Client"]==cid]["Montant_Total"].sum()
            last = (upd[upd["ID_Client"]==cid]
                    .sort_values("Version",ascending=False)
                    .drop_duplicates("ID_Pret")["Montant_Total"].sum())
            return round((last - orig) / orig, 4) if orig > 0 else 0.0
        cli["FL_Contract_Drift_Rate"] = _safe(cli,"ID_Client").apply(_drift)
    else:
        cli["FL_Contract_Drift_Rate"] = 0.0
    log.append("FL_Contract_Drift_Rate : (Montant_Total_final - initial) / initial — negatif = reduction, positif = surencherissement")

    # FL_Adjustment_Dependency — inoperant jusqu'a alimentation Ajustements_Echeances
    if not adj.empty and "ID_Pret" in adj.columns and not prt.empty:
        adj_map = adj.groupby("ID_Pret").size().to_dict()
        prt["_adj"] = _safe(prt,"ID_Pret").map(adj_map).fillna(0)
        adj_cli = prt.groupby("ID_Client")["_adj"].sum().to_dict()
        cli["FL_Adjustment_Dependency"] = _safe(cli,"ID_Client").map(adj_cli).fillna(0)
    else:
        cli["FL_Adjustment_Dependency"] = 0.0
    log.append("FL_Adjustment_Dependency : nb ajustements par client — 0.0 (table Ajustements vide) activable en production")

    # FL_Multi_Loan_Exposure (ajout strategique)
    if not prt.empty:
        active_statuts = ["ACTIF","EN_RETARD"]
        active_loans = prt[prt["Statut"].str.upper().isin(active_statuts)].groupby("ID_Client").size().to_dict()
        cli["FL_Multi_Loan_Exposure"] = _safe(cli,"ID_Client").map(active_loans).fillna(0).astype(int)
    else:
        cli["FL_Multi_Loan_Exposure"] = 0
    log.append("FL_Multi_Loan_Exposure : nb prets actifs par client (statut ACTIF ou EN_RETARD)")

    # ── 0.4 RENTABILITE ──────────────────────────────────────────────────────

    # FL_Effective_APR
    if not prt.empty and "Taux_Hebdo" in prt.columns:
        apr_map = prt.groupby("ID_Client")["Taux_Hebdo"].mean().apply(
            lambda t: round(((1 + t/100)**52 - 1) * 100, 2)
        ).to_dict()
        cli["FL_Effective_APR"] = _safe(cli,"ID_Client").map(apr_map).fillna(0)
    else:
        cli["FL_Effective_APR"] = 0.0
    log.append("FL_Effective_APR : ((1 + Taux_Hebdo/100)^52 - 1) * 100 — taux annuel effectif global moyen par client")

    # FL_Yield_per_Client
    if not rem.empty and "ID_Client" in rem.columns:
        yield_map = rem.groupby("ID_Client")["Montant_Interets"].sum().to_dict()
        cli["FL_Yield_per_Client"] = _safe(cli,"ID_Client").map(yield_map).fillna(0)
    else:
        cli["FL_Yield_per_Client"] = 0.0
    log.append("FL_Yield_per_Client : somme des Montant_Interets realises par client")

    # FL_Operational_Cost_Index : nb modifications + nb transactions (proxy de complexite de gestion)
    upd_ops = upd.groupby("ID_Client").size().to_dict() if not upd.empty and "ID_Client" in upd.columns else {}
    rem_ops = rem.groupby("ID_Client").size().to_dict() if not rem.empty and "ID_Client" in rem.columns else {}
    cli["FL_Operational_Cost_Index"] = _safe(cli,"ID_Client").apply(
        lambda cid: int(upd_ops.get(cid,0) + rem_ops.get(cid,0))
    )
    log.append("FL_Operational_Cost_Index : nb_modifications + nb_transactions (complexite de gestion)")

    # ── TARGET : FL_Risk_Target ───────────────────────────────────────────────
    # Score composite [0.0 - 1.0] — variable cible pour ML supervise
    # Composantes : Financial_Fragility (40%) + Late_Gravity norm (30%) + Renegotiation (30%)

    ffr  = cli["FL_Financial_Fragility_Index"].clip(0,1)
    late = cli["FL_Late_Gravity_Score"]
    late_n = (late / late.replace(0,np.nan).max()).fillna(0)
    reneg = cli["FL_Renegotiation_Frequency"].clip(0,1)

    cli["FL_Risk_Target"] = (ffr*0.40 + late_n*0.30 + reneg*0.30).round(4)
    log.append("FL_Risk_Target : score de risque composite [0-1] = FFI(40%) + LateGravity_norm(30%) + RenegFreq(30%) — VARIABLE CIBLE ML SUPERVISE")

    # ── Nettoyage des colonnes temporaires ───────────────────────────────────
    cli.drop(columns=[c for c in ["_age","_cap","_versement"] if c in cli.columns],
             inplace=True, errors="ignore")

    s["Clients_KYC"] = cli

    # Stocker le log dans le dict pour U2
    s["_fl_log"] = log
    return s


# ══════════════════════════════════════════════════════════════════════════════
# RENDU FRONT-END
# ══════════════════════════════════════════════════════════════════════════════

_FL_COLS = [
    "FL_Age_Risk_Index",
    "FL_Job_Seniority_vs_Age",
    "FL_Social_Network_Density",
    "FL_Geographic_Stability_Score",
    "FL_Life_Stage_Proxy",
    "FL_Net_Disposable_Income",
    "FL_Theoretical_Debt_Capacity",
    "FL_Income_MultiSource_Index",
    "FL_Wealth_to_Commitment_Ratio",
    "FL_Financial_Fragility_Index",
    "FL_Loan_to_Income_Ratio",
    "FL_Debt_Service_Coverage",
    "FL_Repayment_Punctuality_Rate",
    "FL_Late_Gravity_Score",
    "FL_Prepayment_Index",
    "FL_Renegotiation_Frequency",
    "FL_Contract_Drift_Rate",
    "FL_Adjustment_Dependency",
    "FL_Multi_Loan_Exposure",
    "FL_Effective_APR",
    "FL_Yield_per_Client",
    "FL_Operational_Cost_Index",
    "FL_Risk_Target",
]

_FL_GROUPS = {
    "DEMOGRAPHIQUES": [
        "FL_Age_Risk_Index","FL_Job_Seniority_vs_Age",
        "FL_Social_Network_Density","FL_Geographic_Stability_Score","FL_Life_Stage_Proxy",
    ],
    "PUISSANCE FINANCIERE": [
        "FL_Net_Disposable_Income","FL_Theoretical_Debt_Capacity",
        "FL_Income_MultiSource_Index","FL_Wealth_to_Commitment_Ratio",
        "FL_Financial_Fragility_Index","FL_Loan_to_Income_Ratio","FL_Debt_Service_Coverage",
    ],
    "COMPORTEMENTALES": [
        "FL_Repayment_Punctuality_Rate","FL_Late_Gravity_Score","FL_Prepayment_Index",
        "FL_Renegotiation_Frequency","FL_Contract_Drift_Rate",
        "FL_Adjustment_Dependency","FL_Multi_Loan_Exposure",
    ],
    "RENTABILITE": [
        "FL_Effective_APR","FL_Yield_per_Client","FL_Operational_Cost_Index",
    ],
    "TARGET ML": ["FL_Risk_Target"],
}


def _get_fl_matrix(cli: pd.DataFrame) -> pd.DataFrame:
    """Extrait la matrice features x clients, impute, retourne un DataFrame propre."""
    available = [c for c in _FL_COLS if c in cli.columns]
    mat = cli[["ID_Client"] + available].copy() if "ID_Client" in cli.columns else cli[available].copy()
    for col in available:
        if mat[col].isna().any():
            mat[col] = mat[col].fillna(mat[col].median())
    return mat


def _render_u0_protocol(cli: pd.DataFrame, log: list):
    """U0 : protocole d'ingenierie — stats par feature + log des transformations."""
    _title_bar("U0  ·  PROTOCOLE D'INGENIERIE FEATURES", _C["ml"])

    available = [c for c in _FL_COLS if c in cli.columns]
    n_feat  = len(available)
    n_null  = sum(cli[c].isna().sum() for c in available)
    n_cli   = len(cli)

    # KPI row
    c1,c2,c3,c4 = st.columns(4)
    for col,label,val,color in [
        (c1,"FEATURES FL_*",    n_feat,    _C["ml"]),
        (c2,"CLIENTS",          n_cli,     _C["text"]),
        (c3,"NULLS IMPUTES",    n_null,    _C["warning"] if n_null>0 else _C["success"]),
        (c4,"TARGET DISPONIBLE",1 if "FL_Risk_Target" in cli.columns else 0, _C["success"]),
    ]:
        with col:
            st.markdown(
                f'<div style="background:{_C["card"]};border:1px solid {_C["border"]};'
                f'border-left:3px solid {color};padding:10px 14px;font-family:{_FONT};">'
                f'<div style="font-size:0.50rem;letter-spacing:2px;color:{_C["subtext"]};'
                f'text-transform:uppercase;">{label}</div>'
                f'<div style="font-size:1.4rem;font-weight:700;color:{color};">{val}</div>'
                f'</div>', unsafe_allow_html=True)

    st.markdown("<br>", unsafe_allow_html=True)

    # Tableau des features par groupe avec stats
    _title_bar("INVENTAIRE DES FEATURES PAR GROUPE", _C["ml"])
    for group, feats in _FL_GROUPS.items():
        avail = [f for f in feats if f in cli.columns]
        if not avail:
            continue
        st.markdown(
            f'<div style="font-family:{_FONT};font-size:0.52rem;letter-spacing:2px;'
            f'text-transform:uppercase;color:{_C["subtext"]};margin:10px 0 4px 0;">'
            f'{group}</div>', unsafe_allow_html=True)
        rows = []
        for f in avail:
            s = cli[f]
            rows.append({
                "Feature": f,
                "Type": "CIBLE" if f == "FL_Risk_Target" else "NUMERIQUE",
                "Min": round(float(s.min()),3) if s.notna().any() else "N/A",
                "Max": round(float(s.max()),3) if s.notna().any() else "N/A",
                "Moy": round(float(s.mean()),3) if s.notna().any() else "N/A",
                "Nulls": int(s.isna().sum()),
            })
        st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)

    st.divider()

    # Log de nettoyage
    _title_bar("LOG DES TRANSFORMATIONS", _C["neutral"])
    for i, line in enumerate(log):
        icon = "[ CIBLE ]" if "CIBLE" in line.upper() or "TARGET" in line.upper() else \
               "[ ALERTE ]" if "NOTE" in line.upper() or "INOPERANT" in line.upper() or "IMPUTE" in line.upper() else \
               f"[ F{i+1:02d} ]"
        color = _C["warning"] if "ALERTE" in icon else \
                _C["ml"] if "CIBLE" in icon else _C["subtext"]
        st.markdown(
            f'<div style="font-family:{_FONT};font-size:0.60rem;padding:3px 0;'
            f'border-bottom:1px solid {_C["border"]};color:{_C["text"]};">'
            f'<span style="color:{color};margin-right:10px;">{icon}</span>{line}</div>',
            unsafe_allow_html=True)


def _render_u1_ml(cli: pd.DataFrame, sheets: dict):
    """U1 : diagnostics ML — heatmap Spearman, feature importance, radar, PCA."""
    _title_bar("U1  ·  DIAGNOSTICS ML", _C["ml"])

    mat = _get_fl_matrix(cli)
    feat_cols = [c for c in _FL_COLS if c in mat.columns and c != "FL_Risk_Target"]
    id_col = "ID_Client" if "ID_Client" in mat.columns else None

    # Alerte volume
    n = len(mat)
    st.markdown(
        f'<div style="border-left:3px solid {_C["warning"]};padding:4px 10px;'
        f'margin-bottom:12px;font-family:{_FONT};font-size:0.60rem;color:{_C["subtext"]};">'
        f'VOLUME : {n} clients  —  Resultats indicatifs. '
        f'Les correlations et le PCA gagnent en robustesse a partir de n=50+.</div>',
        unsafe_allow_html=True)

    # 1. Heatmap Spearman
    _title_bar("1  ·  MATRICE DE CORRELATION SPEARMAN", _C["ml"])
    num_mat = mat[feat_cols + (["FL_Risk_Target"] if "FL_Risk_Target" in mat.columns else [])].copy()
    corr_matrix = num_mat.corr(method="spearman")

    fig = go.Figure(go.Heatmap(
        z=corr_matrix.values,
        x=corr_matrix.columns.tolist(),
        y=corr_matrix.index.tolist(),
        colorscale=[
            [0.0,  "#c0392b"],
            [0.35, "#2d1010"],
            [0.5,  _C["card"]],
            [0.65, "#0d2240"],
            [1.0,  "#58a6ff"],
        ],
        zmid=0, zmin=-1, zmax=1,
        text=corr_matrix.round(2).values,
        texttemplate="%{text}",
        textfont=dict(size=8, family=_FONT),
        hovertemplate="<b>%{y}</b>  x  <b>%{x}</b><br>Spearman : %{z:.3f}<extra></extra>",
        colorbar=dict(title="rho", tickvals=[-1,-0.5,0,0.5,1],
                      tickfont=dict(size=9,family=_FONT)),
        xgap=1, ygap=1,
    ))
    fig.update_layout(**_L(
        height=max(480, len(feat_cols)*22),
        xaxis=dict(tickangle=-45, side="bottom", tickfont=dict(size=8,family=_FONT)),
        yaxis=dict(automargin=True, tickfont=dict(size=8,family=_FONT)),
        margin=dict(t=44, b=120, l=200, r=24),
    ))
    st.plotly_chart(fig, use_container_width=True)

    # 2. Feature Importance (Gradient Boosting vs FL_Risk_Target)
    _title_bar("2  ·  FEATURE IMPORTANCE  (Gradient Boosting vs FL_Risk_Target)", _C["ml"])
    if "FL_Risk_Target" in mat.columns and len(mat) >= 5:
        X = mat[feat_cols].fillna(0).values
        y = mat["FL_Risk_Target"].fillna(0).values
        scaler = StandardScaler()
        X_sc   = scaler.fit_transform(X)
        gb = GradientBoostingRegressor(n_estimators=100, max_depth=3, random_state=42)
        gb.fit(X_sc, y)
        imp  = gb.feature_importances_
        order = np.argsort(imp)
        cols_ord = [feat_cols[i] for i in order]
        imp_ord  = imp[order]
        bar_colors = [_C["ml"] if v > imp.mean() else _C["neutral"] for v in imp_ord]
        fig = go.Figure(go.Bar(
            x=imp_ord, y=cols_ord, orientation="h",
            marker_color=bar_colors,
            text=[f"{v:.3f}" for v in imp_ord], textposition="outside",
            hovertemplate="<b>%{y}</b><br>Importance : %{x:.4f}<extra></extra>",
        ))
        fig.add_vline(x=imp.mean(), line_dash="dot", line_color=_C["warning"],
            annotation_text=f"Moy : {imp.mean():.3f}",
            annotation_font=dict(size=9, color=_C["warning"]))
        fig.update_layout(**_L(
            title="IMPACT SUR LE SCORE DE RISQUE  (violet = au-dessus de la moyenne)",
            height=max(400, len(feat_cols)*22), showlegend=False,
            xaxis_title="Importance relative", margin=dict(t=44,b=36,l=220,r=40),
        ))
        st.plotly_chart(fig, use_container_width=True)
    else:
        st.plotly_chart(_ef("FL_Risk_Target absent ou volume insuffisant (< 5).", 200),
                        use_container_width=True)

    c1, c2 = st.columns(2)

    # 3. Radar : Bons payeurs vs Profils a risque
    with c1:
        _title_bar("3  ·  RADAR SEGMENT  Bons payeurs vs Risque", _C["ml"])
        radar_feats = [
            "FL_Job_Seniority_vs_Age",
            "FL_Financial_Fragility_Index",
            "FL_Repayment_Punctuality_Rate",
            "FL_Social_Network_Density",
            "FL_Loan_to_Income_Ratio",
        ]
        rf_avail = [f for f in radar_feats if f in mat.columns]
        if "FL_Risk_Target" in mat.columns and len(rf_avail) >= 3:
            median_risk = mat["FL_Risk_Target"].median()
            good = mat[mat["FL_Risk_Target"] <= median_risk]
            risky = mat[mat["FL_Risk_Target"] > median_risk]

            def _normalize_group(g, feats):
                vals = []
                for f in feats:
                    col_min = mat[f].min()
                    col_max = mat[f].max()
                    rng = col_max - col_min
                    mean_val = g[f].mean() if len(g) > 0 else 0
                    vals.append((mean_val - col_min) / rng if rng > 0 else 0.5)
                return vals

            good_vals  = _normalize_group(good, rf_avail)
            risky_vals = _normalize_group(risky, rf_avail)
            short_labels = [f.replace("FL_","").replace("_"," ")[:14] for f in rf_avail]
            cats = short_labels + [short_labels[0]]

            fig = go.Figure()
            for vals, name, color in [
                (good_vals,  f"Bon payeur (n={len(good)})",     _C["success"]),
                (risky_vals, f"Profil risque (n={len(risky)})", _C["critical"]),
            ]:
                v = vals + [vals[0]]
                fig.add_trace(go.Scatterpolar(
                    r=v, theta=cats, fill="toself", name=name,
                    line=dict(color=color, width=2),
                    fillcolor=color.replace("#","rgba(").replace(")",",0.10)") if "#" in color else color,
                ))
            fig.update_layout(**_L(
                polar=dict(
                    bgcolor=_C["card"],
                    radialaxis=dict(visible=True, range=[0,1],
                                    tickfont=dict(size=8,family=_FONT),
                                    gridcolor=_C["grid"]),
                    angularaxis=dict(tickfont=dict(size=9,family=_FONT),
                                     gridcolor=_C["grid"]),
                ),
                title="PROFIL MOYEN  (normalise 0-1)", height=380,
            ))
            st.plotly_chart(fig, use_container_width=True)

    # 4. PCA 2D cluster
    with c2:
        _title_bar("4  ·  PCA 2D  CLUSTERS CLIENTS", _C["ml"])
        if len(mat) >= 4 and len(feat_cols) >= 3:
            X_pca = mat[feat_cols].fillna(0).values
            X_sc  = StandardScaler().fit_transform(X_pca)
            pca   = PCA(n_components=2, random_state=42)
            comp  = pca.fit_transform(X_sc)
            var1  = pca.explained_variance_ratio_[0] * 100
            var2  = pca.explained_variance_ratio_[1] * 100

            df_pca = pd.DataFrame({
                "PC1":       comp[:,0],
                "PC2":       comp[:,1],
                "ID_Client": mat.get("ID_Client", mat.index.astype(str)).values if "ID_Client" in mat.columns else mat.index.astype(str),
                "Risk":      mat["FL_Risk_Target"].fillna(0).values if "FL_Risk_Target" in mat.columns else np.zeros(len(mat)),
            })
            df_pca["Nom"] = cli.get("Nom_Complet", df_pca["ID_Client"]).fillna(df_pca["ID_Client"]).values if "Nom_Complet" in cli.columns else df_pca["ID_Client"]

            fig = go.Figure(go.Scatter(
                x=df_pca["PC1"], y=df_pca["PC2"],
                mode="markers+text",
                text=df_pca["Nom"].str[:10],
                textposition="top center",
                textfont=dict(size=8, family=_FONT),
                marker=dict(
                    size=12,
                    color=df_pca["Risk"],
                    colorscale=[[0,"#2ecc71"],[0.5,"#f39c12"],[1,"#c0392b"]],
                    showscale=True,
                    colorbar=dict(title="Risque", tickfont=dict(size=9,family=_FONT)),
                    line=dict(width=1.5, color=_C["bg"]),
                ),
                hovertemplate="<b>%{text}</b><br>PC1 : %{x:.2f}<br>PC2 : %{y:.2f}<br>Risque : %{marker.color:.3f}<extra></extra>",
            ))
            fig.update_layout(**_L(
                title=f"PCA 2D  ({var1:.0f}% + {var2:.0f}% variance expliquee)",
                height=380, showlegend=False,
                xaxis_title=f"PC1 ({var1:.1f}%)", yaxis_title=f"PC2 ({var2:.1f}%)",
            ))
            st.plotly_chart(fig, use_container_width=True)
        else:
            st.plotly_chart(_ef("Volume insuffisant pour PCA (< 4 clients).", 380),
                            use_container_width=True)

    # Scatter bonus : Risk_Target vs Fragility
    _title_bar("5  ·  SCATTER  FL_Risk_Target vs features cles", _C["ml"])
    s_cols = st.columns(3)
    scatter_pairs = [
        ("FL_Financial_Fragility_Index","FL_Risk_Target"),
        ("FL_Repayment_Punctuality_Rate","FL_Risk_Target"),
        ("FL_Loan_to_Income_Ratio","FL_Risk_Target"),
    ]
    for i,(xf,yf) in enumerate(scatter_pairs):
        if xf in mat.columns and yf in mat.columns:
            with s_cols[i]:
                fig = go.Figure(go.Scatter(
                    x=mat[xf], y=mat[yf], mode="markers+text",
                    text=cli.get("Nom_Complet", mat.get("ID_Client",
                          pd.Series(range(len(mat))))).str[:8] if "Nom_Complet" in cli.columns else mat.get("ID_Client",pd.Series(range(len(mat)))).astype(str),
                    textposition="top center",
                    textfont=dict(size=8,family=_FONT),
                    marker=dict(size=10, color=mat[yf],
                                colorscale=[[0,"#2ecc71"],[1,"#c0392b"]],
                                line=dict(width=1,color=_C["bg"])),
                    hovertemplate=f"%{{text}}<br>{xf.replace('FL_','')}: %{{x:.3f}}<br>Risk: %{{y:.3f}}<extra></extra>",
                ))
                fig.update_layout(**_L(
                    title=xf.replace("FL_","").replace("_"," ")[:22],
                    height=260, showlegend=False,
                    xaxis_title=xf.replace("FL_","")[:16],
                    yaxis_title="Risk Target",
                    margin=dict(t=36,b=30,l=50,r=10),
                ))
                st.plotly_chart(fig, use_container_width=True)

    st.divider()

    # 6. Cluster maps : Clients / Garants / Prets / Updates
    _render_cluster_section(sheets)


def _pca_cluster(df: pd.DataFrame, feat_cols: list, label_col: str,
                 color_col: str, color_title: str,
                 title: str, colorscale=None) -> go.Figure:
    """
    PCA 2D generique pour n'importe quelle table.
    feat_cols  : colonnes numeriques a utiliser
    label_col  : colonne de nom/id affichee sur chaque point
    color_col  : colonne numerique qui pilote la couleur
    """
    if colorscale is None:
        colorscale = [[0,"#2ecc71"],[0.5,"#f39c12"],[1,"#c0392b"]]

    avail = [c for c in feat_cols if c in df.columns]
    if len(df) < 3 or len(avail) < 2:
        return _ef(f"Volume ou features insuffisants ({len(df)} lignes, {len(avail)} features).", 360)

    X = df[avail].fillna(df[avail].median()).values
    try:
        X_sc = StandardScaler().fit_transform(X)
        n_comp = min(2, X_sc.shape[1], X_sc.shape[0])
        pca  = PCA(n_components=n_comp, random_state=42)
        comp = pca.fit_transform(X_sc)
        var1 = pca.explained_variance_ratio_[0] * 100
        var2 = pca.explained_variance_ratio_[1] * 100 if n_comp > 1 else 0.0
    except Exception as e:
        return _ef(f"PCA impossible : {e}", 360)

    labels = df[label_col].astype(str).str[:12] if label_col in df.columns else df.index.astype(str)
    colors = df[color_col].fillna(df[color_col].median()) if color_col in df.columns else pd.Series(0, index=df.index)

    pc2 = comp[:,1] if n_comp > 1 else pd.Series(0, index=range(len(comp)))

    fig = go.Figure(go.Scatter(
        x=comp[:,0], y=pc2,
        mode="markers+text",
        text=labels,
        textposition="top center",
        textfont=dict(size=8, family=_FONT, color=_C["subtext"]),
        marker=dict(
            size=13,
            color=colors,
            colorscale=colorscale,
            showscale=True,
            colorbar=dict(title=color_title, tickfont=dict(size=9, family=_FONT), len=0.7),
            line=dict(width=1.5, color=_C["bg"]),
        ),
        hovertemplate=(
            "<b>%{text}</b><br>"
            "PC1 : %{x:.2f}<br>PC2 : %{y:.2f}<br>"
            f"{color_title} : %{{marker.color:.3f}}<extra></extra>"
        ),
    ))
    fig.update_layout(**_L(
        title=f"{title}  ({var1:.0f}% + {var2:.0f}% var.)",
        height=370, showlegend=False,
        xaxis_title=f"PC1 ({var1:.1f}%)", yaxis_title=f"PC2 ({var2:.1f}%)",
    ))
    return fig


def _render_cluster_section(sheets: dict):
    """
    PCA 2D par entite : Clients, Garants, Prets_Master, Prets_Update.
    """
    HDR_STYLE = (
        'font-family:JetBrains Mono,monospace;font-size:0.58rem;'
        'letter-spacing:2px;text-transform:uppercase;color:#58a6ff;margin:12px 0 4px 0;'
    )

    def _hdiv(label):
        st.markdown(f'<div style="{HDR_STYLE}">{label}</div>', unsafe_allow_html=True)

    _title_bar("CLUSTER MAPS  PCA 2D PAR ENTITE", _C["ml"])
    st.markdown(
        '<div style="font-family:JetBrains Mono,monospace;font-size:0.60rem;'
        'color:#5a6a7a;border-left:3px solid #a78bfa;padding:4px 10px;margin-bottom:14px;">'
        'Chaque point = une entite.  Couleur = variable de risque principale.  '
        'La proximite = similarite multi-dimensionnelle (PCA).</div>',
        unsafe_allow_html=True,
    )

    cli = sheets.get("Clients_KYC",  pd.DataFrame())
    gar = sheets.get("Garants_KYC",  pd.DataFrame())
    prt = sheets.get("Prets_Master", pd.DataFrame())
    upd = sheets.get("Prets_Update", pd.DataFrame())

    # ── CLIENTS ───────────────────────────────────────────────────────────────
    _hdiv("CLIENTS")
    cli_feats = [
        "FL_Age_Risk_Index","FL_Job_Seniority_vs_Age","FL_Social_Network_Density",
        "FL_Net_Disposable_Income","FL_Financial_Fragility_Index",
        "FL_Loan_to_Income_Ratio","FL_Repayment_Punctuality_Rate",
        "FL_Late_Gravity_Score","FL_Renegotiation_Frequency",
        "FL_Effective_APR","FL_Yield_per_Client",
    ]
    c1, c2 = st.columns(2)
    with c1:
        fig = _pca_cluster(cli, cli_feats, "Nom_Complet", "FL_Risk_Target",
                           "Risque", "CLIENTS  (couleur = FL_Risk_Target)")
        st.plotly_chart(fig, use_container_width=True)
    with c2:
        fig = _pca_cluster(cli, cli_feats, "Nom_Complet", "FL_Financial_Fragility_Index",
                           "Fragilite", "CLIENTS  (couleur = Fragilite Financiere)",
                           colorscale=[[0,"#58a6ff"],[0.5,"#f39c12"],[1,"#c0392b"]])
        st.plotly_chart(fig, use_container_width=True)

    st.divider()

    # ── GARANTS ───────────────────────────────────────────────────────────────
    _hdiv("GARANTS")
    gar_feats = [
        "Revenus_Mensuels","Autres_Revenus","Charges_Estimees",
        "Patrimoine_Declare","Pers_Charge","Anciennete_Emploi","Checking_frequency",
        "DX_Guarantee_Leverage_Score","DX_Family_Pressure_Index",
        "DX_Garant_Availability_Score","DX_Net_Worth_Credibility_Check",
    ]
    if not gar.empty:
        gar = gar.copy()
        rev_g = gar["Revenus_Mensuels"].fillna(0) + gar["Autres_Revenus"].fillna(0)
        gar["_gar_pression"] = (gar["Charges_Estimees"].fillna(0) / rev_g.replace(0, np.nan)).fillna(0).round(3)
        gar["_gar_leverage"] = gar.get("DX_Guarantee_Leverage_Score",
                                        pd.Series(0, index=gar.index)).fillna(0)

    c3, c4 = st.columns(2)
    with c3:
        fig = _pca_cluster(gar, gar_feats, "Nom_Complet", "_gar_pression",
                           "Pression fin.", "GARANTS  (couleur = Charges/Revenus)")
        st.plotly_chart(fig, use_container_width=True)
    with c4:
        fig = _pca_cluster(gar, gar_feats, "Nom_Complet", "_gar_leverage",
                           "Leverage", "GARANTS  (couleur = Leverage Patrimoine)",
                           colorscale=[[0,"#c0392b"],[0.5,"#f39c12"],[1,"#2ecc71"]])
        st.plotly_chart(fig, use_container_width=True)

    st.divider()

    # ── PRETS MASTER ──────────────────────────────────────────────────────────
    _hdiv("PRETS MASTER")
    prt_feats = [
        "Montant_Capital","Taux_Hebdo","Taux_Endettement","Duree_Semaines",
        "Montant_Versement","Montant_Total","Cout_Credit","Nb_Versements",
        "DX_Interest_Yield_Factor","DX_Debt_to_Income_Pressure",
        "DX_Motif_Risk_Weight","DX_Collateral_Coverage_Ratio",
        "EX_Endettement_Critical_Threshold","EX_Duration_Anomaly_Detection",
    ]
    if not prt.empty:
        prt = prt.copy()
        prt["_prt_risk"] = (
            prt.get("DX_Motif_Risk_Weight", pd.Series(0.5, index=prt.index)).fillna(0.5) * 0.5
            + (prt["Taux_Endettement"].fillna(0) / 100).clip(0, 1) * 0.5
        ).round(3)

    c5, c6 = st.columns(2)
    with c5:
        fig = _pca_cluster(prt, prt_feats, "ID_Pret", "_prt_risk",
                           "Risque contrat", "PRETS  (couleur = Motif Risk + Endettement)")
        st.plotly_chart(fig, use_container_width=True)
    with c6:
        fig = _pca_cluster(prt, prt_feats, "Nom_Complet", "Taux_Endettement",
                           "Endettement %", "PRETS  (couleur = Taux_Endettement)",
                           colorscale=[[0,"#2ecc71"],[0.4,"#f39c12"],[1,"#c0392b"]])
        st.plotly_chart(fig, use_container_width=True)

    st.divider()

    # ── PRETS UPDATE ──────────────────────────────────────────────────────────
    _hdiv("PRETS UPDATE  (historique des modifications)")
    upd_feats = [
        "Version","Montant_Capital","Taux_Hebdo","Taux_Endettement",
        "Duree_Semaines","Montant_Total","Cout_Credit",
        "DX_Contract_Volatility_Delta","DX_Update_Velocity",
        "DX_Renegotiation_Gravity_Score","DX_Structural_Fragility_Index",
        "EX_Modification_Pattern_Clustering","EX_Version_Drift_Analysis",
    ]
    if not upd.empty:
        upd = upd.copy()
        upd["_upd_grav"] = upd.get("DX_Renegotiation_Gravity_Score",
            pd.Series(0, index=upd.index)).fillna(0).round(3)
        raw_drift = upd.get("EX_Version_Drift_Analysis", pd.Series(0, index=upd.index)).fillna(0)
        mx = raw_drift.abs().max()
        upd["_upd_drift"] = (raw_drift / mx).round(3) if mx > 0 else pd.Series(0.0, index=upd.index)

    c7, c8 = st.columns(2)
    with c7:
        if upd.empty:
            st.plotly_chart(_ef("Table Prets_Update vide.", 360), use_container_width=True)
        else:
            fig = _pca_cluster(upd, upd_feats, "ID_Pret", "_upd_grav",
                               "Gravite reneg.", "UPDATES  (couleur = Gravite Renegociation)")
            st.plotly_chart(fig, use_container_width=True)
    with c8:
        if upd.empty:
            st.plotly_chart(_ef("Table Prets_Update vide.", 360), use_container_width=True)
        else:
            fig = _pca_cluster(upd, upd_feats, "ID_Pret", "_upd_drift",
                               "Derive montant", "UPDATES  (couleur = Derive Montant Total)",
                               colorscale=[[0,"#58a6ff"],[0.5,"#f39c12"],[1,"#c0392b"]])
            st.plotly_chart(fig, use_container_width=True)


def _render_u2_export(cli: pd.DataFrame, log: list, sheets: dict):
    """U2 : console d'exportation OAG."""
    _title_bar("U2  ·  CONSOLE D'EXPORTATION OAG", _C["success"])

    # Construire le dataset enrichi complet
    prt = sheets.get("Prets_Master", pd.DataFrame())

    # Colonnes metier cli (sans DX_, EX_, FL_ intermediaires ni temporaires)
    base_cols = [c for c in cli.columns
                 if not c.startswith(("DX_","EX_","_"))
                 and c not in _FL_COLS]
    fl_cols_present = [c for c in _FL_COLS if c in cli.columns]

    # Jointure avec agregats Prets pour enrichir le contexte
    if not prt.empty and "ID_Client" in prt.columns:
        prt_agg = prt.groupby("ID_Client").agg(
            nb_prets=("ID_Pret","count"),
            capital_total=("Montant_Capital","sum"),
            taux_moyen=("Taux_Hebdo","mean"),
            duree_moy=("Duree_Semaines","mean"),
            statut_dominant=("Statut", lambda x: x.value_counts().index[0]),
        ).reset_index()
        export_df = cli[base_cols + fl_cols_present].merge(
            prt_agg, on="ID_Client", how="left")
    else:
        export_df = cli[base_cols + fl_cols_present].copy()

    # Preview
    _title_bar("MATRICE OAG  —  APERCU (10 premieres lignes)", _C["success"])
    preview_cols = ["ID_Client"] + [c for c in fl_cols_present if c != "FL_Risk_Target"] + ["FL_Risk_Target"]
    preview_avail = [c for c in preview_cols if c in export_df.columns]
    st.dataframe(
        export_df[preview_avail].head(10).round(4),
        use_container_width=True,
    )

    st.markdown("<br>", unsafe_allow_html=True)

    # Stats de nettoyage
    n_total     = export_df.shape[0] * export_df.shape[1]
    n_null_init = export_df.isnull().sum().sum()
    export_clean = export_df.fillna(export_df.median(numeric_only=True))
    n_imputed   = int(n_null_init)

    _title_bar("LOG DE NETTOYAGE PRE-EXPORT", _C["neutral"])
    clean_log = [
        f"Lignes x colonnes : {export_df.shape[0]} x {export_df.shape[1]}",
        f"Valeurs manquantes imputees par la mediane : {n_imputed}",
        f"Features FL_* incluses : {len(fl_cols_present)}",
        f"Variables categoriques NON encodees (necessite LabelEncoder pour modeles sklearn)",
        f"FL_Risk_Target : variable cible continue [0.0 - 1.0] — compatible regression et classification (seuil 0.4)",
        f"Taille dataset export : {export_clean.memory_usage(deep=True).sum() / 1024:.1f} KB",
    ]
    for line in clean_log:
        icon = "[ INFO ]"
        color = _C["subtext"]
        if "manquantes" in line or "encodees" in line:
            icon = "[ ALERTE ]"
            color = _C["warning"]
        elif "FL_Risk_Target" in line:
            icon = "[ CIBLE ]"
            color = _C["ml"]
        st.markdown(
            f'<div style="font-family:{_FONT};font-size:0.60rem;padding:3px 0;'
            f'border-bottom:1px solid {_C["border"]};color:{_C["text"]};">'
            f'<span style="color:{color};margin-right:10px;">{icon}</span>{line}</div>',
            unsafe_allow_html=True)

    st.markdown("<br>", unsafe_allow_html=True)

    # Bouton de telechargement
    csv_bytes = export_clean.to_csv(index=False).encode("utf-8")
    st.download_button(
        label="TELECHARGER LE DATASET ENRICHI POUR IA  (.CSV)",
        data=csv_bytes,
        file_name=f"VortexFlux_OAG_Dataset_{datetime.today().strftime('%Y%m%d')}.csv",
        mime="text/csv",
        use_container_width=True,
        type="primary",
    )

    # Log complet en expander
    with st.expander("LOG COMPLET DES TRANSFORMATIONS FL_*", expanded=False):
        for i,line in enumerate(log):
            st.markdown(
                f'<div style="font-family:{_FONT};font-size:0.58rem;'
                f'padding:2px 0;color:{_C["text"]};">'
                f'<span style="color:{_C["subtext"]};margin-right:8px;">[{i+1:02d}]</span>'
                f'{line}</div>', unsafe_allow_html=True)


# ── Point d'entree public ─────────────────────────────────────────────────────

def render_feature_store(sheets: dict):
    """
    Appele depuis Usis.py quand mode == "U3 ML FEATURE STORE".
    sheets doit avoir ete enrichi par enrich_dx(), enrich_ex(), enrich_fl().
    """
    cli = sheets.get("Clients_KYC", pd.DataFrame())
    log = sheets.get("_fl_log", [])

    if cli.empty:
        st.error("[ ML ] Table Clients_KYC vide — impossible de calculer les features.")
        return

    fl_present = [c for c in _FL_COLS if c in cli.columns]
    if not fl_present:
        st.warning("[ ML ] Aucune feature FL_* detectee. Verifiez que enrich_fl() a ete appele.")
        return

    tab_u0, tab_u1, tab_u2 = st.tabs([
        "U0  PROTOCOLE INGENIERIE",
        "U1  DIAGNOSTICS ML",
        "U2  EXPORT OAG",
    ])

    with tab_u0:
        _render_u0_protocol(cli, log)

    with tab_u1:
        _render_u1_ml(cli, sheets)

    with tab_u2:
        _render_u2_export(cli, log, sheets)