#!/usr/bin/env python3
"""
Optimisation Massive Stratégie Hybride
Teste 100+ configurations pour trouver les meilleurs paramètres
"""

import pandas as pd
import numpy as np
import json
import random
import time
from datetime import datetime
from pathlib import Path

from hybrid_strategy import HybridStrategy
from backtest_hybrid import HybridBacktest, get_btc_historical_data

print("=" * 80)
print("🚀 OPTIMISATION MASSIVE HYBRID STRATEGY")
print("=" * 80)
print(f"Démarrage: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print()

# Charger données (1 jour = ~1440 bougies)
print("📊 Chargement données...")
df = get_btc_historical_data(days=1, interval='1m')
print(f"✅ {len(df)} bougies chargées")
print()

results = []
TOTAL_TESTS = 100

output_file = 'hybrid_optimization_results.json'

print(f"🔄 Lancement de {TOTAL_TESTS} tests...")
print(f"💾 Sauvegarde progressive dans {output_file}")
print()

for i in range(TOTAL_TESTS):
    start_time = time.time()
    
    # Générer config aléatoire
    config = {
        # Bull params
        'bull.min_trend_strength': random.randint(50, 80),
        'bull.rsi_pullback_max': random.randint(35, 50),
        'bull.rsi_breakout_min': random.randint(50, 65),
        'bull.sl_atr_multiplier': round(random.uniform(1.0, 2.5), 2),
        'bull.tp_atr_multiplier': round(random.uniform(2.0, 5.0), 2),
        'bull.leverage': random.choice([50, 75, 100, 125, 150, 200]),
        
        # Bear params
        'bear.min_trend_strength': random.randint(50, 80),
        'bear.rsi_rally_min': random.randint(50, 65),
        'bear.rsi_overbought': random.randint(65, 80),
        'bear.sl_atr_multiplier': round(random.uniform(1.0, 2.5), 2),
        'bear.tp_atr_multiplier': round(random.uniform(2.0, 5.0), 2),
        'bear.leverage': random.choice([50, 75, 100, 125, 150, 200]),
        
        # Range params (V10)
        'range.rsi_oversold': random.randint(25, 40),
        'range.rsi_overbought': random.randint(60, 80),
        'range.range_atr_threshold': round(random.uniform(0.20, 0.45), 2),
        'range.sl_atr_multiplier': round(random.uniform(1.0, 2.5), 2),
        'range.trailing_pct': round(random.uniform(0.03, 0.15), 2),
        'range.leverage': random.choice([100, 150, 200, 250]),
    }
    
    # Créer stratégie avec ces params
    strategy = HybridStrategy(leverage=100)
    
    # Appliquer params bull
    strategy.bull_strategy.params['min_trend_strength'] = config['bull.min_trend_strength']
    strategy.bull_strategy.params['rsi_pullback_max'] = config['bull.rsi_pullback_max']
    strategy.bull_strategy.params['rsi_breakout_min'] = config['bull.rsi_breakout_min']
    strategy.bull_strategy.params['sl_atr_multiplier'] = config['bull.sl_atr_multiplier']
    strategy.bull_strategy.params['tp_atr_multiplier'] = config['bull.tp_atr_multiplier']
    strategy.bull_strategy.leverage = config['bull.leverage']
    
    # Appliquer params bear
    strategy.bear_strategy.params['min_trend_strength'] = config['bear.min_trend_strength']
    strategy.bear_strategy.params['rsi_rally_min'] = config['bear.rsi_rally_min']
    strategy.bear_strategy.params['rsi_overbought'] = config['bear.rsi_overbought']
    strategy.bear_strategy.params['sl_atr_multiplier'] = config['bear.sl_atr_multiplier']
    strategy.bear_strategy.params['tp_atr_multiplier'] = config['bear.tp_atr_multiplier']
    strategy.bear_strategy.leverage = config['bear.leverage']
    
    # Appliquer params range
    strategy.range_strategy.params['rsi_oversold'] = config['range.rsi_oversold']
    strategy.range_strategy.params['rsi_overbought'] = config['range.rsi_overbought']
    strategy.range_strategy.params['range_atr_threshold'] = config['range.range_atr_threshold']
    strategy.range_strategy.params['sl_atr_multiplier'] = config['range.sl_atr_multiplier']
    strategy.range_strategy.params['trailing_pct'] = config['range.trailing_pct']
    strategy.range_strategy.leverage = config['range.leverage']
    
    # Backtest
    try:
        backtest = HybridBacktest(df, initial_capital=500.0)
        result = backtest.run("Hybrid", strategy)
        
        elapsed = time.time() - start_time
        
        if result['total_trades'] > 0:
            results.append({
                'config': config,
                'pnl_pct': result['total_pnl_pct'],
                'trades': result['total_trades'],
                'win_rate': result['win_rate'],
                'profit_factor': result['profit_factor'],
                'max_dd': result['max_drawdown'],
                'trades_by_strategy': result['trades_by_strategy'],
                'timestamp': datetime.now().isoformat()
            })
            
            print(f"[{i+1}/{TOTAL_TESTS}] PnL {result['total_pnl_pct']:+.1f}% | Trades {result['total_trades']} | WR {result['win_rate']:.0f}% | PF {result['profit_factor']:.2f} | {elapsed:.1f}s")
            
            # Sauvegarder tous les 5 tests
            if (i + 1) % 5 == 0:
                with open(output_file, 'w') as f:
                    json.dump(results, f, indent=2)
                print(f"  💾 Sauvegarde intermédiaire ({len(results)} résultats)")
        else:
            print(f"[{i+1}/{TOTAL_TESTS}] Aucun trade | {elapsed:.1f}s")
            
    except Exception as e:
        print(f"[{i+1}/{TOTAL_TESTS}] ERREUR: {e}")

# Sauvegarde finale
with open(output_file, 'w') as f:
    json.dump(results, f, indent=2)

print()
print("=" * 80)
print("📊 RÉSULTATS FINAUX")
print("=" * 80)
print(f"Terminé: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print()

if results:
    # Statistiques globales
    profitable = [r for r in results if r['pnl_pct'] > 0 and r['profit_factor'] > 1.0]
    print(f"Tests effectués: {len(results)}/{TOTAL_TESTS}")
    print(f"Configs profitables: {len(profitable)} ({len(profitable)/len(results)*100:.0f}%)")
    
    if profitable:
        profitable.sort(key=lambda x: x['pnl_pct'], reverse=True)
        
        print()
        print("🏆 TOP 5 PAR PnL:")
        for i, r in enumerate(profitable[:5], 1):
            print(f"\n{i}. PnL: {r['pnl_pct']:+.1f}% | PF: {r['profit_factor']:.2f} | WR: {r['win_rate']:.0f}% | Trades: {r['trades']}")
            print(f"   Max DD: {r['max_dd']:.1f}%")
            print(f"   Répartition: {r['trades_by_strategy']}")
        
        print()
        print("🏆 TOP 5 PAR PROFIT FACTOR:")
        profitable.sort(key=lambda x: x['profit_factor'], reverse=True)
        for i, r in enumerate(profitable[:5], 1):
            print(f"\n{i}. PF: {r['profit_factor']:.2f} | PnL: {r['pnl_pct']:+.1f}% | WR: {r['win_rate']:.0f}% | Trades: {r['trades']}")
            print(f"   Max DD: {r['max_dd']:.1f}%")
            print(f"   Répartition: {r['trades_by_strategy']}")
    else:
        print("\n❌ Aucune config profitable trouvée")
else:
    print("\n❌ Aucun résultat")

print()
print(f"💾 Résultats sauvegardés: {output_file}")
print("=" * 80)
