import ccxt
import logging

logger = logging.getLogger(__name__)

class BinanceClient:
    def __init__(self, preferred_exchange='bitget'):
        """
        Inicializa cliente con exchange preferido
        Exchanges disponibles: 'bitget', 'bybit', 'kucoin'
        """
        self.preferred_exchange = preferred_exchange
        self.spot = None
        self.futures = None
        self.active_exchange = None
        
        # ✅ Si por error llega 'binance', lo cambiamos silenciosamente a 'bitget'
        if self.preferred_exchange.lower() == 'binance':
            logger.warning("⚠️ 'binance' detectado en config. Cambiando automáticamente a 'bitget' para evitar bloqueo 451.")
            self.preferred_exchange = 'bitget'
        
        # Intentar crear cliente con exchange preferido
        try:
            self._init_exchange(preferred_exchange)
            self.active_exchange = preferred_exchange
            logger.info(f"✅ Cliente inicializado con {preferred_exchange.upper()}")
        except Exception as e:
            logger.warning(f"⚠️ Error con {preferred_exchange}: {e}. Usando fallback...")
            # Fallback a otros exchanges
            for exchange in ['bitget', 'bybit', 'kucoin']:
                if exchange != preferred_exchange:
                    try:
                        self._init_exchange(exchange)
                        self.active_exchange = exchange
                        logger.info(f"✅ Fallback exitoso a {exchange.upper()}")
                        break
                    except Exception as e2:
                        logger.error(f"❌ Error con {exchange}: {e2}")
        
        if not self.spot:
            raise Exception("No se pudo conectar a ningún exchange")
    
    def _init_exchange(self, exchange_name: str):
        """Inicializa un exchange específico"""
        exchange_config = {
            'enableRateLimit': True,
        }
        
        if exchange_name == 'bitget':
            self.spot = ccxt.bitget({**exchange_config, 'options': {'defaultType': 'spot'}})
            self.futures = ccxt.bitget({**exchange_config, 'options': {'defaultType': 'swap'}})
        elif exchange_name == 'bybit':
            self.spot = ccxt.bybit({**exchange_config, 'options': {'defaultType': 'spot'}})
            self.futures = ccxt.bybit({**exchange_config, 'options': {'defaultType': 'linear'}})
        elif exchange_name == 'kucoin':
            self.spot = ccxt.kucoin({**exchange_config, 'options': {'defaultType': 'spot'}})
            self.futures = ccxt.kucoin({**exchange_config, 'options': {'defaultType': 'margin'}})
        else:
            raise ValueError(f"Exchange no soportado: {exchange_name}")
    
    def fetch_ohlcv(self, symbol: str, timeframe: str, limit: int = 100, market_type: str = 'spot'):
        try:
            exchange = self.futures if market_type == 'futures' else self.spot
            return exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        except Exception as e:
            logger.error(f"Error fetching OHLCV for {symbol}: {e}")
            return None
    
    def fetch_tickers(self):
        try:
            return self.spot.fetch_tickers()
        except Exception as e:
            logger.error(f"Error fetching tickers: {e}")
            return {}