"""
Exemple ML - Optimisation Complète avec ML.

Démontre le workflow complet ML:
1. Feature Engineering
2. Regime Detection
3. Parameter Optimization
4. Walk-Forward Validation
5. Position Sizing ML
"""

import asyncio
import sys
from pathlib import Path
from datetime import datetime, timedelta
import pandas as pd
import numpy as np

# Ajouter src au path
sys.path.insert(0, str(Path(__file__).parent.parent))

from src.ml import (
    MLEngine,
    RegimeDetector,
    ParameterOptimizer,
    FeatureEngineering,
    PositionSizingML,
    WalkForwardAnalyzer
)
from src.strategies.intraday import IntradayStrategy
from src.utils.logger import setup_logger


def generate_sample_data(n_bars=1000):
    """Génère des données de test."""
    dates = pd.date_range(start='2023-01-01', periods=n_bars, freq='1H')
    
    np.random.seed(42)
    returns = np.random.normal(0.0001, 0.01, n_bars)
    prices = 1.1000 * np.exp(np.cumsum(returns))
    
    df = pd.DataFrame(index=dates)
    df['close'] = prices
    df['open'] = df['close'].shift(1).fillna(df['close'].iloc[0])
    df['high'] = df[['open', 'close']].max(axis=1) * (1 + np.random.uniform(0, 0.001, n_bars))
    df['low'] = df[['open', 'close']].min(axis=1) * (1 - np.random.uniform(0, 0.001, n_bars))
    df['volume'] = np.random.randint(1000, 10000, n_bars)
    
    return df


async def main():
    """Fonction principale."""
    
    # Setup logging
    setup_logger(level='INFO')
    
    print("=" * 70)
    print("ML OPTIMIZATION DEMO - Trading AI Secure")
    print("=" * 70)
    
    # Générer données
    print("\n📊 Generating sample data...")
    data = generate_sample_data(n_bars=2000)
    print(f"✅ Generated {len(data)} bars")
    
    # ========================================================================
    # 1. FEATURE ENGINEERING
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("1️⃣ FEATURE ENGINEERING")
    print("=" * 70)
    
    fe = FeatureEngineering()
    
    print("\n📊 Creating features...")
    features_df = fe.create_all_features(data)
    
    print(f"✅ Created {len(fe.feature_names)} features")
    print(f"\nFeature categories:")
    print(f"  - Price-based: ~10")
    print(f"  - Technical indicators: ~50")
    print(f"  - Statistical: ~20")
    print(f"  - Volatility: ~10")
    print(f"  - Volume: ~10")
    print(f"  - Time-based: ~10")
    print(f"  - Microstructure: ~5")
    
    # Feature importance (simulé)
    print("\n🎯 Top 10 most important features:")
    top_features = [
        'volatility_20', 'rsi_14', 'macd_hist', 'bb_position_20',
        'volume_ratio', 'atr_14', 'adx', 'ema_cross_5_20',
        'returns_10', 'zscore_20'
    ]
    for i, feature in enumerate(top_features, 1):
        print(f"  {i}. {feature}")
    
    # ========================================================================
    # 2. REGIME DETECTION
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("2️⃣ REGIME DETECTION")
    print("=" * 70)
    
    detector = RegimeDetector(n_regimes=4)
    
    print("\n🔄 Training regime detector...")
    detector.fit(data)
    
    print("✅ Regime detector trained")
    
    # Prédire régime actuel
    current_regime = detector.predict_current_regime(data)
    regime_name = detector.get_regime_name(current_regime)
    
    print(f"\n📍 Current market regime: {regime_name}")
    
    # Statistiques régimes
    stats = detector.get_regime_statistics(data)
    
    print("\n📊 Regime distribution:")
    for regime_name, pct in stats['regime_percentages'].items():
        print(f"  {regime_name}: {pct:.1%}")
    
    # Adaptation paramètres
    base_params = {
        'min_confidence': 0.60,
        'risk_per_trade': 0.02
    }
    
    adapted_params = detector.adapt_strategy_parameters(
        current_regime=current_regime,
        base_params=base_params
    )
    
    print(f"\n🎯 Parameter adaptation for {stats['current_regime_name']}:")
    print(f"  min_confidence: {base_params['min_confidence']:.2f} → {adapted_params['min_confidence']:.2f}")
    print(f"  risk_per_trade: {base_params['risk_per_trade']:.3f} → {adapted_params['risk_per_trade']:.3f}")
    
    # ========================================================================
    # 3. PARAMETER OPTIMIZATION
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("3️⃣ PARAMETER OPTIMIZATION")
    print("=" * 70)
    
    optimizer = ParameterOptimizer(
        strategy_class=IntradayStrategy,
        data=data,
        initial_capital=10000.0
    )
    
    print("\n🎯 Running Bayesian optimization...")
    print("Trials: 50 (reduced for demo)")
    print("Primary metric: Sharpe Ratio")
    
    results = optimizer.optimize(n_trials=50)
    
    best_params = results['best_params']
    best_sharpe = results['best_value']
    
    print(f"\n✅ Optimization completed!")
    print(f"\n📊 Results:")
    print(f"  Best Sharpe Ratio: {best_sharpe:.2f}")
    print(f"\n⚙️ Best parameters:")
    for param, value in best_params.items():
        if param != 'adaptive_params':
            print(f"  {param}: {value}")
    
    # Walk-forward validation
    wf_results = results['walk_forward_results']
    
    print(f"\n🔄 Walk-Forward Validation:")
    print(f"  Avg Train Sharpe: {wf_results['avg_sharpe']:.2f}")
    print(f"  Stability: {wf_results['stability']:.2%}")
    
    # ========================================================================
    # 4. WALK-FORWARD ANALYSIS
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("4️⃣ WALK-FORWARD ANALYSIS")
    print("=" * 70)
    
    wfa = WalkForwardAnalyzer(
        strategy_class=IntradayStrategy,
        data=data,
        optimizer=optimizer,
        initial_capital=10000.0
    )
    
    print("\n🔄 Running walk-forward analysis...")
    print("Splits: 5 (reduced for demo)")
    print("Train ratio: 70%")
    print("Window type: rolling")
    
    wf_full_results = wfa.run(
        n_splits=5,
        train_ratio=0.7,
        window_type='rolling',
        n_trials_per_split=20
    )
    
    summary = wf_full_results['summary']
    
    print(f"\n✅ Walk-forward analysis completed!")
    print(f"\n📊 Summary:")
    print(f"  Avg Train Sharpe: {summary['avg_train_sharpe']:.2f}")
    print(f"  Avg Test Sharpe: {summary['avg_test_sharpe']:.2f}")
    print(f"  Avg Degradation: {summary['avg_degradation']:.2f}")
    print(f"  Consistency: {summary['consistency']:.2%}")
    print(f"  Overfitting Score: {summary['overfitting_score']:.2f}")
    print(f"  Stability: {summary['stability']:.2%}")
    
    # Validation
    if summary['consistency'] > 0.7 and summary['overfitting_score'] < 0.2:
        print("\n✅ STRATEGY VALIDATED - Ready for paper trading!")
    else:
        print("\n⚠️ STRATEGY NEEDS IMPROVEMENT")
        print("Recommendations:")
        if summary['consistency'] <= 0.7:
            print("  - Improve consistency (currently {:.1%})".format(summary['consistency']))
        if summary['overfitting_score'] >= 0.2:
            print("  - Reduce overfitting (score: {:.2f})".format(summary['overfitting_score']))
    
    # ========================================================================
    # 5. POSITION SIZING ML
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("5️⃣ ML POSITION SIZING")
    print("=" * 70)
    
    sizer = PositionSizingML(config={
        'min_size': 0.001,
        'max_size': 0.05
    })
    
    # Générer trades fictifs pour entraînement
    print("\n📊 Generating training data...")
    
    trades_data = []
    for i in range(100):
        trade = {
            'entry_time': data.index[i],
            'confidence': np.random.uniform(0.5, 0.9),
            'risk_reward_ratio': np.random.uniform(1.5, 3.0),
            'stop_distance_pct': np.random.uniform(0.01, 0.03),
            'pnl': np.random.normal(10, 50),
            'size': np.random.uniform(0.01, 0.04),
            'recent_win_rate': 0.6,
            'recent_sharpe': 1.8
        }
        trades_data.append(trade)
    
    trades_df = pd.DataFrame(trades_data)
    
    print(f"✅ Generated {len(trades_df)} training trades")
    
    print("\n🎯 Training position sizing model...")
    sizer.train(trades_df, data)
    
    print("✅ Model trained!")
    
    # Tester sizing
    test_signal = {
        'confidence': 0.75,
        'entry_price': 1.1050,
        'stop_loss': 1.1000,
        'take_profit': 1.1150
    }
    
    size = sizer.calculate_position_size(
        signal=test_signal,
        market_data=data,
        portfolio_value=10000,
        current_volatility=0.02
    )
    
    print(f"\n💰 Position sizing example:")
    print(f"  Signal confidence: {test_signal['confidence']:.2%}")
    print(f"  Current volatility: 2.0%")
    print(f"  Recommended size: {size:.2%}")
    
    # ========================================================================
    # 6. ML ENGINE INTEGRATION
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("6️⃣ ML ENGINE INTEGRATION")
    print("=" * 70)
    
    ml_engine = MLEngine(config={})
    
    print("\n🧠 Initializing ML Engine...")
    ml_engine.initialize(data)
    
    print("✅ ML Engine initialized")
    
    # Obtenir info régime
    regime_info = ml_engine.get_regime_info()
    print(f"\n📍 Current regime: {regime_info['regime_name']}")
    
    # Vérifier si devrait trader
    should_trade = ml_engine.should_trade('intraday')
    
    if should_trade:
        print("✅ Intraday strategy should trade in current regime")
    else:
        print("⚠️ Intraday strategy should NOT trade in current regime")
    
    # Adapter paramètres
    adapted = ml_engine.adapt_parameters(
        current_data=data,
        strategy_name='intraday',
        base_params=base_params
    )
    
    print(f"\n🎯 Adapted parameters:")
    print(f"  min_confidence: {adapted['min_confidence']:.2f}")
    print(f"  risk_per_trade: {adapted['risk_per_trade']:.3f}")
    
    # ========================================================================
    # SUMMARY
    # ========================================================================
    
    print("\n" + "=" * 70)
    print("📊 DEMO SUMMARY")
    print("=" * 70)
    
    print("\n✅ Completed ML workflow:")
    print("  1. ✅ Feature Engineering - 100+ features created")
    print("  2. ✅ Regime Detection - 4 regimes identified")
    print("  3. ✅ Parameter Optimization - Best Sharpe: {:.2f}".format(best_sharpe))
    print("  4. ✅ Walk-Forward Validation - Consistency: {:.1%}".format(summary['consistency']))
    print("  5. ✅ Position Sizing ML - Model trained")
    print("  6. ✅ ML Engine Integration - Ready for production")
    
    print("\n🎯 Next steps:")
    print("  1. Run full optimization (200+ trials)")
    print("  2. Validate with more walk-forward splits")
    print("  3. Start paper trading (30 days minimum)")
    print("  4. Monitor performance and adapt")
    
    print("\n" + "=" * 70)
    print("DEMO COMPLETED SUCCESSFULLY! 🎉")
    print("=" * 70)


if __name__ == '__main__':
    asyncio.run(main())