Update src/modules/repayments.py

src/modules/repayments.py

@@ -1,6 +1,13 @@
 import streamlit as st
 import pandas as pd
 from datetime import datetime, date
+import sys
+import os
+
+# Import du module d'analyse
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from Analytics.AnalyseRepayment import AnalyseRepayment
+from DocumentGen.InvoiceRepayment import generer_recu
 
 # === CSS SPÉCIFIQUE REPAYMENTS MODULE ===
 def apply_repayments_styles():
@@ -44,6 +51,118 @@ def apply_repayments_styles():
         font-weight: 700 !important;
     }
     
+    /* Cartes Gotham pour scénarios */
+    .gotham-card {
+        background: linear-gradient(135deg, rgba(22, 27, 34, 0.9) 0%, rgba(13, 17, 23, 0.9) 100%);
+        border: 2px solid rgba(88, 166, 255, 0.3);
+        border-radius: 8px;
+        padding: 20px;
+        margin: 10px 0;
+        transition: all 0.3s ease;
+        position: relative;
+        overflow: hidden;
+    }
+    
+    .gotham-card:hover {
+        border-color: rgba(88, 166, 255, 0.6);
+        transform: translateY(-2px);
+        box-shadow: 0 8px 16px rgba(0, 0, 0, 0.3);
+    }
+    
+    .gotham-card::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        height: 3px;
+        background: linear-gradient(90deg, #58a6ff, #54bd4b);
+    }
+    
+    .gotham-card-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 16px;
+        padding-bottom: 12px;
+        border-bottom: 1px solid rgba(88, 166, 255, 0.2);
+    }
+    
+    .gotham-card-title {
+        font-size: 1.1rem;
+        font-weight: 700;
+        color: #58a6ff;
+        margin: 0;
+    }
+    
+    .gotham-card-badge {
+        background: rgba(88, 166, 255, 0.2);
+        color: #58a6ff;
+        padding: 4px 12px;
+        border-radius: 12px;
+        font-size: 0.75rem;
+        font-weight: 600;
+    }
+    
+    .gotham-card-body {
+        color: #c9d1d9;
+    }
+    
+    .gotham-card-row {
+        display: flex;
+        justify-content: space-between;
+        padding: 8px 0;
+        border-bottom: 1px solid rgba(48, 54, 61, 0.4);
+    }
+    
+    .gotham-card-row:last-child {
+        border-bottom: none;
+    }
+    
+    .gotham-card-label {
+        color: #8b949e;
+        font-size: 0.85rem;
+    }
+    
+    .gotham-card-value {
+        color: #c9d1d9;
+        font-weight: 600;
+        font-size: 0.9rem;
+    }
+    
+    .gotham-card-total {
+        background: rgba(88, 166, 255, 0.1);
+        padding: 12px;
+        border-radius: 6px;
+        margin-top: 12px;
+        text-align: center;
+    }
+    
+    .gotham-card-total-label {
+        color: #8b949e;
+        font-size: 0.8rem;
+        margin-bottom: 4px;
+    }
+    
+    .gotham-card-total-value {
+        color: #58a6ff;
+        font-size: 1.6rem;
+        font-weight: 700;
+    }
+    
+    .gotham-card-impact {
+        margin-top: 12px;
+        padding: 8px;
+        background: rgba(84, 189, 75, 0.1);
+        border-left: 3px solid #54bd4b;
+        border-radius: 4px;
+    }
+    
+    .gotham-card-impact.negative {
+        background: rgba(243, 156, 18, 0.1);
+        border-left-color: #f39c12;
+    }
+    
     /* Expanders pour détails contrat */
     #repayments-module .streamlit-expanderHeader {
         background: rgba(22, 27, 34, 0.7) !important;
@@ -164,22 +283,6 @@ def apply_repayments_styles():
         border-left: 4px solid #e74c3c !important;
     }
     
-    /* Selectbox dropdown */
-    #repayments-module .stSelectbox [data-baseweb="select"] > div {
-        background: rgba(13, 17, 23, 0.9) !important;
-    }
-    
-    /* Colonnes */
-    #repayments-module [data-testid="column"] {
-        padding: 8px;
-    }
-    
-    /* Placeholder text */
-    #repayments-module input::placeholder {
-        color: #6e7681 !important;
-        font-style: italic;
-    }
-    
     /* Success badge style */
     .repayment-success-badge {
         background: linear-gradient(135deg, rgba(84, 189, 75, 0.2), rgba(63, 185, 80, 0.1));
@@ -204,6 +307,42 @@ def apply_repayments_styles():
     </style>
     """, unsafe_allow_html=True)
 
+def render_gotham_card(option_num, label, badge, data):
+    """Génère une carte style Gotham"""
+    
+    html = f"""
+    <div class="gotham-card">
+        <div class="gotham-card-header">
+            <h4 class="gotham-card-title">Option {option_num}</h4>
+            <span class="gotham-card-badge">{badge}</span>
+        </div>
+        <div class="gotham-card-body">
+            <div class="gotham-card-row">
+                <span class="gotham-card-label">Durée de retard</span>
+                <span class="gotham-card-value">{data['jours_retard']} jours ({data['semaines_retard']} semaine{'s' if data['semaines_retard'] > 1 else ''})</span>
+            </div>
+            <div class="gotham-card-row">
+                <span class="gotham-card-label">Montant échéance</span>
+                <span class="gotham-card-value">{data['montant_echeance']:,.0f} XOF</span>
+            </div>
+            <div class="gotham-card-row">
+                <span class="gotham-card-label">Pénalités ({data['taux']}%)</span>
+                <span class="gotham-card-value">+ {data['montant_penalites']:,.0f} XOF</span>
+            </div>
+        </div>
+        <div class="gotham-card-total">
+            <div class="gotham-card-total-label">TOTAL À ENCAISSER</div>
+            <div class="gotham-card-total-value">{data['total_a_encaisser']:,.0f} XOF</div>
+        </div>
+        <div class="gotham-card-impact {'negative' if data['montant_penalites'] == 0 else ''}">
+            <span style="font-size: 0.85rem; color: #c9d1d9;">
+                {data['impact']}
+            </span>
+        </div>
+    </div>
+    """
+    return html
+
 def show_repayments_module(client, sheet_name):
     # Appliquer les styles spécifiques
     apply_repayments_styles()
@@ -211,17 +350,31 @@ def show_repayments_module(client, sheet_name):
     # Wrapper pour isolation
     st.markdown('<div id="repayments-module">', unsafe_allow_html=True)
     
-    st.header("💰 GUICHET DE RECOUVREMENT (CASHFLOW IN)")
+    st.header("GUICHET DE RECOUVREMENT (CASHFLOW IN)")
 
     try:
         sh = client.open(sheet_name)
         ws_prets = sh.worksheet("Prets_Master")
         ws_remb = sh.worksheet("Remboursements")
+        ws_clients = sh.worksheet("Clients_KYC")
+        
+        # Tentative de charger Ajustements_Echeances (créer si n'existe pas)
+        try:
+            ws_ajust = sh.worksheet("Ajustements_Echeances")
+            df_ajust = pd.DataFrame(ws_ajust.get_all_records())
+        except:
+            st.warning("⚠️ Table Ajustements_Echeances non trouvée. Création nécessaire.")
+            df_ajust = pd.DataFrame()
         
         # Chargement des données
         df_prets = pd.DataFrame(ws_prets.get_all_records())
+        df_remb = pd.DataFrame(ws_remb.get_all_records())
+        df_clients = pd.DataFrame(ws_clients.get_all_records())
         
-        # On ne garde que les prêts ACTIFS ou EN RETARD (pas ceux déjà clos)
+        # Initialisation de l'analyseur
+        analyser = AnalyseRepayment(df_prets, df_remb, df_ajust)
+        
+        # On ne garde que les prêts ACTIFS
         if not df_prets.empty and 'ID_Pret' in df_prets.columns:
             active_loans = df_prets[df_prets['Statut'].isin(["ACTIF", "EN_RETARD", "LITIGE"])]
         else:
@@ -235,7 +388,7 @@ def show_repayments_module(client, sheet_name):
         return
 
     # --- 1. SÉLECTION DU PRÊT ---
-    st.subheader("1️⃣ Identifier le Dossier")
+    st.subheader("1. Identifier le Dossier")
     
     # Création liste de choix lisible
     choices = active_loans.apply(
@@ -255,132 +408,351 @@ def show_repayments_module(client, sheet_name):
         loan_data = active_loans[active_loans['ID_Pret'] == loan_id].iloc[0]
 
         # Affichage du contexte
-        with st.expander("📄 Détails du contrat", expanded=True):
+        with st.expander("Détails du contrat", expanded=True):
             c1, c2, c3 = st.columns(3)
             with c1:
-                st.metric("💵 Capital Prêté", f"{loan_data['Montant_Capital']:,.0f} XOF")
+                st.metric("Capital Prêté", f"{loan_data['Montant_Capital']:,.0f} XOF")
             with c2:
-                st.metric("💰 Montant Total Dû", f"{loan_data['Montant_Total']:,.0f} XOF")
+                st.metric("Montant Total Dû", f"{loan_data['Montant_Total']:,.0f} XOF")
             with c3:
-                st.metric("📅 Échéance Prévue", f"{loan_data['Montant_Versement']:,.0f} XOF")
+                st.metric("Échéance Prévue", f"{loan_data['Montant_Versement']:,.0f} XOF")
             
-            # Informations supplémentaires
             st.caption(f"**Client :** {loan_data['Nom_Complet']}")
             st.caption(f"**Date de début :** {loan_data.get('Date_Deblocage', 'N/A')}")
             st.caption(f"**Statut actuel :** {loan_data['Statut']}")
 
-        # --- 2. SAISIE DU PAIEMENT ---
+        # --- 2. ANALYSE DE L'ÉCHÉANCE ---
         st.divider()
-        st.subheader("2️⃣ Enregistrement du Paiement")
-
-        with st.form("repayment_form", clear_on_submit=True):
-            col_a, col_b = st.columns(2)
-            
+        st.subheader("2. Analyse de l'Échéance en Cours")
+        
+        # Date du paiement
+        date_paiement = st.date_input("Date du paiement", value=date.today())
+        
+        # Analyse automatique
+        echeance_info = analyser.detecter_echeance_attendue(loan_id, date_paiement)
+        
+        if echeance_info:
+            col_a, col_b, col_c = st.columns(3)
             with col_a:
-                date_paiement = st.date_input(
-                    "📅 Date du paiement", 
-                    value=date.today(),
-                    help="Date effective de réception des fonds"
-                )
-                montant_verse = st.number_input(
-                    "💵 Montant Versé (XOF)", 
-                    min_value=1000, 
-                    step=5000,
-                    help="Montant exact reçu"
-                )
-            
+                st.metric("Échéance Attendue", f"{echeance_info['numero']}/{echeance_info['total']}")
             with col_b:
-                moyen = st.selectbox(
-                    "💳 Moyen de Paiement", 
-                    ["Espèces", "Mobile Money (Wave)", "Mobile Money (Orange Money)", "Virement Bancaire", "Chèque"],
-                    help="Canal de réception des fonds"
-                )
-                commentaire = st.text_input(
-                    "📝 Référence / Commentaire", 
-                    placeholder="Ex: Transaction ID Wave, Numéro de chèque...",
-                    help="Informations de traçabilité"
+                st.metric("Date Prévue", echeance_info['date_prevue'].strftime("%d/%m/%Y"))
+            with col_c:
+                st.metric("Montant Échéance", f"{echeance_info['montant_ajuste']:,.0f} XOF")
+            
+            # Calcul du retard
+            penalites_base = analyser.calculer_penalites(
+                echeance_info['montant_ajuste'],
+                echeance_info['date_prevue'],
+                date_paiement
+            )
+            
+            jours_retard = penalites_base['jours_retard']
+            
+            # --- 3. SCÉNARIOS DE PÉNALITÉS (si retard détecté) ---
+            if jours_retard >= 1:
+                st.divider()
+                st.warning(f"⚠️ RETARD DÉTECTÉ : {jours_retard} jours")
+                st.subheader("3. Choix du Scénario de Pénalités")
+                
+                # Génération des 3 scénarios
+                scenarios = analyser.generer_scenarios_penalites(
+                    echeance_info['montant_ajuste'],
+                    echeance_info['date_prevue'],
+                    date_paiement
                 )
+                
+                # Ajout de l'impact business
+                scenarios[0]['impact'] = f"Gain structure : +{scenarios[0]['montant_penalites']:,.0f} XOF | Applique pénalités réglementaires"
+                scenarios[1]['impact'] = f"Manque à gagner : -{scenarios[0]['montant_penalites']:,.0f} XOF | Geste de fidélisation client"
+                scenarios[2]['impact'] = f"Gain structure : +{scenarios[2]['montant_penalites']:,.0f} XOF | Compromis équitable"
+                
+                # Enrichir avec les données nécessaires
+                for s in scenarios:
+                    s['montant_echeance'] = echeance_info['montant_ajuste']
+                    s['semaines_retard'] = s.get('semaines_retard', penalites_base['semaines_retard'])
+                
+                # Affichage des cartes
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.markdown(render_gotham_card(1, "Règlement Standard", "5%", scenarios[0]), unsafe_allow_html=True)
+                    if st.button("Sélectionner Option 1", key="opt1", use_container_width=True):
+                        st.session_state['selected_scenario'] = scenarios[0]
+                
+                with col2:
+                    st.markdown(render_gotham_card(2, "Geste Commercial", "0%", scenarios[1]), unsafe_allow_html=True)
+                    if st.button("Sélectionner Option 2", key="opt2", use_container_width=True):
+                        st.session_state['selected_scenario'] = scenarios[1]
+                
+                with col3:
+                    st.markdown(render_gotham_card(3, "Taux Personnalisé", "Custom", scenarios[2]), unsafe_allow_html=True)
+                    
+                    # Slider pour taux personnalisé
+                    taux_custom = st.slider(
+                        "Taux de pénalité (%)",
+                        min_value=0.0,
+                        max_value=5.0,
+                        value=2.5,
+                        step=0.5,
+                        key="taux_slider"
+                    )
+                    
+                    # Recalcul automatique
+                    if taux_custom != 2.5:
+                        scenario_custom = analyser.calculer_penalites(
+                            echeance_info['montant_ajuste'],
+                            echeance_info['date_prevue'],
+                            date_paiement,
+                            taux_hebdo=taux_custom / 100
+                        )
+                        scenario_custom['label'] = "Taux Personnalisé"
+                        scenario_custom['taux'] = taux_custom
+                        scenario_custom['total_a_encaisser'] = echeance_info['montant_ajuste'] + scenario_custom['montant_penalites']
+                        scenario_custom['impact'] = f"Gain structure : +{scenario_custom['montant_penalites']:,.0f} XOF | Taux ajusté"
+                        scenario_custom['montant_echeance'] = echeance_info['montant_ajuste']
+                        scenario_custom['semaines_retard'] = scenario_custom.get('semaines_retard', penalites_base['semaines_retard'])
+                        
+                        st.markdown(render_gotham_card(3, "Taux Personnalisé", f"{taux_custom}%", scenario_custom), unsafe_allow_html=True)
+                    
+                    if st.button("Sélectionner Option 3", key="opt3", use_container_width=True):
+                        if taux_custom != 2.5:
+                            st.session_state['selected_scenario'] = scenario_custom
+                        else:
+                            st.session_state['selected_scenario'] = scenarios[2]
+                
+                # Affichage du scénario sélectionné
+                if 'selected_scenario' in st.session_state:
+                    selected = st.session_state['selected_scenario']
+                    st.success(f"Scénario sélectionné : {selected['label']} ({selected['taux']}% de pénalités)")
+                    st.info(f"Montant total à encaisser : **{selected['total_a_encaisser']:,.0f} XOF**")
+            else:
+                # Pas de retard
+                if jours_retard < 0:
+                    st.success(f"Paiement anticipé de {abs(jours_retard)} jours")
+                else:
+                    st.success("Paiement dans les délais")
+                
+                st.session_state['selected_scenario'] = {
+                    'taux': 0.0,
+                    'montant_penalites': 0,
+                    'total_a_encaisser': echeance_info['montant_ajuste']
+                }
 
-            # Checkbox pour clore le dossier
-            st.markdown("---")
-            cloture = st.checkbox(
-                "✅ Ce paiement solde la totalité du prêt (Clôturer le dossier)",
-                help="Cochez uniquement si le montant versé couvre l'intégralité du solde restant"
-            )
+            # --- 4. SAISIE DU PAIEMENT ---
+            st.divider()
+            st.subheader("4. Enregistrement du Paiement")
 
-            submit = st.form_submit_button("🔒 VALIDER L'ENCAISSEMENT", use_container_width=True)
+            with st.form("repayment_form", clear_on_submit=True):
+                col_a, col_b = st.columns(2)
+                
+                with col_a:
+                    montant_verse = st.number_input(
+                        "Montant Versé (XOF)", 
+                        min_value=1000, 
+                        step=5000,
+                        value=int(st.session_state.get('selected_scenario', {}).get('total_a_encaisser', echeance_info['montant_ajuste'])),
+                        help="Montant exact reçu"
+                    )
+                
+                with col_b:
+                    moyen = st.selectbox(
+                        "Moyen de Paiement", 
+                        ["Espèces", "Mobile Money (Wave)", "Mobile Money (Orange Money)", "Virement Bancaire", "Chèque"],
+                        help="Canal de réception des fonds"
+                    )
+                
+                reference_externe = st.text_input(
+                    "Référence Transaction", 
+                    placeholder="Ex: WAVE-TXN-123456, Numéro de chèque...",
+                    help="Référence externe pour traçabilité"
+                )
+                
+                commentaire = st.text_area(
+                    "Commentaire", 
+                    placeholder="Notes additionnelles sur la transaction...",
+                    help="Informations complémentaires"
+                )
 
-        if submit:
-            # Validation du montant
-            if montant_verse <= 0:
-                st.error("❌ Le montant versé doit être supérieur à 0 XOF")
-            else:
-                try:
-                    # Génération ID Transaction
-                    existing_remb = ws_remb.get_all_values()
-                    next_id = len(existing_remb)  # Compte les lignes (incluant header)
-                    trans_id = f"TRX-2025-{next_id:04d}"
-                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                # Checkbox pour clore le dossier
+                st.markdown("---")
+                cloture = st.checkbox(
+                    "Ce paiement solde la totalité du prêt (Clôturer le dossier)",
+                    help="Cochez uniquement si le montant versé couvre l'intégralité du solde restant"
+                )
 
-                    # 1. Écriture dans Remboursements
-                    new_row = [
-                        trans_id,
-                        loan_id,
-                        str(date_paiement),
-                        montant_verse,
-                        moyen,
-                        commentaire if commentaire else "N/A",
-                        timestamp
-                    ]
-                    ws_remb.append_row(new_row)
+                submit = st.form_submit_button("VALIDER L'ENCAISSEMENT", use_container_width=True)
 
-                    # 2. Mise à jour du Statut si clôture
-                    if cloture:
-                        # Trouver la ligne du prêt
-                        cell = ws_prets.find(loan_id)
-                        header = ws_prets.row_values(1)
-                        col_statut_idx = header.index("Statut") + 1
+            if submit:
+                if montant_verse <= 0:
+                    st.error("❌ Le montant versé doit être supérieur à 0 XOF")
+                else:
+                    try:
+                        # Récupération du taux de pénalité sélectionné
+                        taux_penalite = st.session_state.get('selected_scenario', {}).get('taux', 0.0) / 100
                         
-                        # Update de la cellule
-                        ws_prets.update_cell(cell.row, col_statut_idx, "CLOTURE")
+                        # Analyse complète
+                        analyse_complete = analyser.analyser_remboursement_complet(
+                            loan_id,
+                            date_paiement,
+                            montant_verse,
+                            taux_penalite=taux_penalite
+                        )
                         
-                        # Badge de succès
-                        st.markdown(f"""
-                        <div class="repayment-success-badge">
-                            <h3>✅ DOSSIER {loan_id} CLÔTURÉ</h3>
-                            <p style="color: #8b949e; margin: 8px 0 0 0;">
-                                Paiement de {montant_verse:,.0f} XOF enregistré | Ref: {trans_id}
-                            </p>
-                        </div>
-                        """, unsafe_allow_html=True)
-                    else:
-                        st.success(f"✅ Paiement de **{montant_verse:,.0f} XOF** enregistré avec succès")
-                        st.info(f"📋 Référence de transaction : **{trans_id}**")
-                    
-                    # Afficher un récapitulatif
-                    with st.expander("📊 Récapitulatif de la transaction", expanded=True):
-                        recap_col1, recap_col2 = st.columns(2)
-                        with recap_col1:
-                            st.write(f"**ID Transaction :** {trans_id}")
-                            st.write(f"**ID Prêt :** {loan_id}")
-                            st.write(f"**Date :** {date_paiement}")
-                        with recap_col2:
-                            st.write(f"**Montant :** {montant_verse:,.0f} XOF")
-                            st.write(f"**Moyen :** {moyen}")
-                            st.write(f"**Statut :** {'CLÔTURÉ ✅' if cloture else 'ACTIF 🔄'}")
+                        if 'error' in analyse_complete:
+                            st.error(f"❌ {analyse_complete['error']}")
+                        else:
+                            # Génération ID Transaction
+                            existing_remb = ws_remb.get_all_values()
+                            next_id = len(existing_remb)
+                            trans_id = f"TRX-2026-{next_id:04d}"
+                            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            
+                            # Génération Numéro Reçu
+                            annee_actuelle = datetime.now().year
+                            count_annee = len([r for r in existing_remb if f"REC-{annee_actuelle}" in str(r)])
+                            numero_recu = f"REC-{annee_actuelle}-{count_annee + 1:04d}"
+
+                            # 1. Écriture dans Remboursements
+                            new_row = [
+                                trans_id,
+                                loan_id,
+                                analyse_complete['id_client'],
+                                str(date_paiement),
+                                montant_verse,
+                                analyse_complete['montant_principal'],
+                                analyse_complete['montant_interets'],
+                                analyse_complete['penalites_retard'],
+                                analyse_complete['solde_avant'],
+                                analyse_complete['solde_apres'],
+                                analyse_complete['numero_echeance'],
+                                str(analyse_complete['date_echeance_prevue']),
+                                analyse_complete['jours_retard'],
+                                analyse_complete['statut_paiement'],
+                                moyen,
+                                reference_externe if reference_externe else "N/A",
+                                commentaire if commentaire else "N/A",
+                                "NON",  # Recu_Emis (par défaut NON, sera mis à OUI si généré)
+                                numero_recu,
+                                timestamp
+                            ]
+                            ws_remb.append_row(new_row)
+
+                            # 2. Gestion des ajustements si PARTIEL
+                            if analyse_complete['statut_paiement'] == "PARTIEL" and analyse_complete['montant_a_reporter'] > 0:
+                                if analyse_complete['prochaine_echeance']:
+                                    # Génération ID Ajustement
+                                    try:
+                                        existing_ajust = ws_ajust.get_all_values()
+                                        next_ajust_id = len(existing_ajust)
+                                    except:
+                                        # Si la table n'existe pas, la créer
+                                        ws_ajust = sh.add_worksheet(title="Ajustements_Echeances", rows="1000", cols="7")
+                                        ws_ajust.append_row(["ID_Ajustement", "ID_Pret", "Numero_Echeance", "Montant_Additionnel", "Raison", "Date_Creation", "Timestamp"])
+                                        next_ajust_id = 1
+                                    
+                                    ajust_id = f"ADJ-{annee_actuelle}-{next_ajust_id:04d}"
+                                    
+                                    ajust_row = [
+                                        ajust_id,
+                                        loan_id,
+                                        analyse_complete['prochaine_echeance'],
+                                        analyse_complete['montant_a_reporter'],
+                                        "PAIEMENT_PARTIEL",
+                                        str(date.today()),
+                                        timestamp
+                                    ]
+                                    ws_ajust.append_row(ajust_row)
+                                    
+                                    st.warning(f"⚠️ Paiement PARTIEL détecté. {analyse_complete['montant_a_reporter']:,.0f} XOF reportés sur l'échéance #{analyse_complete['prochaine_echeance']}")
 
-                except Exception as e:
-                    st.error(f"❌ Erreur lors de l'enregistrement : {e}")
-                    st.exception(e)
+                            # 3. Mise à jour du Statut si clôture
+                            if cloture or analyse_complete['solde_apres'] <= 0:
+                                cell = ws_prets.find(loan_id)
+                                header = ws_prets.row_values(1)
+                                col_statut_idx = header.index("Statut") + 1
+                                ws_prets.update_cell(cell.row, col_statut_idx, "CLOTURE")
+                                
+                                st.markdown(f"""
+                                <div class="repayment-success-badge">
+                                    <h3>DOSSIER {loan_id} CLÔTURÉ</h3>
+                                    <p style="color: #8b949e; margin: 8px 0 0 0;">
+                                        Paiement de {montant_verse:,.0f} XOF enregistré | Ref: {trans_id}
+                                    </p>
+                                </div>
+                                """, unsafe_allow_html=True)
+                            else:
+                                st.success(f"Paiement de **{montant_verse:,.0f} XOF** enregistré avec succès")
+                                st.info(f"Référence de transaction : **{trans_id}**")
+                            
+                            # Afficher un récapitulatif détaillé
+                            with st.expander("Récapitulatif de la transaction", expanded=True):
+                                recap_col1, recap_col2, recap_col3 = st.columns(3)
+                                with recap_col1:
+                                    st.write(f"**ID Transaction :** {trans_id}")
+                                    st.write(f"**ID Prêt :** {loan_id}")
+                                    st.write(f"**Date :** {date_paiement}")
+                                    st.write(f"**Échéance :** {analyse_complete['numero_echeance']}")
+                                with recap_col2:
+                                    st.write(f"**Montant Versé :** {montant_verse:,.0f} XOF")
+                                    st.write(f"**Principal :** {analyse_complete['montant_principal']:,.0f} XOF")
+                                    st.write(f"**Intérêts :** {analyse_complete['montant_interets']:,.0f} XOF")
+                                    st.write(f"**Pénalités :** {analyse_complete['penalites_retard']:,.0f} XOF")
+                                with recap_col3:
+                                    st.write(f"**Solde Avant :** {analyse_complete['solde_avant']:,.0f} XOF")
+                                    st.write(f"**Solde Après :** {analyse_complete['solde_apres']:,.0f} XOF")
+                                    st.write(f"**Moyen :** {moyen}")
+                                    st.write(f"**Statut :** {analyse_complete['statut_paiement']}")
+                            
+                            # Bouton pour générer le reçu
+                            st.divider()
+                            if st.button("Générer le Reçu", use_container_width=True):
+                                # Préparer les données pour le reçu
+                                client_data = df_clients[df_clients['ID_Client'] == analyse_complete['id_client']].iloc[0].to_dict()
+                                
+                                recu_data = {
+                                    'numero_recu': numero_recu,
+                                    'trans_id': trans_id,
+                                    'date_paiement': date_paiement,
+                                    'client': client_data,
+                                    'loan': loan_data.to_dict(),
+                                    'paiement': analyse_complete,
+                                    'moyen': moyen,
+                                    'reference': reference_externe
+                                }
+                                
+                                pdf_bytes = generer_recu(recu_data)
+                                
+                                if pdf_bytes:
+                                    # Mise à jour de Recu_Emis dans Remboursements
+                                    cell_trans = ws_remb.find(trans_id)
+                                    header_remb = ws_remb.row_values(1)
+                                    col_recu_idx = header_remb.index("Recu_Emis") + 1
+                                    ws_remb.update_cell(cell_trans.row, col_recu_idx, "OUI")
+                                    
+                                    st.download_button(
+                                        label="Télécharger le Reçu PDF",
+                                        data=pdf_bytes,
+                                        file_name=f"{numero_recu}_{loan_id}.pdf",
+                                        mime="application/pdf",
+                                        use_container_width=True
+                                    )
+                                    st.success("Reçu généré avec succès")
+                                else:
+                                    st.error("❌ Erreur lors de la génération du reçu")
+
+                    except Exception as e:
+                        st.error(f"❌ Erreur lors de l'enregistrement : {e}")
+                        st.exception(e)
+        else:
+            st.error("❌ Impossible d'analyser l'échéance pour ce prêt")
     
     else:
-        # Instructions si aucun prêt sélectionné
-        st.info("👆 Veuillez sélectionner un prêt dans la liste ci-dessus pour commencer")
+        st.info("Veuillez sélectionner un prêt dans la liste ci-dessus pour commencer")
         
-        # Afficher statistiques rapides
         if not active_loans.empty:
             st.markdown("---")
-            st.subheader("📊 Vue d'ensemble des prêts actifs")
+            st.subheader("Vue d'ensemble des prêts actifs")
             
             stat_col1, stat_col2, stat_col3 = st.columns(3)
             with stat_col1:
@@ -392,5 +764,4 @@ def show_repayments_module(client, sheet_name):
                 avg_loan = active_loans['Montant_Capital'].mean() if 'Montant_Capital' in active_loans.columns else 0
                 st.metric("Prêt Moyen", f"{avg_loan:,.0f} XOF")
     
-    # Fermeture du wrapper
     st.markdown('</div>', unsafe_allow_html=True)