"""
Analyse de la fréquence de trading de la stratégie V10
"""

import logging
from apollo_client import ApolloDegenClient
from strategies.inverse_strategy_v10 import InverseBacktesterV10
import pandas as pd
from datetime import datetime, timedelta

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

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

print("="*80)
print("📊 ANALYSE FRÉQUENCE DE TRADING - STRATÉGIE V10")
print("="*80)
print()

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

print(f"Données: {len(df)} chandeliers (1 minute)")

# Calculer période couverte
first_time = pd.to_datetime(df.iloc[0]['timestamp'], unit='ms')
last_time = pd.to_datetime(df.iloc[-1]['timestamp'], unit='ms')
period_hours = (last_time - first_time).total_seconds() / 3600

print(f"Période: {first_time.strftime('%Y-%m-%d %H:%M')} → {last_time.strftime('%Y-%m-%d %H:%M')}")
print(f"Durée: {period_hours:.1f} heures (~{period_hours/24:.1f} jours)")
print()

# Run backtest
backtester = InverseBacktesterV10(initial_capital=1000)
result = backtester.backtest(df, 'BTCUSDT')

if result:
    trades = result['trades']
    num_trades = len(trades)

    print("="*80)
    print("📈 STATISTIQUES DE TRADING")
    print("="*80)
    print()

    # Fréquence globale
    trades_per_hour = num_trades / period_hours
    trades_per_day = trades_per_hour * 24

    print(f"Total trades:       {num_trades}")
    print(f"Trades/heure:       {trades_per_hour:.2f}")
    print(f"Trades/jour:        {trades_per_day:.1f}")
    print()

    # Analyse temporelle
    if num_trades > 1:
        # Convertir timestamps
        entry_times = [pd.to_datetime(t['entry_time'], unit='ms') for t in trades]
        exit_times = [pd.to_datetime(t['exit_time'], unit='ms') for t in trades]

        # Durée moyenne des trades
        durations = [(exit_times[i] - entry_times[i]).total_seconds() / 60 for i in range(len(trades))]
        avg_duration = sum(durations) / len(durations)
        min_duration = min(durations)
        max_duration = max(durations)

        print(f"Durée moyenne trade: {avg_duration:.0f} minutes ({avg_duration/60:.1f}h)")
        print(f"Durée min:           {min_duration:.0f} minutes")
        print(f"Durée max:           {max_duration:.0f} minutes")
        print()

        # Temps entre trades
        intervals = [(entry_times[i] - exit_times[i-1]).total_seconds() / 60 for i in range(1, len(trades))]
        avg_interval = sum(intervals) / len(intervals) if intervals else 0

        print(f"Temps moyen entre trades: {avg_interval:.0f} minutes ({avg_interval/60:.1f}h)")
        print()

    # Analyse par stratégie
    print("="*80)
    print("📊 DISTRIBUTION PAR STRATÉGIE")
    print("="*80)
    print()

    strategy_counts = {}
    for trade in trades:
        strategy = trade['strategy'].replace('INVERSE_V10_', '')
        strategy_counts[strategy] = strategy_counts.get(strategy, 0) + 1

    for strategy, count in sorted(strategy_counts.items(), key=lambda x: x[1], reverse=True):
        pct = (count / num_trades) * 100
        print(f"  {strategy:25} {count:3} trades ({pct:5.1f}%)")

    print()

    # Pyramiding stats
    pyramid_trades = [t for t in trades if t['pyramids'] > 0]
    print("="*80)
    print("📈 PYRAMIDING")
    print("="*80)
    print()
    print(f"Trades avec pyramiding: {len(pyramid_trades)}/{num_trades} ({len(pyramid_trades)/num_trades*100:.1f}%)")
    if pyramid_trades:
        avg_pyramids = sum(t['pyramids'] for t in pyramid_trades) / len(pyramid_trades)
        print(f"Avg pyramids/trade:     {avg_pyramids:.2f}")
    print()

    # Leverage stats
    print("="*80)
    print("⚡ LEVERAGE")
    print("="*80)
    print()
    leverage_250 = sum(1 for t in trades if t['leverage'] == 250)
    leverage_225 = sum(1 for t in trades if t['leverage'] == 225)
    leverage_200 = sum(1 for t in trades if t['leverage'] == 200)

    print(f"Trades 250x: {leverage_250} ({leverage_250/num_trades*100:.1f}%)")
    print(f"Trades 225x: {leverage_225} ({leverage_225/num_trades*100:.1f}%)")
    print(f"Trades 200x: {leverage_200} ({leverage_200/num_trades*100:.1f}%)")
    print()

    avg_leverage = sum(t['leverage'] for t in trades) / num_trades
    print(f"Leverage moyen: {avg_leverage:.0f}x")
    print()

    # Projections
    print("="*80)
    print("🔮 PROJECTIONS")
    print("="*80)
    print()

    print(f"📅 Sur 1 jour (24h):")
    print(f"   Trades attendus:    ~{trades_per_day:.0f} trades")
    print(f"   Return attendu:     ~{result['total_return'] * (24/period_hours):.1f}%")
    print()

    print(f"📅 Sur 1 semaine (7 jours):")
    print(f"   Trades attendus:    ~{trades_per_day * 7:.0f} trades")
    print(f"   Return attendu:     ~{result['total_return'] * (24*7/period_hours):.1f}%")
    print()

    print(f"📅 Sur 1 mois (30 jours):")
    print(f"   Trades attendus:    ~{trades_per_day * 30:.0f} trades")
    print(f"   Return attendu:     ~{result['total_return'] * (24*30/period_hours):.1f}%")
    print()

    print("⚠️  NOTE: Ces projections supposent:")
    print("   - Marché reste en RANGE")
    print("   - Performance constante")
    print("   - Pas de changement de volatilité")
    print()

    # Timeline d'un trade type
    print("="*80)
    print("⏱️  TIMELINE TRADE TYPIQUE")
    print("="*80)
    print()
    print(f"1. Signal détecté (score ~0.90-1.0)")
    print(f"2. Entry @ prix du marché")
    print(f"3. Position tenue {avg_duration:.0f} min en moyenne")
    print(f"4. Si +0.5%: Pyramiding +50%")
    print(f"5. Si +1.0%: Pyramiding +25%")
    print(f"6. Exit TP @ +1.75% (ou SL @ -0.5%)")
    print(f"7. Attente ~{avg_interval:.0f} min avant prochain signal")
    print()

else:
    print("❌ Aucun résultat de backtest")

print("="*80)