"""
Module d'ajustement automatique des scores IA basé sur les performances
=======================================================================

Ce module est appelé par ai_predictor.py pour ajuster les scores selon 
les performances récentes. Les cryptos avec mauvaises perfs ont des scores
réduits, mais peuvent être réintégrées automatiquement si elles s'améliorent.
"""

import json
from pathlib import Path
from datetime import datetime
import logging

logger = logging.getLogger('AIScoreAdjuster')

class AIScoreAdjuster:
    """Ajuste les scores IA selon les performances récentes"""
    
    def __init__(self):
        self.stats_file = Path('dynamic_blacklist.json')
        self.monitored_cache = {}
        self.last_update = None
    
    def load_monitored_stats(self):
        """Charge les stats des cryptos surveillées"""
        try:
            if not self.stats_file.exists():
                return {}
            
            with open(self.stats_file, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            # Mettre en cache
            self.monitored_cache = data.get('details', {})
            self.last_update = datetime.now()
            
            return self.monitored_cache
        except Exception as e:
            logger.warning(f"Erreur chargement stats: {e}")
            return {}
    
    def get_score_penalty(self, symbol: str) -> int:
        """
        Calcule la pénalité de score pour une crypto surveillée
        
        Returns:
            int: Pénalité de score (0 à -25)
                 0 = aucune pénalité
                 -5 = win rate 30-40% (léger)
                 -10 = win rate 20-30% (modéré)
                 -15 = win rate 10-20% (sévère)
                 -25 = win rate 0-10% (critique)
        """
        # Rafraîchir cache si nécessaire (toutes les 5 minutes)
        # 🔧 FIX AUDIT 28/02: .seconds → .total_seconds() (sinon cache périmé après 24h+)
        if not self.last_update or (datetime.now() - self.last_update).total_seconds() > 300:
            self.load_monitored_stats()
        
        # Vérifier si crypto surveillée
        if symbol not in self.monitored_cache:
            return 0  # Pas de pénalité si pas surveillée
        
        stats = self.monitored_cache[symbol]
        win_rate = stats.get('win_rate', 50)
        total_trades = stats.get('trades', 0)
        pnl = stats.get('pnl', 0)
        
        # Calculer pénalité selon win rate
        penalty = 0
        
        if win_rate < 10:
            penalty = -25  # Win rate catastrophique
        elif win_rate < 20:
            penalty = -15  # Win rate très mauvais
        elif win_rate < 30:
            penalty = -10  # Win rate mauvais
        elif win_rate < 40:
            penalty = -5   # Win rate faible
        
        # Pénalité additionnelle si perte importante
        if pnl < -2:
            penalty -= 5  # -5 points supplémentaires
        
        # Pénalité moindre si peu de trades (pas assez de données)
        if total_trades < 3:
            penalty = penalty // 2  # Diviser par 2
        
        return penalty
    
    def adjust_score(self, symbol: str, base_score: int) -> int:
        """
        Ajuste le score de base selon les performances récentes
        
        Args:
            symbol: Symbole crypto
            base_score: Score de base calculé par l'IA (0-100)
        
        Returns:
            int: Score ajusté (0-100)
        """
        penalty = self.get_score_penalty(symbol)
        adjusted_score = max(0, min(100, base_score + penalty))
        
        return adjusted_score


# Instance globale
_score_adjuster = None

def get_score_adjuster():
    """Récupère l'instance globale du score adjuster"""
    global _score_adjuster
    if _score_adjuster is None:
        _score_adjuster = AIScoreAdjuster()
    return _score_adjuster