"""
Test simple: Tous les signaux DIRECTS vs tous les signaux INVERSÉS
"""

import logging
from apollo_client import ApolloDegenClient
from strategies.inverse_strategy_v10 import InverseStrategyV10
from signals.short_term_signals import ShortTermSignalGenerator
import config

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

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

print("\n🧪 TEST SIMPLE: Signaux DIRECTS vs INVERSÉS")
print("="*80)

signal_gen = ShortTermSignalGenerator()
inverse_strategy = InverseStrategyV10()

total_direct_signals = 0
total_inverse_signals = 0

# Simuler tous les signaux
for i in range(100, len(df) - 100, 10):  # Check every 10 candles
    window_df = df.iloc[:i]

    # Signaux DIRECTS
    direct_signals = signal_gen.generate_signals(window_df, 'BTCUSDT')
    if direct_signals:
        best_direct = max(direct_signals, key=lambda x: x.score)
        total_direct_signals += 1

    # Signaux INVERSÉS
    inverse_signal = inverse_strategy.generate_inverse_signal(window_df, 'BTCUSDT')
    if inverse_signal:
        total_inverse_signals += 1

print(f"\n📊 COMPTAGE DES SIGNAUX:")
print(f"  Signaux DIRECTS générés:   {total_direct_signals}")
print(f"  Signaux INVERSÉS générés:  {total_inverse_signals}")

# Maintenant testons le PnL moyen par signal
print(f"\n📊 SIMULATION PnL:")

def simulate_signal_pnl(df, start_idx, signal):
    """Simule le PnL d'un signal"""
    entry_price = df.iloc[start_idx]['close']

    # SL/TP
    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:
        sl = entry_price * (1 + sl_pct)
        tp = entry_price * (1 - sl_pct * config.TAKE_PROFIT_RATIO)

    # Check les 50 prochaines bougies
    for j in range(start_idx + 1, min(start_idx + 50, len(df))):
        candle = df.iloc[j]

        if signal.side == 'LONG':
            if candle['low'] <= sl:
                return -sl_pct * 100  # SL hit
            elif candle['high'] >= tp:
                return sl_pct * config.TAKE_PROFIT_RATIO * 100  # TP hit
        else:  # SHORT
            if candle['high'] >= sl:
                return -sl_pct * 100  # SL hit
            elif candle['low'] <= tp:
                return sl_pct * config.TAKE_PROFIT_RATIO * 100  # TP hit

    return 0  # Pas de sortie

# Test sur 20 premiers signaux
direct_pnls = []
inverse_pnls = []

tested = 0
for i in range(100, len(df) - 100, 20):
    if tested >= 20:
        break

    window_df = df.iloc[:i]

    # Signal DIRECT
    direct_signals = signal_gen.generate_signals(window_df, 'BTCUSDT')
    if direct_signals:
        best_direct = max(direct_signals, key=lambda x: x.score)
        pnl = simulate_signal_pnl(df, i, best_direct)
        direct_pnls.append(pnl)

    # Signal INVERSÉ
    inverse_signal = inverse_strategy.generate_inverse_signal(window_df, 'BTCUSDT')
    if inverse_signal:
        pnl = simulate_signal_pnl(df, i, inverse_signal)
        inverse_pnls.append(pnl)

    tested += 1

# Stats
if direct_pnls:
    avg_direct = sum(direct_pnls) / len(direct_pnls)
    wins_direct = len([p for p in direct_pnls if p > 0])
    wr_direct = wins_direct / len(direct_pnls) * 100

    print(f"\n  SIGNAUX DIRECTS ({len(direct_pnls)} trades):")
    print(f"    PnL moyen:   {avg_direct:+.2f}%")
    print(f"    Win rate:    {wr_direct:.1f}%")
    print(f"    Wins/Losses: {wins_direct}/{len(direct_pnls)-wins_direct}")

if inverse_pnls:
    avg_inverse = sum(inverse_pnls) / len(inverse_pnls)
    wins_inverse = len([p for p in inverse_pnls if p > 0])
    wr_inverse = wins_inverse / len(inverse_pnls) * 100

    print(f"\n  SIGNAUX INVERSÉS ({len(inverse_pnls)} trades):")
    print(f"    PnL moyen:   {avg_inverse:+.2f}%")
    print(f"    Win rate:    {wr_inverse:.1f}%")
    print(f"    Wins/Losses: {wins_inverse}/{len(inverse_pnls)-wins_inverse}")

print("\n" + "="*80)
if direct_pnls and inverse_pnls:
    diff = avg_direct - avg_inverse
    if diff > 0:
        print(f"✅ SIGNAUX DIRECTS sont meilleurs de {diff:+.2f}%/trade")
        print(f"⚠️  L'INVERSION DÉGRADE les performances")
    else:
        print(f"✅ SIGNAUX INVERSÉS sont meilleurs de {-diff:+.2f}%/trade")
        print(f"✅ L'INVERSION AMÉLIORE les performances")

print("="*80)