//! Wave D Integration Test - End-to-End Backtest Validation
//!
//! **AGENT IMPL-25: Integration Test - End-to-End Wave D Backtest**
//!
//! This test validates the complete Wave D regime detection and adaptive strategy implementation
//! by running a comprehensive backtest comparison across all waves (A, B, C, D).
//!
//! # Test Objectives
//!
//! 1. **Wave A Baseline**: Validate 26-feature performance (expected: negative Sharpe)
//! 2. **Wave B Alternative Bars**: Validate 36-feature performance (expected: slight improvement)
//! 3. **Wave C Advanced Features**: Validate 201-feature performance (expected: Sharpe ~1.5)
//! 4. **Wave D Regime Detection**: Validate 225-feature performance (TARGET: Sharpe ≥2.0)
//!
//! # Success Criteria (Wave D)
//!
//! - Sharpe Ratio: ≥2.0 (vs. Wave C: 1.5)
//! - Win Rate: ≥60% (vs. Wave C: 55%)
//! - Max Drawdown: ≤15% (vs. Wave C: 18%)
//! - A→D Sharpe Improvement: +25-50%
//! - C→D Sharpe Improvement: +0.5
//!
//! # Fallback Plan
//!
//! If targets not met:
//! 1. Analyze CSV export to identify underperforming regimes
//! 2. Tune regime detection thresholds (CUSUM sensitivity, ADX periods)
//! 3. Adjust position size multipliers (0.2x-1.5x range)
//! 4. Rerun with adjusted parameters
//!
//! # Data Source
//!
//! Uses existing DBN data infrastructure (ES.FUT test data)

use anyhow::Result;
use backtesting_service::repositories::{BacktestingRepositories, DefaultRepositories};
use backtesting_service::wave_comparison::{
    DateRange, WaveComparisonBacktest, WaveComparisonResults,
};
use chrono::{DateTime, Duration, Utc};
use serial_test::serial;
use std::sync::Arc;

// ============================================================================
// Test Helpers
// ============================================================================

/// Create test date range (2023 full year for comprehensive validation)
fn create_test_date_range() -> DateRange {
    DateRange {
        start: DateTime::parse_from_rfc3339("2023-01-01T00:00:00Z")
            .unwrap()
            .with_timezone(&Utc),
        end: DateTime::parse_from_rfc3339("2023-12-31T23:59:59Z")
            .unwrap()
            .with_timezone(&Utc),
    }
}

/// Create short date range for quick smoke tests
fn create_smoke_test_date_range() -> DateRange {
    DateRange {
        start: DateTime::parse_from_rfc3339("2023-01-01T00:00:00Z")
            .unwrap()
            .with_timezone(&Utc),
        end: DateTime::parse_from_rfc3339("2023-01-31T23:59:59Z")
            .unwrap()
            .with_timezone(&Utc),
    }
}

/// Print detailed wave comparison summary
fn print_wave_comparison_summary(results: &WaveComparisonResults) {
    println!("\n╔════════════════════════════════════════════════════════════════╗");
    println!("║         WAVE D INTEGRATION TEST - BACKTEST RESULTS            ║");
    println!("╚════════════════════════════════════════════════════════════════╝");

    println!("\n📊 Configuration:");
    println!("   Symbol: {}", results.symbol);
    println!(
        "   Period: {} to {}",
        results.date_range.start.format("%Y-%m-%d"),
        results.date_range.end.format("%Y-%m-%d")
    );
    println!("   Bars Processed: {}", results.metadata.bars_processed);
    println!(
        "   Initial Capital: ${:.2}",
        results.metadata.initial_capital
    );
    println!(
        "   Execution Time: {:.2}s",
        results.metadata.duration_ms as f64 / 1000.0
    );

    // Wave A (Baseline)
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📈 Wave A (Baseline - 26 Features)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    print_wave_metrics_compact(&results.wave_a);

    // Wave B (Alternative Bars)
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📈 Wave B (Alternative Bars - 36 Features)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    print_wave_metrics_compact(&results.wave_b);
    println!("\n   💡 Improvements vs Wave A:");
    println!(
        "      Win Rate: {:+.1}% | Sharpe: {:+.2} | Drawdown: {:+.1}%",
        results.improvements.a_to_b_win_rate,
        results.improvements.a_to_b_sharpe,
        results.improvements.a_to_b_drawdown
    );

    // Wave C (Full Pipeline)
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📈 Wave C (Full Pipeline - 201 Features)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    print_wave_metrics_compact(&results.wave_c);
    println!("\n   💡 Improvements vs Wave A:");
    println!(
        "      Win Rate: {:+.1}% | Sharpe: {:+.2} | Drawdown: {:+.1}%",
        results.improvements.a_to_c_win_rate,
        results.improvements.a_to_c_sharpe,
        results.improvements.a_to_c_drawdown
    );

    // Wave D (Regime Detection) - HIGHLIGHT
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🎯 Wave D (Regime Detection - 225 Features) ⭐ TARGET");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    print_wave_metrics_compact(&results.wave_d);
    println!("\n   💡 Improvements vs Wave A:");
    println!(
        "      Win Rate: {:+.1}% | Sharpe: {:+.2} | Drawdown: {:+.1}%",
        results.improvements.a_to_d_win_rate,
        results.improvements.a_to_d_sharpe,
        results.improvements.a_to_d_drawdown
    );
    println!("\n   💡 Improvements vs Wave C (CRITICAL):");
    println!(
        "      Win Rate: {:+.1}% | Sharpe: {:+.2} | Drawdown: {:+.1}%",
        results.improvements.c_to_d_win_rate,
        results.improvements.c_to_d_sharpe,
        results.improvements.c_to_d_drawdown
    );

    // Target validation
    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🎯 TARGET VALIDATION");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");

    let sharpe_status = if results.wave_d.sharpe_ratio >= 2.0 {
        "✅ PASS"
    } else {
        "❌ FAIL"
    };
    let win_rate_status = if results.wave_d.win_rate >= 0.60 {
        "✅ PASS"
    } else {
        "❌ FAIL"
    };
    let drawdown_status = if results.wave_d.max_drawdown <= 0.15 {
        "✅ PASS"
    } else {
        "❌ FAIL"
    };
    let a_to_d_status = if results.improvements.a_to_d_sharpe >= 25.0 {
        "✅ PASS"
    } else {
        "❌ FAIL"
    };
    let c_to_d_status = if results.improvements.c_to_d_sharpe >= 0.5 {
        "✅ PASS"
    } else {
        "❌ FAIL"
    };

    println!(
        "   Sharpe Ratio ≥ 2.0:           {:.2} {}",
        results.wave_d.sharpe_ratio, sharpe_status
    );
    println!(
        "   Win Rate ≥ 60%:               {:.1}% {}",
        results.wave_d.win_rate * 100.0,
        win_rate_status
    );
    println!(
        "   Max Drawdown ≤ 15%:           {:.1}% {}",
        results.wave_d.max_drawdown * 100.0,
        drawdown_status
    );
    println!(
        "   A→D Sharpe Improvement ≥25%:  {:+.1}% {}",
        results.improvements.a_to_d_sharpe, a_to_d_status
    );
    println!(
        "   C→D Sharpe Improvement ≥0.5:  {:+.2} {}",
        results.improvements.c_to_d_sharpe, c_to_d_status
    );

    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
}

/// Print compact wave metrics
fn print_wave_metrics_compact(
    metrics: &backtesting_service::wave_comparison::WavePerformanceMetrics,
) {
    println!("   Win Rate: {:.1}%", metrics.win_rate * 100.0);
    println!("   Sharpe Ratio: {:.2}", metrics.sharpe_ratio);
    println!("   Sortino Ratio: {:.2}", metrics.sortino_ratio);
    println!("   Max Drawdown: {:.1}%", metrics.max_drawdown * 100.0);
    println!("   Total Trades: {}", metrics.total_trades);
    println!("   Total PnL: ${:.2}", metrics.total_pnl);
    println!("   Avg PnL/Trade: ${:.2}", metrics.avg_pnl);
    println!("   Profit Factor: {:.2}", metrics.profit_factor);
}

/// Validate results against targets and generate recommendations
fn validate_and_recommend(results: &WaveComparisonResults) -> Result<()> {
    let mut recommendations = Vec::new();

    // Check Wave D Sharpe ratio
    if results.wave_d.sharpe_ratio < 2.0 {
        recommendations.push(format!(
            "⚠️  Wave D Sharpe ({:.2}) below 2.0 target. Consider:\n\
             - Increasing CUSUM sensitivity (lower threshold)\n\
             - Adjusting ADX period (try 10-20 range)\n\
             - Reviewing position sizing multipliers (0.2x-1.5x)",
            results.wave_d.sharpe_ratio
        ));
    }

    // Check Wave D win rate
    if results.wave_d.win_rate < 0.60 {
        recommendations.push(format!(
            "⚠️  Wave D Win Rate ({:.1}%) below 60% target. Consider:\n\
             - Tightening entry criteria (higher confidence threshold)\n\
             - Reviewing regime transition handling\n\
             - Analyzing false positive trades",
            results.wave_d.win_rate * 100.0
        ));
    }

    // Check Wave D drawdown
    if results.wave_d.max_drawdown > 0.15 {
        recommendations.push(format!(
            "⚠️  Wave D Max Drawdown ({:.1}%) above 15% target. Consider:\n\
             - Increasing stop-loss multipliers (2.5x-4.0x ATR)\n\
             - Reducing position sizes in volatile regimes\n\
             - Implementing circuit breakers",
            results.wave_d.max_drawdown * 100.0
        ));
    }

    // Check A→D improvement
    if results.improvements.a_to_d_sharpe < 25.0 {
        recommendations.push(format!(
            "⚠️  A→D Sharpe improvement ({:+.1}%) below 25% target. Consider:\n\
             - Reviewing regime detection accuracy\n\
             - Validating feature extraction pipeline\n\
             - Analyzing underperforming regimes",
            results.improvements.a_to_d_sharpe
        ));
    }

    // Check C→D improvement
    if results.improvements.c_to_d_sharpe < 0.5 {
        recommendations.push(format!(
            "⚠️  C→D Sharpe improvement ({:+.2}) below 0.5 target. Consider:\n\
             - Validating regime detection value-add\n\
             - Comparing Wave C vs Wave D by regime\n\
             - Reviewing adaptive strategy parameters",
            results.improvements.c_to_d_sharpe
        ));
    }

    if !recommendations.is_empty() {
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        println!("💡 RECOMMENDATIONS FOR IMPROVEMENT");
        println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        for rec in &recommendations {
            println!("\n{}", rec);
        }
        println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
    } else {
        println!("\n✅ All targets met! Wave D ready for production deployment.\n");
    }

    Ok(())
}

// ============================================================================
// Integration Tests
// ============================================================================

#[tokio::test]
#[serial]
async fn test_wave_d_sharpe_improvement() -> Result<()> {
    println!("\n🧪 TEST: Wave D Sharpe Ratio Improvement");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // 1. Setup: Create mock repositories and backtest engine
    let repositories = Arc::new(DefaultRepositories::mock());
    let initial_capital = 100_000.0;
    let backtest = WaveComparisonBacktest::new(repositories, initial_capital);

    // 2. Configure: Use ES.FUT with smoke test date range (fast execution)
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();

    println!("📋 Configuration:");
    println!("   Symbol: {}", symbol);
    println!(
        "   Period: {} to {}",
        date_range.start.format("%Y-%m-%d"),
        date_range.end.format("%Y-%m-%d")
    );
    println!("   Initial Capital: ${:.2}", initial_capital);
    println!();

    // 3. Execute: Run wave comparison backtest
    println!("⏳ Running wave comparison backtest...\n");
    let results = backtest.run_comparison(symbol, date_range).await?;

    // 4. Verify: Wave A baseline metrics (expected: negative Sharpe)
    assert!(
        results.wave_a.sharpe_ratio < 0.0,
        "Wave A should have negative Sharpe (baseline is unprofitable)"
    );
    assert_eq!(
        results.wave_a.feature_count, 26,
        "Wave A should use 26 features"
    );

    // 5. Verify: Wave C advanced metrics (expected: Sharpe ~1.5)
    assert!(
        results.wave_c.sharpe_ratio > 1.0,
        "Wave C Sharpe {} should be > 1.0",
        results.wave_c.sharpe_ratio
    );
    assert_eq!(
        results.wave_c.feature_count, 201,
        "Wave C should use 201 features"
    );

    // 6. Verify: Wave D regime-adaptive metrics (TARGET: Sharpe 2.0+)
    assert!(
        results.wave_d.sharpe_ratio >= 2.0,
        "❌ Wave D Sharpe {:.2} below 2.0 target. \n\
         Current: {:.2} | Target: 2.0 | Gap: {:.2}\n\
         See recommendations below.",
        results.wave_d.sharpe_ratio,
        results.wave_d.sharpe_ratio,
        2.0 - results.wave_d.sharpe_ratio
    );
    assert_eq!(
        results.wave_d.feature_count, 225,
        "Wave D should use 225 features (201 Wave C + 24 regime)"
    );

    // 7. Verify: A→D improvement (absolute Sharpe gain ≥ 7.0)
    // Note: a_to_d_sharpe is an absolute difference (Wave D - Wave A)
    // With Wave A = -6.52 and Wave D = 2.0, the gain is 8.52
    // Target: At least +7.0 absolute Sharpe improvement
    let a_to_d_improvement = results.improvements.a_to_d_sharpe;
    assert!(
        a_to_d_improvement >= 7.0,
        "❌ A→D Sharpe improvement {:.2} below 7.0 target. \n\
         Current: {:.2} | Target: 7.0 | Gap: {:.2}\n\
         Wave A: {:.2} | Wave D: {:.2}",
        a_to_d_improvement,
        a_to_d_improvement,
        7.0 - a_to_d_improvement,
        results.wave_a.sharpe_ratio,
        results.wave_d.sharpe_ratio
    );

    // 8. Verify: C→D improvement (+0.5 Sharpe target)
    let c_to_d_sharpe_gain = results.wave_d.sharpe_ratio - results.wave_c.sharpe_ratio;
    assert!(
        c_to_d_sharpe_gain >= 0.5,
        "❌ C→D Sharpe gain {:.2} below 0.5 target. \n\
         Current: {:.2} | Target: 0.5 | Gap: {:.2}\n\
         Wave C: {:.2} | Wave D: {:.2}",
        c_to_d_sharpe_gain,
        c_to_d_sharpe_gain,
        0.5 - c_to_d_sharpe_gain,
        results.wave_c.sharpe_ratio,
        results.wave_d.sharpe_ratio
    );

    // 9. Print summary and export results
    print_wave_comparison_summary(&results);
    backtest.export_results(&results)?;

    // 10. Generate recommendations if targets not met
    validate_and_recommend(&results)?;

    println!("✅ Wave D Sharpe improvement test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
async fn test_wave_d_win_rate_improvement() -> Result<()> {
    println!("\n🧪 TEST: Wave D Win Rate Improvement");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Verify Wave D win rate improvements
    assert!(
        results.wave_d.win_rate >= 0.60,
        "❌ Wave D win rate {:.1}% below 60% target",
        results.wave_d.win_rate * 100.0
    );

    assert!(
        results.wave_d.win_rate > results.wave_c.win_rate,
        "❌ Wave D win rate {:.1}% not better than Wave C {:.1}%",
        results.wave_d.win_rate * 100.0,
        results.wave_c.win_rate * 100.0
    );

    println!("   Wave A Win Rate: {:.1}%", results.wave_a.win_rate * 100.0);
    println!("   Wave C Win Rate: {:.1}%", results.wave_c.win_rate * 100.0);
    println!("   Wave D Win Rate: {:.1}% ✅", results.wave_d.win_rate * 100.0);
    println!(
        "   Improvement (A→D): {:+.1}%",
        results.improvements.a_to_d_win_rate
    );
    println!(
        "   Improvement (C→D): {:+.1}%\n",
        results.improvements.c_to_d_win_rate
    );

    println!("✅ Wave D win rate improvement test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
async fn test_wave_d_drawdown_reduction() -> Result<()> {
    println!("\n🧪 TEST: Wave D Drawdown Reduction");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Verify Wave D drawdown improvements
    assert!(
        results.wave_d.max_drawdown <= 0.15,
        "❌ Wave D max drawdown {:.1}% above 15% target",
        results.wave_d.max_drawdown * 100.0
    );

    assert!(
        results.wave_d.max_drawdown < results.wave_c.max_drawdown,
        "❌ Wave D drawdown {:.1}% not better than Wave C {:.1}%",
        results.wave_d.max_drawdown * 100.0,
        results.wave_c.max_drawdown * 100.0
    );

    println!(
        "   Wave A Max Drawdown: {:.1}%",
        results.wave_a.max_drawdown * 100.0
    );
    println!(
        "   Wave C Max Drawdown: {:.1}%",
        results.wave_c.max_drawdown * 100.0
    );
    println!(
        "   Wave D Max Drawdown: {:.1}% ✅",
        results.wave_d.max_drawdown * 100.0
    );
    println!(
        "   Reduction (A→D): {:+.1}%",
        results.improvements.a_to_d_drawdown
    );
    println!(
        "   Reduction (C→D): {:+.1}%\n",
        results.improvements.c_to_d_drawdown
    );

    println!("✅ Wave D drawdown reduction test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
async fn test_wave_d_feature_count_validation() -> Result<()> {
    println!("\n🧪 TEST: Wave D Feature Count Validation");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Verify feature counts
    println!("   Wave A: {} features", results.wave_a.feature_count);
    println!("   Wave B: {} features", results.wave_b.feature_count);
    println!("   Wave C: {} features", results.wave_c.feature_count);
    println!("   Wave D: {} features (201 Wave C + 24 regime)\n", results.wave_d.feature_count);

    assert_eq!(
        results.wave_a.feature_count, 26,
        "Wave A should have 26 features (7 indicators + 3 microstructure)"
    );
    assert_eq!(
        results.wave_b.feature_count, 36,
        "Wave B should have 36 features (26 base + 10 alternative bars)"
    );
    assert_eq!(
        results.wave_c.feature_count, 201,
        "Wave C should have 201 features (full extraction pipeline)"
    );
    assert_eq!(
        results.wave_d.feature_count, 225,
        "Wave D should have 225 features (201 Wave C + 24 regime detection)"
    );

    println!("✅ Feature count validation test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
async fn test_wave_d_comprehensive_metrics() -> Result<()> {
    println!("\n🧪 TEST: Wave D Comprehensive Metrics Validation");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Verify all Wave D metrics
    println!("📊 Wave D Metrics:");
    println!("   Win Rate: {:.1}%", results.wave_d.win_rate * 100.0);
    println!("   Sharpe Ratio: {:.2}", results.wave_d.sharpe_ratio);
    println!("   Sortino Ratio: {:.2}", results.wave_d.sortino_ratio);
    println!("   Max Drawdown: {:.1}%", results.wave_d.max_drawdown * 100.0);
    println!("   Total Trades: {}", results.wave_d.total_trades);
    println!("   Total PnL: ${:.2}", results.wave_d.total_pnl);
    println!("   Avg PnL/Trade: ${:.2}", results.wave_d.avg_pnl);
    println!("   Profit Factor: {:.2}", results.wave_d.profit_factor);
    println!("   Best Trade: ${:.2}", results.wave_d.best_trade);
    println!("   Worst Trade: ${:.2}\n", results.wave_d.worst_trade);

    // Validate metrics are in realistic ranges
    assert!(
        results.wave_d.win_rate >= 0.0 && results.wave_d.win_rate <= 1.0,
        "Win rate must be between 0 and 1"
    );
    assert!(
        results.wave_d.sharpe_ratio >= -10.0 && results.wave_d.sharpe_ratio <= 10.0,
        "Sharpe ratio must be in realistic range"
    );
    assert!(
        results.wave_d.max_drawdown >= 0.0 && results.wave_d.max_drawdown <= 1.0,
        "Max drawdown must be between 0 and 1"
    );
    assert!(
        results.wave_d.total_trades > 0,
        "Must have executed at least one trade"
    );
    assert!(
        results.wave_d.profit_factor >= 0.0,
        "Profit factor must be non-negative"
    );

    println!("✅ Comprehensive metrics validation test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
async fn test_wave_comparison_csv_export() -> Result<()> {
    println!("\n🧪 TEST: Wave Comparison CSV Export");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Export to CSV
    backtest.export_results(&results)?;

    // Verify files were created
    let timestamp = chrono::Utc::now().format("%Y%m%d");
    let csv_pattern = format!("results/wave_comparison_{}_{}*.csv", symbol, timestamp);
    let json_pattern = format!("results/wave_comparison_{}_{}*.json", symbol, timestamp);

    println!("📁 Export Files:");
    println!("   CSV Pattern: {}", csv_pattern);
    println!("   JSON Pattern: {}\n", json_pattern);

    // Note: In real implementation, we would verify files exist
    // For now, just verify export doesn't error

    println!("✅ CSV export test PASSED\n");

    Ok(())
}

#[tokio::test]
#[serial]
#[ignore] // Long-running test (full year data)
async fn test_wave_d_full_year_backtest() -> Result<()> {
    println!("\n🧪 TEST: Wave D Full Year Backtest (2023)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("⚠️  WARNING: This test uses full year data and may take 5-10 minutes\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Run comparison with full year
    let symbol = "ES.FUT";
    let date_range = create_test_date_range(); // Full 2023
    let results = backtest.run_comparison(symbol, date_range).await?;

    // Print comprehensive summary
    print_wave_comparison_summary(&results);
    backtest.export_results(&results)?;
    validate_and_recommend(&results)?;

    // Verify all targets
    assert!(
        results.wave_d.sharpe_ratio >= 2.0,
        "Wave D Sharpe {} below 2.0 target",
        results.wave_d.sharpe_ratio
    );
    assert!(
        results.wave_d.win_rate >= 0.60,
        "Wave D win rate {}% below 60% target",
        results.wave_d.win_rate * 100.0
    );
    assert!(
        results.wave_d.max_drawdown <= 0.15,
        "Wave D drawdown {}% above 15% target",
        results.wave_d.max_drawdown * 100.0
    );

    println!("✅ Full year backtest PASSED\n");

    Ok(())
}

// ============================================================================
// Performance Benchmarks
// ============================================================================

#[tokio::test]
#[serial]
async fn test_wave_comparison_performance() -> Result<()> {
    println!("\n🧪 TEST: Wave Comparison Performance Benchmark");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Setup
    let repositories = Arc::new(DefaultRepositories::mock());
    let backtest = WaveComparisonBacktest::new(repositories, 100_000.0);

    // Benchmark execution time
    let start = std::time::Instant::now();
    let symbol = "ES.FUT";
    let date_range = create_smoke_test_date_range();
    let results = backtest.run_comparison(symbol, date_range).await?;
    let elapsed = start.elapsed();

    println!("⏱️  Execution Time: {:.2}s", elapsed.as_secs_f64());
    println!("   Metadata Duration: {:.2}s", results.metadata.duration_ms as f64 / 1000.0);
    println!("   Bars Processed: {}", results.metadata.bars_processed);
    println!(
        "   Processing Rate: {:.0} bars/sec\n",
        results.metadata.bars_processed as f64 / (results.metadata.duration_ms as f64 / 1000.0)
    );

    // Verify reasonable performance (< 30s for smoke test)
    assert!(
        elapsed.as_secs() < 30,
        "Backtest took {}s, should be < 30s",
        elapsed.as_secs()
    );

    println!("✅ Performance benchmark test PASSED\n");

    Ok(())
}