#!/usr/bin/env python3
"""
WALK-FORWARD VALIDATION - Système Hybride

Test sur différentes périodes pour vérifier:
1. Pas d'overfitting
2. Robustesse temporelle
3. Performance cohérente
"""

import pandas as pd
import numpy as np
from hybrid_system import HybridSystem
from martingale_backtester import MartingaleBacktester
import json

print("=" * 80)
print("🔬 WALK-FORWARD VALIDATION - Système Hybride")
print("=" * 80)

backtester = MartingaleBacktester(
    initial_capital=1000.0,
    trading_fee_pct=0.0005,
    timeout_minutes=60
)

# Test sur BTC (meilleur performer) avec 1000 bougies
print("\n📥 Téléchargement BTC 4h (1000 bougies)...")
df_full = backtester.fetch_binance_data('BTCUSDT', '4h', 1000)

if df_full is None:
    print("❌ Erreur téléchargement")
    exit(1)

print(f"✅ {len(df_full)} bougies\n")

# Split en 3 périodes
n = len(df_full)
period1 = df_full.iloc[:n//3]
period2 = df_full.iloc[n//3:2*n//3]
period3 = df_full.iloc[2*n//3:]

results = []

print("📊 Test Walk-Forward (3 périodes):\n")

for idx, period_df in enumerate([period1, period2, period3], 1):
    start_date = period_df.iloc[0]['timestamp'] if 'timestamp' in period_df.columns else 'N/A'
    end_date = period_df.iloc[-1]['timestamp'] if 'timestamp' in period_df.columns else 'N/A'

    print(f"🧪 Période {idx} ({len(period_df)} bougies)...")
    print(f"   {start_date} → {end_date}")

    system = HybridSystem(initial_capital=1000)
    result = system.backtest(period_df)

    if result:
        result['period'] = idx
        result['period_size'] = len(period_df)
        results.append(result)
        status = "✅" if result['roi'] > 10 else "⚠️" if result['roi'] > 0 else "❌"
        print(f"   {status} ROI: {result['roi']:+.2f}% | WR: {result['win_rate']*100:.1f}% | Trades: {result['trades']}\n")
    else:
        print(f"   ⚠️  Aucun trade\n")

# ============ MULTI-SYMBOL WALK-FORWARD ============

print("\n" + "=" * 80)
print("📊 MULTI-SYMBOL WALK-FORWARD")
print("=" * 80)

symbols = ['ETHUSDT', 'SOLUSDT', 'BNBUSDT']

for symbol in symbols:
    print(f"\n🔬 {symbol}:")

    df_sym = backtester.fetch_binance_data(symbol, '4h', 1000)

    if df_sym is None:
        print("   ❌ Erreur")
        continue

    # Split en 3
    n = len(df_sym)
    p1 = df_sym.iloc[:n//3]
    p2 = df_sym.iloc[n//3:2*n//3]
    p3 = df_sym.iloc[2*n//3:]

    for idx, p_df in enumerate([p1, p2, p3], 1):
        system = HybridSystem(initial_capital=1000)
        res = system.backtest(p_df)

        if res:
            res['period'] = idx
            res['symbol'] = symbol
            results.append(res)
            status = "✅" if res['roi'] > 5 else "⚠️" if res['roi'] > 0 else "❌"
            print(f"   P{idx}: {status} {res['roi']:+.2f}% | WR: {res['win_rate']*100:.1f}% | {res['trades']} trades")

# ============ RÉSULTATS ============

print("\n\n" + "=" * 80)
print("🏆 RÉSULTATS WALK-FORWARD VALIDATION")
print("=" * 80)

if not results:
    print("\n❌ Aucun résultat")
    exit(1)

results.sort(key=lambda x: x['roi'], reverse=True)

print(f"\n{'Symbol':<10} {'P':>2} {'ROI%':>8} {'WR%':>6} {'PF':>6} {'Trades':>7} {'DD%':>7} {'Status'}")
print("-" * 70)

for res in results:
    status = "✅" if res['roi'] > 10 else "⚠️" if res['roi'] > 0 else "❌"
    symbol = res.get('symbol', 'BTCUSDT')
    period = res.get('period', 0)

    print(f"{symbol:<10} {period:>2} {res['roi']:>7.2f}% {res['win_rate']*100:>5.1f}% "
          f"{res['profit_factor']:>6.2f} {res['trades']:>7} {res['max_dd']:>6.2f}% {status}")

# Stats globales
profitable = [r for r in results if r['roi'] > 0]
avg_roi = np.mean([r['roi'] for r in results])
median_roi = np.median([r['roi'] for r in results])
std_roi = np.std([r['roi'] for r in results])

print(f"\n📈 STATISTIQUES GLOBALES:")
print(f"   Tests:               {len(results)}")
print(f"   Profitables:         {len(profitable)} ({len(profitable)/len(results)*100:.1f}%)")
print(f"   ROI moyen:           {avg_roi:+.2f}%")
print(f"   ROI médian:          {median_roi:+.2f}%")
print(f"   Écart-type:          {std_roi:.2f}%")

if profitable:
    avg_profit = np.mean([r['roi'] for r in profitable])
    print(f"   ROI moyen (profit):  +{avg_profit:.2f}%")

# Cohérence par symbole
print(f"\n📊 COHÉRENCE PAR SYMBOLE:")
for symbol in ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT']:
    sym_results = [r for r in results if r.get('symbol', 'BTCUSDT') == symbol]
    if sym_results:
        avg = np.mean([r['roi'] for r in sym_results])
        std = np.std([r['roi'] for r in sym_results])
        prof = len([r for r in sym_results if r['roi'] > 0])
        status = "✅" if prof/len(sym_results) > 0.6 else "⚠️" if prof/len(sym_results) > 0.4 else "❌"
        print(f"   {symbol:<10} {status} ROI: {avg:+.2f}% ± {std:.2f}% | {prof}/{len(sym_results)} profitable")

# VERDICT
print(f"\n🎯 VALIDATION:")

# Critères de robustesse
consistent = std_roi < 20
profitable_rate = len(profitable) / len(results)
positive_avg = avg_roi > 5

print(f"   Variance: {'✅ Faible' if std_roi < 15 else '⚠️ Modérée' if std_roi < 25 else '❌ Élevée'} ({std_roi:.2f}%)")
print(f"   Profitabilité: {'✅ Élevée' if profitable_rate > 0.7 else '⚠️ Modérée' if profitable_rate > 0.5 else '❌ Faible'} ({profitable_rate*100:.0f}%)")
print(f"   ROI moyen: {'✅ Positif' if positive_avg else '❌ Négatif'} ({avg_roi:+.2f}%)")

print(f"\n{'=' * 80}")
if consistent and profitable_rate > 0.7 and positive_avg:
    print("🎉 SYSTÈME VALIDÉ - ROBUSTE ET NON-OVERFITTÉ!")
    print("   ✅ Cohérent dans le temps")
    print("   ✅ Espérance mathématique positive")
    print("   ✅ Prêt pour le trading live")
elif profitable_rate > 0.6 and positive_avg:
    print("✅ SYSTÈME VALIDÉ - Espérance positive confirmée")
    print(f"   ROI moyen: {avg_roi:+.2f}%")
    print(f"   Taux réussite: {profitable_rate*100:.0f}%")
elif avg_roi > 0:
    print("⚠️  Système légèrement profitable - À améliorer")
else:
    print("❌ Système non validé")
print(f"{'=' * 80}")

# Sauvegarder
with open('hybrid_walkforward_results.json', 'w') as f:
    json.dump(results, f, indent=2, default=str)

print(f"\n💾 Résultats: hybrid_walkforward_results.json")