Update src/Analytics/AnalyseRepayment.py

src/Analytics/AnalyseRepayment.py

@@ -0,0 +1,402 @@
+import pandas as pd
+from datetime import datetime, timedelta
+import math
+
+class AnalyseRepayment:
+    """
+    Classe pour gérer toute la logique métier des remboursements
+    """
+    
+    def __init__(self, df_prets, df_remboursements, df_ajustements=None):
+        """
+        Initialise l'analyse avec les données des prêts et remboursements
+        
+        Args:
+            df_prets: DataFrame de Prets_Master
+            df_remboursements: DataFrame de Remboursements
+            df_ajustements: DataFrame de Ajustements_Echeances (optionnel)
+        """
+        self.df_prets = df_prets
+        self.df_remboursements = df_remboursements
+        self.df_ajustements = df_ajustements if df_ajustements is not None else pd.DataFrame()
+    
+    def get_loan_data(self, id_pret):
+        """Récupère les données d'un prêt spécifique"""
+        loan = self.df_prets[self.df_prets['ID_Pret'] == id_pret]
+        if loan.empty:
+            return None
+        return loan.iloc[0]
+    
+    def get_previous_payments(self, id_pret):
+        """Récupère tous les paiements antérieurs pour un prêt"""
+        if self.df_remboursements.empty or 'ID_Pret' not in self.df_remboursements.columns:
+            return []
+        
+        payments = self.df_remboursements[self.df_remboursements['ID_Pret'] == id_pret]
+        return payments.to_dict('records') if not payments.empty else []
+    
+    def parse_echeances(self, dates_versements_str):
+        """
+        Parse la chaîne de dates d'échéances
+        
+        Args:
+            dates_versements_str: "04/01/2026,11/01/2026,18/01/2026"
+        
+        Returns:
+            Liste de datetime.date
+        """
+        if not dates_versements_str or pd.isna(dates_versements_str):
+            return []
+        
+        dates_str = dates_versements_str.split(',')
+        echeances = []
+        
+        for d in dates_str:
+            d = d.strip()
+            if d:
+                try:
+                    # Format attendu : DD/MM/YYYY
+                    date_obj = datetime.strptime(d, "%d/%m/%Y").date()
+                    echeances.append(date_obj)
+                except ValueError:
+                    continue
+        
+        return echeances
+    
+    def detecter_echeance_attendue(self, id_pret, date_paiement):
+        """
+        Détecte quelle échéance correspond au paiement
+        
+        Returns:
+            dict: {
+                'numero': 3,
+                'total': 10,
+                'date_prevue': date(2026,1,18),
+                'montant_echeance': 10600,
+                'montant_ajuste': 14200  # Si ajustement
+            }
+        """
+        loan_data = self.get_loan_data(id_pret)
+        if loan_data is None:
+            return None
+        
+        # Parser les échéances
+        echeances = self.parse_echeances(loan_data['Dates_Versements'])
+        if not echeances:
+            return None
+        
+        # Compter les paiements déjà effectués
+        previous_payments = self.get_previous_payments(id_pret)
+        nb_paiements_faits = len(previous_payments)
+        
+        # L'échéance attendue est la suivante
+        numero_echeance = nb_paiements_faits + 1
+        
+        # Si on dépasse le nombre d'échéances, on prend la dernière
+        if numero_echeance > len(echeances):
+            numero_echeance = len(echeances)
+        
+        date_prevue = echeances[numero_echeance - 1]
+        montant_echeance_base = loan_data['Montant_Versement']
+        
+        # Vérifier s'il y a un ajustement pour cette échéance
+        montant_ajuste = montant_echeance_base
+        if not self.df_ajustements.empty:
+            ajustements = self.df_ajustements[
+                (self.df_ajustements['ID_Pret'] == id_pret) &
+                (self.df_ajustements['Numero_Echeance'] == numero_echeance)
+            ]
+            if not ajustements.empty:
+                montant_additionnel = ajustements['Montant_Additionnel'].sum()
+                montant_ajuste = montant_echeance_base + montant_additionnel
+        
+        return {
+            'numero': numero_echeance,
+            'total': len(echeances),
+            'date_prevue': date_prevue,
+            'montant_echeance': montant_echeance_base,
+            'montant_ajuste': montant_ajuste
+        }
+    
+    def calculer_penalites(self, montant_echeance, date_echeance_prevue, date_paiement, taux_hebdo=0.05):
+        """
+        Calcule les pénalités de retard
+        
+        Args:
+            montant_echeance: Montant de l'échéance
+            date_echeance_prevue: Date attendue
+            date_paiement: Date effective
+            taux_hebdo: Taux par semaine (défaut: 5%)
+        
+        Returns:
+            dict: {
+                'jours_retard': 7,
+                'semaines_retard': 1,
+                'montant_penalites': 530
+            }
+        """
+        if isinstance(date_paiement, str):
+            date_paiement = datetime.strptime(date_paiement, "%Y-%m-%d").date()
+        if isinstance(date_echeance_prevue, str):
+            date_echeance_prevue = datetime.strptime(date_echeance_prevue, "%Y-%m-%d").date()
+        
+        jours_retard = (date_paiement - date_echeance_prevue).days
+        
+        if jours_retard <= 0:
+            return {
+                'jours_retard': jours_retard,
+                'semaines_retard': 0,
+                'montant_penalites': 0
+            }
+        
+        # Calcul par semaine entamée
+        semaines_retard = math.ceil(jours_retard / 7)
+        montant_penalites = montant_echeance * taux_hebdo * semaines_retard
+        
+        return {
+            'jours_retard': jours_retard,
+            'semaines_retard': semaines_retard,
+            'montant_penalites': round(montant_penalites, 0)
+        }
+    
+    def generer_scenarios_penalites(self, montant_echeance, date_echeance_prevue, date_paiement):
+        """
+        Génère 3 scénarios de paiement
+        
+        Returns:
+            list: [scenario1, scenario2, scenario3]
+        """
+        # Scénario 1: Avec pénalités réglementaires (5%)
+        scenario1 = self.calculer_penalites(montant_echeance, date_echeance_prevue, date_paiement, taux_hebdo=0.05)
+        scenario1['label'] = "Règlement Standard"
+        scenario1['taux'] = 5.0
+        scenario1['total_a_encaisser'] = montant_echeance + scenario1['montant_penalites']
+        
+        # Scénario 2: Geste commercial (0%)
+        scenario2 = {
+            'label': "Geste Commercial",
+            'taux': 0.0,
+            'jours_retard': scenario1['jours_retard'],
+            'semaines_retard': 0,
+            'montant_penalites': 0,
+            'total_a_encaisser': montant_echeance
+        }
+        
+        # Scénario 3: Taux personnalisé (défaut: 2.5%)
+        scenario3 = self.calculer_penalites(montant_echeance, date_echeance_prevue, date_paiement, taux_hebdo=0.025)
+        scenario3['label'] = "Taux Personnalisé"
+        scenario3['taux'] = 2.5
+        scenario3['total_a_encaisser'] = montant_echeance + scenario3['montant_penalites']
+        
+        return [scenario1, scenario2, scenario3]
+    
+    def decomposer_versement(self, loan_data, numero_echeance, montant_verse, penalites=0):
+        """
+        Décompose un versement en Principal + Intérêts
+        
+        Args:
+            loan_data: Données du prêt
+            numero_echeance: Numéro de l'échéance
+            montant_verse: Montant total payé par le client
+            penalites: Montant des pénalités
+        
+        Returns:
+            dict: {
+                'montant_principal': 9434,
+                'montant_interets': 1166,
+                'montant_penalites': 530,
+                'montant_pour_dette': 10600  # Montant qui réduit la dette
+            }
+        """
+        montant_total = loan_data['Montant_Total']
+        montant_capital = loan_data['Montant_Capital']
+        nb_versements = loan_data['Nb_Versements']
+        
+        # Intérêts totaux du prêt
+        interets_totaux = montant_total - montant_capital
+        
+        # Répartition linéaire
+        interets_par_echeance = interets_totaux / nb_versements
+        principal_par_echeance = montant_capital / nb_versements
+        
+        # Les pénalités sont prélevées en priorité
+        montant_pour_dette = montant_verse - penalites
+        
+        # Si le montant est insuffisant pour couvrir l'échéance complète
+        montant_echeance_theorique = principal_par_echeance + interets_par_echeance
+        
+        if montant_pour_dette >= montant_echeance_theorique:
+            # Paiement complet ou supérieur
+            return {
+                'montant_principal': round(principal_par_echeance, 0),
+                'montant_interets': round(interets_par_echeance, 0),
+                'montant_penalites': round(penalites, 0),
+                'montant_pour_dette': round(montant_pour_dette, 0)
+            }
+        else:
+            # Paiement partiel : on priorise les intérêts puis le principal
+            if montant_pour_dette >= interets_par_echeance:
+                montant_interets = interets_par_echeance
+                montant_principal = montant_pour_dette - interets_par_echeance
+            else:
+                montant_interets = montant_pour_dette
+                montant_principal = 0
+            
+            return {
+                'montant_principal': round(montant_principal, 0),
+                'montant_interets': round(montant_interets, 0),
+                'montant_penalites': round(penalites, 0),
+                'montant_pour_dette': round(montant_pour_dette, 0)
+            }
+    
+    def calculer_soldes(self, loan_data, previous_payments, montant_pour_dette):
+        """
+        Calcule le solde avant et après paiement
+        
+        Returns:
+            dict: {
+                'solde_avant': 84800,
+                'solde_apres': 74200
+            }
+        """
+        montant_total_du = loan_data['Montant_Total']
+        
+        # Somme des paiements précédents (uniquement la partie qui réduit la dette)
+        total_rembourse = sum(
+            p.get('Montant_Principal', 0) + p.get('Montant_Interets', 0)
+            for p in previous_payments
+        )
+        
+        solde_avant = montant_total_du - total_rembourse
+        solde_apres = solde_avant - montant_pour_dette
+        
+        return {
+            'solde_avant': round(max(0, solde_avant), 0),
+            'solde_apres': round(max(0, solde_apres), 0)
+        }
+    
+    def determiner_statut_paiement(self, jours_retard, montant_verse, montant_echeance_ajuste):
+        """
+        Détermine le statut du paiement
+        
+        Returns:
+            str: PONCTUEL / EN_RETARD / ANTICIPE / PARTIEL
+        """
+        # Tolérance de 1%
+        tolerance = montant_echeance_ajuste * 0.01
+        montant_min_accepte = montant_echeance_ajuste - tolerance
+        
+        # Priorité 1: Retard
+        if jours_retard > 0:
+            return "EN_RETARD"
+        
+        # Priorité 2: Paiement partiel
+        if montant_verse < montant_min_accepte:
+            return "PARTIEL"
+        
+        # Priorité 3: Anticipé
+        if jours_retard < 0:
+            return "ANTICIPE"
+        
+        # Par défaut: Ponctuel
+        return "PONCTUEL"
+    
+    def calculer_montant_a_reporter(self, montant_echeance_ajuste, montant_verse, penalites):
+        """
+        Calcule le montant à reporter sur l'échéance suivante en cas de paiement partiel
+        
+        Returns:
+            float: Montant à ajouter à la prochaine échéance
+        """
+        montant_pour_dette = montant_verse - penalites
+        montant_manquant = montant_echeance_ajuste - montant_pour_dette
+        
+        return max(0, montant_manquant)
+    
+    def analyser_remboursement_complet(self, id_pret, date_paiement, montant_verse, taux_penalite=0.05):
+        """
+        Analyse complète d'un remboursement
+        
+        Args:
+            id_pret: ID du prêt
+            date_paiement: Date du paiement (date ou str)
+            montant_verse: Montant payé par le client
+            taux_penalite: Taux de pénalité appliqué (0.05 = 5%)
+        
+        Returns:
+            dict: Toutes les informations calculées
+        """
+        # Conversion de la date si nécessaire
+        if isinstance(date_paiement, str):
+            date_paiement = datetime.strptime(date_paiement, "%Y-%m-%d").date()
+        
+        # 1. Récupération des données
+        loan_data = self.get_loan_data(id_pret)
+        if loan_data is None:
+            return {'error': 'Prêt non trouvé'}
+        
+        previous_payments = self.get_previous_payments(id_pret)
+        
+        # 2. Détection de l'échéance
+        echeance_info = self.detecter_echeance_attendue(id_pret, date_paiement)
+        if echeance_info is None:
+            return {'error': 'Impossible de déterminer l\'échéance'}
+        
+        # 3. Calcul des pénalités
+        penalites_info = self.calculer_penalites(
+            echeance_info['montant_ajuste'],
+            echeance_info['date_prevue'],
+            date_paiement,
+            taux_hebdo=taux_penalite
+        )
+        
+        # 4. Décomposition du versement
+        decomposition = self.decomposer_versement(
+            loan_data,
+            echeance_info['numero'],
+            montant_verse,
+            penalites=penalites_info['montant_penalites']
+        )
+        
+        # 5. Calcul des soldes
+        soldes = self.calculer_soldes(
+            loan_data,
+            previous_payments,
+            decomposition['montant_pour_dette']
+        )
+        
+        # 6. Détermination du statut
+        statut = self.determiner_statut_paiement(
+            penalites_info['jours_retard'],
+            montant_verse,
+            echeance_info['montant_ajuste']
+        )
+        
+        # 7. Calcul du montant à reporter si partiel
+        montant_a_reporter = 0
+        if statut == "PARTIEL":
+            montant_a_reporter = self.calculer_montant_a_reporter(
+                echeance_info['montant_ajuste'],
+                montant_verse,
+                penalites_info['montant_penalites']
+            )
+        
+        # Compilation des résultats
+        return {
+            'id_pret': id_pret,
+            'id_client': loan_data['ID_Client'],
+            'numero_echeance': f"{echeance_info['numero']}/{echeance_info['total']}",
+            'date_echeance_prevue': echeance_info['date_prevue'],
+            'montant_echeance': echeance_info['montant_echeance'],
+            'montant_ajuste': echeance_info['montant_ajuste'],
+            'jours_retard': penalites_info['jours_retard'],
+            'montant_verse': montant_verse,
+            'montant_principal': decomposition['montant_principal'],
+            'montant_interets': decomposition['montant_interets'],
+            'penalites_retard': decomposition['montant_penalites'],
+            'solde_avant': soldes['solde_avant'],
+            'solde_apres': soldes['solde_apres'],
+            'statut_paiement': statut,
+            'montant_a_reporter': round(montant_a_reporter, 0),
+            'prochaine_echeance': echeance_info['numero'] + 1 if echeance_info['numero'] < echeance_info['total'] else None
+        }