"""
Test: Est-ce que le problème vient de l'inversion ?
Compare les résultats AVEC et SANS inversion
"""

import logging
from apollo_client import ApolloDegenClient
from strategies.inverse_strategy_v10 import InverseStrategyV10, InverseBacktesterV10
from signals.short_term_signals import ShortTermSignalGenerator
import config
import pandas as pd

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Désactiver logs verbeux
logging.getLogger('InverseStrategyV10').setLevel(logging.WARNING)
logging.getLogger('ShortTermSignalGenerator').setLevel(logging.WARNING)
logging.getLogger('ApolloDegenClient').setLevel(logging.WARNING)

# Récupérer données
client = ApolloDegenClient()
df = client.get_klines('BTCUSDT', '1m', limit=1500)

logger.info("🧪 TEST: Stratégie AVEC vs SANS inversion\n")
logger.info("="*80)

# Test 1: AVEC inversion (V10)
logger.info("\n📊 TEST 1: AVEC INVERSION (InverseStrategyV10)")
logger.info("-"*80)

backtester_inverse = InverseBacktesterV10(initial_capital=1000)
result_inverse = backtester_inverse.backtest(df, 'BTCUSDT')

if result_inverse:
    logger.info(f"Capital final:  ${result_inverse['final_capital']:.2f}")
    logger.info(f"Return:         {result_inverse['total_return']:+.2f}%")
    logger.info(f"Win rate:       {result_inverse['win_rate']*100:.1f}%")
    logger.info(f"Total trades:   {len(result_inverse['trades'])}")

# Test 2: SANS inversion (signaux directs)
logger.info("\n📊 TEST 2: SANS INVERSION (signaux directs)")
logger.info("-"*80)

signal_gen = ShortTermSignalGenerator()
capital = 1000
trades_direct = []

for i in range(len(df) - 100):
    window_df = df.iloc[:i+100]

    # Générer signaux directs (pas inversés)
    signals = signal_gen.generate_signals(window_df, 'BTCUSDT')
    signal = max(signals, key=lambda x: x.score) if signals else None

    # Permettre plusieurs trades (max 5 en parallèle)
    if signal and len([t for t in trades_direct if 'exit' not in t or t['exit'] is None]) < 5:
        # Entry
        entry_price = df.iloc[i+100]['close']
        entry_idx = i + 100

        # Calculer SL/TP selon le signal DIRECT
        leverage = config.LEVERAGE_AGGRESSIVE
        sl_pct = config.STOP_LOSS_PCT[250]

        if signal.side == 'LONG':
            sl = entry_price * (1 - sl_pct)
            tp = entry_price * (1 + sl_pct * config.TAKE_PROFIT_RATIO)
        else:  # SHORT
            sl = entry_price * (1 + sl_pct)
            tp = entry_price * (1 - sl_pct * config.TAKE_PROFIT_RATIO)

        # Simuler trade
        for j in range(entry_idx + 1, len(df)):
            candle = df.iloc[j]

            # Check exit
            exit_price = None
            exit_reason = None

            if signal.side == 'LONG':
                if candle['low'] <= sl:
                    exit_price = sl
                    exit_reason = 'SL'
                elif candle['high'] >= tp:
                    exit_price = tp
                    exit_reason = 'TP'
            else:  # SHORT
                if candle['high'] >= sl:
                    exit_price = sl
                    exit_reason = 'SL'
                elif candle['low'] <= tp:
                    exit_price = tp
                    exit_reason = 'TP'

            if exit_price:
                # Calculer PnL
                if signal.side == 'LONG':
                    pnl_pct = (exit_price - entry_price) / entry_price
                else:  # SHORT
                    pnl_pct = (entry_price - exit_price) / entry_price

                pnl_usd = capital * 0.1 * leverage * pnl_pct  # 10% du capital par trade
                capital += pnl_usd

                trades_direct.append({
                    'side': signal.side,
                    'entry': entry_price,
                    'exit': exit_price,
                    'pnl_pct': pnl_pct * 100,
                    'pnl_usd': pnl_usd,
                    'reason': exit_reason
                })
                break

final_capital_direct = capital
return_direct = ((final_capital_direct - 1000) / 1000) * 100
wins_direct = [t for t in trades_direct if t['pnl_usd'] > 0]
wr_direct = len(wins_direct) / len(trades_direct) * 100 if trades_direct else 0

logger.info(f"Capital final:  ${final_capital_direct:.2f}")
logger.info(f"Return:         {return_direct:+.2f}%")
logger.info(f"Win rate:       {wr_direct:.1f}%")
logger.info(f"Total trades:   {len(trades_direct)}")

# Comparaison
logger.info("\n" + "="*80)
logger.info("📊 COMPARAISON")
logger.info("="*80)
logger.info(f"{'Strategy':<25} | {'Return':<10} | {'WR':<10} | {'Trades':<10}")
logger.info("-"*80)

if result_inverse:
    logger.info(f"{'AVEC inversion (V10)':<25} | {result_inverse['total_return']:>9.2f}% | {result_inverse['win_rate']*100:>9.1f}% | {len(result_inverse['trades']):>10}")

logger.info(f"{'SANS inversion (direct)':<25} | {return_direct:>9.2f}% | {wr_direct:>9.1f}% | {len(trades_direct):>10}")

logger.info("\n" + "="*80)
if result_inverse:
    diff = return_direct - result_inverse['total_return']
    if diff > 0:
        logger.info(f"✅ Les signaux DIRECTS sont meilleurs de {diff:+.2f}%")
        logger.info(f"⚠️  L'INVERSION des signaux DÉGRADE les performances !")
    else:
        logger.info(f"✅ L'INVERSION améliore les performances de {-diff:+.2f}%")