"""
Blacklist Manager - Gestionnaire Simplifié de Blacklist
=========================================================
Exclut uniquement les STABLECOINS et cryptos basées sur des notions monétaires.
Le reste de l'analyse des performances est géré par le script IA.

Auteur: AI Trading Bot
Date: 29/12/2025
"""

import json
import os
from datetime import datetime
from typing import Dict, List, Tuple, Optional
import logging

logger = logging.getLogger(__name__)

# Fichier de stockage de la blacklist
BLACKLIST_FILE = "dynamic_blacklist.json"

# ═══════════════════════════════════════════════════════════════════════════════
# LISTE PERMANENTE DES STABLECOINS ET CRYPTOS À EXCLURE
# ═══════════════════════════════════════════════════════════════════════════════

PERMANENT_BLACKLIST = {
    # STABLECOINS (valeur fixe ~1$)
    "USDCUSDT": "Stablecoin - USD Coin",
    "BUSDUSDT": "Stablecoin - Binance USD",
    "DAIUSDT": "Stablecoin - DAI",
    "TUSDUSDT": "Stablecoin - TrueUSD",
    "USDPUSDT": "Stablecoin - Pax Dollar",
    "FDUSDUSDT": "Stablecoin - First Digital USD",
    "PYUSDUSDT": "Stablecoin - PayPal USD",
    "FRAXUSDT": "Stablecoin - Frax",
    "LUSDUSDT": "Stablecoin - Liquity USD",
    "USTCUSDT": "Stablecoin - TerraClassicUSD",
    
    # DEVISES FIAT
    "EURUSDT": "Devise fiat - Euro",
    "GBPUSDT": "Devise fiat - Livre sterling",
    
    # OR TOKENISÉ
    "PAXGUSDT": "Or tokenisé - volatilité trop faible",
    "XAUTUSDT": "Or tokenisé Tether Gold",
    
    # WRAPPED TOKENS
    "WBTCUSDT": "Wrapped Bitcoin - préférer BTCUSDT",
    "WBETHUSDT": "Wrapped Beacon ETH",
    "STETHUSDT": "Staked ETH - préférer ETHUSDT",
    "CBETHUSDT": "Coinbase Wrapped Staked ETH",
    "RETHUSDT": "Rocket Pool ETH - préférer ETHUSDT",
    "BETHUSDT": "Binance Staked ETH",
    
    # TOKENS PROBLÉMATIQUES
    "LUNCUSDT": "Luna Classic - balance insuffisante",
}

# Symboles à TOUJOURS surveiller (whitelist) - NE JAMAIS BLACKLISTER
PERMANENT_WHITELIST = [
    "BTCUSDT",
    "ETHUSDT",
    "BNBUSDT",
    "SOLUSDT",
    "XRPUSDT",
    "ADAUSDT",
    "DOGEUSDT",
]


class BlacklistManager:
    """Gestionnaire de blacklist simplifié - Focus sur stablecoins et monétaires"""
    
    def __init__(self, trade_history_file: str = "trade_history.json"):
        self.trade_history_file = trade_history_file
        self.blacklist_file = BLACKLIST_FILE
        self.blacklist: Dict[str, dict] = {}
        self.whitelist: List[str] = list(PERMANENT_WHITELIST)
        self.load_blacklist()
        self._init_permanent_blacklist()
    
    def _init_permanent_blacklist(self):
        """Initialiser la blacklist avec les stablecoins permanents"""
        for symbol, reason in PERMANENT_BLACKLIST.items():
            if symbol not in self.blacklist:
                self.blacklist[symbol] = {
                    'permanent': True,
                    'since': datetime.now().isoformat(),
                    'reason': reason,
                    'category': 'stablecoin' if 'Stablecoin' in reason else 'monetary'
                }
        self.save_blacklist()
    
    def load_blacklist(self):
        """Charger la blacklist depuis le fichier"""
        try:
            if os.path.exists(self.blacklist_file):
                with open(self.blacklist_file, 'r') as f:
                    data = json.load(f)
                    # Support des deux formats (ancien array et nouveau dict)
                    blacklist_data = data.get('blacklist', {})
                    if isinstance(blacklist_data, list):
                        # Ancien format array - convertir en dict
                        logger.info("⚠️ Conversion de l'ancien format array vers dict")
                        self.blacklist = {}
                        details = data.get('details', {})
                        for symbol in blacklist_data:
                            if symbol in details:
                                self.blacklist[symbol] = details[symbol]
                            else:
                                self.blacklist[symbol] = {
                                    'permanent': False,
                                    'since': datetime.now().isoformat(),
                                    'reason': 'Performance insuffisante',
                                    'category': 'manual'
                                }
                    else:
                        # Nouveau format dict - utiliser directement
                        self.blacklist = blacklist_data
                    
                    self.whitelist = data.get('whitelist', list(PERMANENT_WHITELIST))
                    logger.info(f"✅ Blacklist chargée: {len(self.blacklist)} symboles exclus")
        except Exception as e:
            logger.error(f"❌ Erreur chargement blacklist: {e}")
            self.blacklist = {}
    
    def save_blacklist(self):
        """Sauvegarder la blacklist dans le fichier"""
        try:
            data = {
                'blacklist': self.blacklist,
                'whitelist': self.whitelist,
                'last_update': datetime.now().isoformat(),
                'info': {
                    'description': 'Blacklist simplifiée - Stablecoins et cryptos monétaires uniquement',
                    'permanent_count': len([k for k, v in self.blacklist.items() if v.get('permanent')]),
                    'manual_count': len([k for k, v in self.blacklist.items() if not v.get('permanent')])
                }
            }
            with open(self.blacklist_file, 'w') as f:
                json.dump(data, f, indent=2, default=str)
        except Exception as e:
            logger.error(f"❌ Erreur sauvegarde blacklist: {e}")
    
    def is_blacklisted(self, symbol: str) -> Tuple[bool, Optional[str]]:
        """Vérifier si un symbole est blacklisté"""
        # Vérifier la whitelist d'abord
        if symbol in self.whitelist:
            return False, None
        
        # Vérifier la blacklist permanente
        if symbol in PERMANENT_BLACKLIST:
            return True, PERMANENT_BLACKLIST[symbol]
        
        # Vérifier la blacklist personnalisée
        if symbol in self.blacklist:
            info = self.blacklist[symbol]
            return True, info.get('reason', 'Blacklisté manuellement')
        
        return False, None
    
    def add_to_blacklist(self, symbol: str, reason: str = "Ajout manuel"):
        """Ajouter manuellement un symbole à la blacklist"""
        if symbol in self.whitelist:
            logger.warning(f"⚠️ {symbol} est dans la whitelist, impossible de blacklister")
            return False
        
        self.blacklist[symbol] = {
            'permanent': False,
            'since': datetime.now().isoformat(),
            'reason': reason,
            'category': 'manual'
        }
        self.save_blacklist()
        logger.info(f"🚫 {symbol} ajouté à la blacklist: {reason}")
        return True
    
    def remove_from_blacklist(self, symbol: str) -> bool:
        """Retirer un symbole de la blacklist (sauf permanents)"""
        if symbol in PERMANENT_BLACKLIST:
            logger.warning(f"⚠️ {symbol} est un stablecoin/monétaire permanent, impossible de retirer")
            return False
        
        if symbol in self.blacklist:
            del self.blacklist[symbol]
            self.save_blacklist()
            logger.info(f"✅ {symbol} retiré de la blacklist")
            return True
        return False
    
    def get_blacklist(self) -> Dict[str, dict]:
        """Retourner la blacklist complète"""
        return self.blacklist
    
    def get_permanent_blacklist(self) -> Dict[str, str]:
        """Retourner la liste des stablecoins/monétaires permanents"""
        return PERMANENT_BLACKLIST
    
    def add_to_whitelist(self, symbol: str):
        """Ajouter à la whitelist (protection contre blacklist)"""
        if symbol not in self.whitelist:
            self.whitelist.append(symbol)
            # Retirer de la blacklist si présent (sauf permanents)
            if symbol in self.blacklist and not self.blacklist[symbol].get('permanent'):
                del self.blacklist[symbol]
            self.save_blacklist()
            logger.info(f"✅ {symbol} ajouté à la whitelist")
    
    def remove_from_whitelist(self, symbol: str):
        """Retirer de la whitelist"""
        if symbol in self.whitelist and symbol not in PERMANENT_WHITELIST:
            self.whitelist.remove(symbol)
            self.save_blacklist()
            logger.info(f"✅ {symbol} retiré de la whitelist")
    
    def clear_manual_blacklist(self) -> int:
        """Vider uniquement les entrées manuelles (pas les permanentes)"""
        count = 0
        to_remove = []
        for symbol, info in self.blacklist.items():
            if not info.get('permanent') and symbol not in PERMANENT_BLACKLIST:
                to_remove.append(symbol)
        
        for symbol in to_remove:
            del self.blacklist[symbol]
            count += 1
        
        self.save_blacklist()
        logger.info(f"🗑️ {count} entrées manuelles supprimées de la blacklist")
        return count
    
    def get_stats(self) -> dict:
        """Retourner les statistiques de la blacklist"""
        permanent = len([k for k, v in self.blacklist.items() if v.get('permanent')])
        manual = len([k for k, v in self.blacklist.items() if not v.get('permanent')])
        
        return {
            'total': len(self.blacklist),
            'permanent': permanent,
            'manual': manual,
            'whitelist': len(self.whitelist),
            'stablecoins': len(PERMANENT_BLACKLIST)
        }
    
    # Compatibilité avec l'ancien code
    def force_blacklist(self, symbol: str, reason: str, hours: int = 6):
        """Compatibilité - Ajoute manuellement"""
        return self.add_to_blacklist(symbol, reason)
    
    def force_unblacklist(self, symbol: str):
        """Compatibilité - Retire de la blacklist"""
        return self.remove_from_blacklist(symbol)
    
    def clear_blacklist(self) -> int:
        """Compatibilité - Vide les entrées manuelles"""
        return self.clear_manual_blacklist()


# Instance globale
_blacklist_manager = None


def get_blacklist_manager() -> BlacklistManager:
    """Retourne l'instance globale du gestionnaire de blacklist"""
    global _blacklist_manager
    if _blacklist_manager is None:
        _blacklist_manager = BlacklistManager()
    return _blacklist_manager


def is_blacklisted(symbol: str) -> Tuple[bool, Optional[str]]:
    """Fonction utilitaire pour vérifier si un symbole est blacklisté"""
    return get_blacklist_manager().is_blacklisted(symbol)


# Alias pour compatibilité avec l'ancien code
is_symbol_blacklisted = is_blacklisted


def update_dynamic_blacklist():
    """Fonction de compatibilité - réinitialise la blacklist permanente"""
    manager = get_blacklist_manager()
    manager._init_permanent_blacklist()
    return manager.get_stats()


def is_stablecoin(symbol: str) -> bool:
    """Vérifier si un symbole est un stablecoin"""
    return symbol in PERMANENT_BLACKLIST


if __name__ == "__main__":
    # Test
    manager = get_blacklist_manager()
    
    print("=== Blacklist Manager - Test ===")
    print(f"\nStablecoins/Monétaires permanents: {len(PERMANENT_BLACKLIST)}")
    for symbol, reason in PERMANENT_BLACKLIST.items():
        print(f"  🚫 {symbol}: {reason}")
    
    print(f"\nWhitelist protégée: {manager.whitelist}")
    
    # Test is_blacklisted
    test_symbols = ["BTCUSDT", "USDCUSDT", "PAXGUSDT", "SOLUSDT"]
    print("\nTests:")
    for sym in test_symbols:
        is_bl, reason = manager.is_blacklisted(sym)
        status = f"🚫 BLACKLISTÉ ({reason})" if is_bl else "✅ OK"
        print(f"  {sym}: {status}")
    
    stats = manager.get_stats()
    print(f"\nStatistiques: {stats}")