#!/usr/bin/env python3
"""
Backtest de la stratégie V10 RANGE
Utilise le moteur backtest_adaptive
"""

import pandas as pd
import logging
from v10_range_strategy import V10RangeStrategy
from backtest_adaptive import AdaptiveBacktest

# Mock Signal class compatible avec backtest_adaptive
class Signal:
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)


class V10StrategyAdapter:
    """Adapteur pour utiliser V10RangeStrategy avec AdaptiveBacktest"""

    def __init__(self, leverage: int = 100):
        self.strategy = V10RangeStrategy(leverage=leverage)
        self.leverage = leverage
        # Copier les params de la stratégie
        self.params = {
            'ranging': {
                'sl_atr_multiplier': self.strategy.params['sl_atr_multiplier'],
                'tp_atr_multiplier': self.strategy.params['tp_atr_multiplier'],
                'min_confidence': self.strategy.params['min_confidence'],
            }
        }

    def analyze(self, symbol: str, df: pd.DataFrame) -> Signal:
        """Analyse compatible avec AdaptiveBacktest"""
        signal_dict = self.strategy.analyze(symbol, df)

        if not signal_dict:
            return None

        # Convertir en Signal object
        return Signal(
            symbol=signal_dict['symbol'],
            side=signal_dict['side'],
            entry_price=signal_dict['entry_price'],
            stop_loss=signal_dict['stop_loss'],
            take_profit=signal_dict['take_profit'],
            confidence=signal_dict['confidence'],
            strategy_used=signal_dict['strategy_used'],
            confluences=signal_dict['confluences'],
            leverage=self.leverage,  # Ajout leverage manquant
            timeframe='5m',
            timestamp=pd.Timestamp.now()
        )


if __name__ == '__main__':
    logging.basicConfig(level=logging.WARNING)
    logger = logging.getLogger(__name__)

    logger.warning("\n" + "="*80)
    logger.warning("🧪 BACKTEST STRATÉGIE V10 RANGE")
    logger.warning("="*80 + "\n")

    # Charger données
    df = pd.read_csv('historical_data/BTCUSDT_5m_2000candles.csv')
    df['timestamp'] = pd.to_datetime(df['timestamp'])

    logger.warning(f"📊 Données: {len(df)} bougies BTC 5m")
    logger.warning(f"   Période: {df['timestamp'].iloc[0]} → {df['timestamp'].iloc[-1]}\n")

    # Tester plusieurs leverages
    leverages = [100, 125, 150]

    results_summary = []

    for lev in leverages:
        logger.warning(f"\n{'='*80}")
        logger.warning(f"⚡ TEST LEVERAGE {lev}x")
        logger.warning(f"{'='*80}\n")

        # Créer stratégie adaptée
        strategy = V10StrategyAdapter(leverage=lev)

        # Backtest avec capital $500
        backtest = AdaptiveBacktest(strategy, initial_capital=500.0)
        results = backtest.run(df, "BTCUSD_DEGEN")

        if results and results['total_trades'] > 0:
            results_summary.append({
                'leverage': lev,
                'pnl_pct': results['total_pnl_pct'],
                'profit_factor': results['profit_factor'],
                'win_rate': results['win_rate'],
                'trades': results['total_trades'],
                'final_capital': results['final_capital']
            })

            logger.warning(f"\n✅ RÉSULTATS {lev}x:")
            logger.warning(f"   PnL: {results['total_pnl_pct']:+.2f}%")
            logger.warning(f"   Capital final: ${results['final_capital']:.2f}")
            logger.warning(f"   Profit Factor: {results['profit_factor']:.3f}")
            logger.warning(f"   Win Rate: {results['win_rate']:.1f}%")
            logger.warning(f"   Trades: {results['total_trades']}")
        else:
            logger.warning(f"\n❌ Aucun trade avec leverage {lev}x")

    # Résumé final
    if results_summary:
        logger.warning(f"\n\n{'='*80}")
        logger.warning(f"📊 RÉSUMÉ COMPARATIF V10 RANGE")
        logger.warning(f"{'='*80}\n")

        # Trier par PnL
        results_summary.sort(key=lambda x: x['pnl_pct'], reverse=True)

        logger.warning(f"{'Leverage':<12} {'PnL':<12} {'PF':<8} {'WR':<10} {'Trades':<10} {'Final $'}")
        logger.warning("-" * 80)

        for r in results_summary:
            logger.warning(
                f"{r['leverage']:>7}x    "
                f"{r['pnl_pct']:>+8.2f}%    "
                f"{r['profit_factor']:>5.2f}   "
                f"{r['win_rate']:>6.1f}%    "
                f"{r['trades']:>6}      "
                f"${r['final_capital']:>8.2f}"
            )

        logger.warning("\n" + "="*80)

        # Meilleur résultat
        best = results_summary[0]
        if best['pnl_pct'] > 0:
            logger.warning(f"\n🏆 MEILLEURE CONFIG:")
            logger.warning(f"   Leverage: {best['leverage']}x")
            logger.warning(f"   PnL: {best['pnl_pct']:+.2f}% (${best['final_capital'] - 500:+.2f})")
            logger.warning(f"   Profit Factor: {best['profit_factor']:.3f}")
            logger.warning(f"   Win Rate: {best['win_rate']:.1f}%")
        else:
            logger.warning(f"\n⚠️  Aucune config profitable trouvée")
    else:
        logger.warning(f"\n❌ Aucun résultat à afficher")

    logger.warning("\n" + "="*80 + "\n")