#!/usr/bin/env python3
"""
Comparaison directe V10 vs V11 avec le meilleur setup Dynamic
"""
import pandas as pd
from v10_range_strategy import V10RangeStrategy
from v11_filtered_strategy import V11FilteredStrategy
from backtest_adaptive import AdaptiveBacktest
from backtest_v10_range import Signal


def run_comparison():
    """Compare V10 vs V11 avec meilleur setup"""

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

    print("="*80)
    print("⚔️  V10 DYNAMIC vs V11 FILTERED")
    print("="*80)
    print(f"Données: {len(df)} candles 1m")
    print(f"Période: {df['timestamp'].iloc[0]} → {df['timestamp'].iloc[-1]}")

    # Meilleur setup Dynamic trouvé
    best_params = {
        'rsi_oversold': 30,
        'rsi_overbought': 70,
        'range_atr_threshold': 0.30,
        'min_confidence': 70,
        'sl_atr_mult': 1.0,
        'trailing_pct': 0.05,  # 5% - meilleur trouvé
        'leverage': 250,       # 250x - meilleur trouvé
    }

    print(f"\n📊 Configuration testée:")
    print(f"   Trailing: {int(best_params['trailing_pct']*100)}%")
    print(f"   Leverage: {best_params['leverage']}x")
    print(f"   RSI: {best_params['rsi_oversold']}/{best_params['rsi_overbought']}")

    # Adapter pour backtest
    class CustomAdapter:
        def __init__(self, strat):
            self.strategy = strat
            self.leverage = strat.leverage
            self.params = {
                'ranging': {
                    'sl_atr_multiplier': strat.params['sl_atr_multiplier'],
                    'tp_atr_multiplier': 3.0,
                    'min_confidence': strat.params['min_confidence'],
                }
            }

        def analyze(self, symbol, df):
            signal_dict = self.strategy.analyze(symbol, df)
            if not signal_dict:
                return None
            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'],
                leverage=signal_dict['leverage'],
                risk_pct=signal_dict['risk_pct'],
                score=signal_dict['confidence'],
                confluences=signal_dict['confluences'],
                strategy_used='v10_range_reversal',
                confidence=signal_dict['confidence']
            )

    # TEST 1: V10 avec adaptation dynamique
    print("\n" + "="*80)
    print("TEST 1: V10 DYNAMIC (ATR adaptation)")
    print("="*80)

    v10 = V10RangeStrategy(leverage=best_params['leverage'])
    v10.params['rsi_oversold'] = best_params['rsi_oversold']
    v10.params['rsi_overbought'] = best_params['rsi_overbought']
    v10.params['range_atr_threshold'] = best_params['range_atr_threshold']
    v10.params['min_confidence'] = best_params['min_confidence']
    v10.params['sl_atr_multiplier'] = best_params['sl_atr_mult']

    adapter_v10 = CustomAdapter(v10)

    backtest_v10 = AdaptiveBacktest(
        adapter_v10,
        initial_capital=500.0,
        use_trailing_stop=True,
        trailing_pct=best_params['trailing_pct'],
        early_stop_on_losses=False,  # Backtest complet
        min_capital_pct=0.50,
        use_dynamic_adaptation=True  # ATR adaptation
    )

    results_v10 = backtest_v10.run(df, 'BTCUSDT')

    if results_v10:
        print(f"\n📊 RÉSULTATS V10:")
        print(f"   Trades: {results_v10['total_trades']}")
        print(f"   Win Rate: {results_v10['win_rate']:.1f}%")
        print(f"   PnL: {results_v10['total_pnl_pct']:+.2f}%")
        print(f"   Profit Factor: {results_v10['profit_factor']:.2f}")
        print(f"   Capital final: ${results_v10['final_capital']:.2f}")
        print(f"   Avg Win: {results_v10['avg_win']:.2f}%")
        print(f"   Avg Loss: {results_v10['avg_loss']:.2f}%")

    # TEST 2: V11 avec filtres additionnels
    print("\n" + "="*80)
    print("TEST 2: V11 FILTERED (ATR + Time + Trend)")
    print("="*80)

    v11 = V11FilteredStrategy(leverage=best_params['leverage'])
    v11.params['rsi_oversold'] = best_params['rsi_oversold']
    v11.params['rsi_overbought'] = best_params['rsi_overbought']
    v11.params['range_atr_threshold'] = best_params['range_atr_threshold']
    v11.params['min_confidence'] = best_params['min_confidence']
    v11.params['sl_atr_multiplier'] = best_params['sl_atr_mult']

    adapter_v11 = CustomAdapter(v11)

    backtest_v11 = AdaptiveBacktest(
        adapter_v11,
        initial_capital=500.0,
        use_trailing_stop=True,
        trailing_pct=best_params['trailing_pct'],
        early_stop_on_losses=False,
        min_capital_pct=0.50,
        use_dynamic_adaptation=True  # ATR adaptation
    )

    results_v11 = backtest_v11.run(df, 'BTCUSDT')

    if results_v11:
        print(f"\n📊 RÉSULTATS V11:")
        print(f"   Trades: {results_v11['total_trades']}")
        print(f"   Win Rate: {results_v11['win_rate']:.1f}%")
        print(f"   PnL: {results_v11['total_pnl_pct']:+.2f}%")
        print(f"   Profit Factor: {results_v11['profit_factor']:.2f}")
        print(f"   Capital final: ${results_v11['final_capital']:.2f}")
        print(f"   Avg Win: {results_v11['avg_win']:.2f}%")
        print(f"   Avg Loss: {results_v11['avg_loss']:.2f}%")

    # COMPARAISON
    if results_v10 and results_v11:
        print("\n" + "="*80)
        print("⚔️  COMPARAISON")
        print("="*80)

        print(f"\n📊 Nombre de trades:")
        print(f"   V10: {results_v10['total_trades']}")
        print(f"   V11: {results_v11['total_trades']}")
        diff = results_v11['total_trades'] - results_v10['total_trades']
        print(f"   → {diff:+d} trades ({diff/results_v10['total_trades']*100:+.1f}%)")

        print(f"\n💎 Win Rate:")
        print(f"   V10: {results_v10['win_rate']:.1f}%")
        print(f"   V11: {results_v11['win_rate']:.1f}%")
        diff = results_v11['win_rate'] - results_v10['win_rate']
        print(f"   → {diff:+.1f}% {'✅' if diff > 0 else '❌'}")

        print(f"\n💰 PnL:")
        print(f"   V10: {results_v10['total_pnl_pct']:+.2f}%")
        print(f"   V11: {results_v11['total_pnl_pct']:+.2f}%")
        diff = results_v11['total_pnl_pct'] - results_v10['total_pnl_pct']
        print(f"   → {diff:+.2f}% {'✅' if diff > 0 else '❌'}")

        print(f"\n💪 Profit Factor:")
        print(f"   V10: {results_v10['profit_factor']:.2f}")
        print(f"   V11: {results_v11['profit_factor']:.2f}")
        diff = results_v11['profit_factor'] - results_v10['profit_factor']
        print(f"   → {diff:+.2f} {'✅' if diff > 0 else '❌'}")

        print(f"\n🎯 Efficacité (PnL par trade):")
        pnl_per_trade_v10 = results_v10['total_pnl_pct'] / results_v10['total_trades']
        pnl_per_trade_v11 = results_v11['total_pnl_pct'] / results_v11['total_trades']
        print(f"   V10: {pnl_per_trade_v10:.3f}% par trade")
        print(f"   V11: {pnl_per_trade_v11:.3f}% par trade")
        diff = pnl_per_trade_v11 - pnl_per_trade_v10
        print(f"   → {diff:+.3f}% {'✅' if diff > 0 else '❌'}")

        # Verdict
        print("\n" + "="*80)
        print("🏆 VERDICT")
        print("="*80)

        v11_wins = 0
        if results_v11['win_rate'] > results_v10['win_rate']:
            v11_wins += 1
        if results_v11['total_pnl_pct'] > results_v10['total_pnl_pct']:
            v11_wins += 1
        if results_v11['profit_factor'] > results_v10['profit_factor']:
            v11_wins += 1
        if pnl_per_trade_v11 > pnl_per_trade_v10:
            v11_wins += 1

        if v11_wins >= 3:
            print("✅ V11 FILTERED GAGNE - Les filtres améliorent les performances")
            print("   → Recommandation: Utiliser V11 en production")
        elif v11_wins == 2:
            print("🤔 ÉGALITÉ - Les filtres apportent des améliorations mineures")
            print("   → Recommandation: A/B test en production")
        else:
            print("❌ V10 DYNAMIC GAGNE - Les filtres réduisent trop les opportunités")
            print("   → Recommandation: Rester sur V10")

        print("="*80)


if __name__ == '__main__':
    run_comparison()