foxhunt/services/backtesting_service/tests/ml_backtest_integration_test.rs

//! ML Backtesting Integration Tests - TDD RED Phase
//!
//! This test suite follows strict TDD methodology:
//! 1. RED: Write failing tests (this file)
//! 2. GREEN: Implement minimal code to pass
//! 3. REFACTOR: Improve quality
//!
//! These tests will initially fail because the ML backtesting methods don't exist yet.

use anyhow::Result;
use backtesting_service::foxhunt::tli::{
    backtesting_service_server::BacktestingService, BacktestMetrics, GetBacktestResultsRequest,
    GetBacktestResultsResponse, StartBacktestRequest, StartBacktestResponse,
};
use backtesting_service::repositories::DefaultRepositories;
use backtesting_service::service::BacktestingServiceImpl;
use chrono::Utc;
use std::sync::Arc;
use tokio::sync::mpsc;
use tonic::{Request, Response, Status};

/// Helper to create test backtesting service instance
async fn create_test_backtesting_service() -> Result<BacktestingServiceImpl> {
    // Create service with mock repositories for testing
    use backtesting_service::repositories::BacktestingRepositories;
    let repositories: Arc<dyn BacktestingRepositories> = Arc::new(DefaultRepositories::mock());
    BacktestingServiceImpl::new(repositories, None).await
}

/// Helper to convert date string to Unix nanos
fn date_to_unix_nanos(date_str: &str) -> i64 {
    let date = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
        .unwrap()
        .and_hms_opt(0, 0, 0)
        .unwrap();
    date.and_utc().timestamp_nanos_opt().unwrap()
}

#[tokio::test]
async fn test_red_ml_backtest_execution() -> Result<()> {
    // RED: This test will fail because RunMLBacktest doesn't exist yet

    let service = create_test_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("confidence_threshold".to_string(), "0.6".to_string()),
            ("use_ensemble".to_string(), "true".to_string()),
        ]
        .into_iter()
        .collect(),
        save_results: true,
        description: "ML ensemble backtest integration test".to_string(),
    });

    // This should succeed once we implement ML backtesting
    let response = service.start_backtest(request).await?;
    let result = response.into_inner();

    assert!(result.success, "ML backtest should start successfully");
    assert!(
        !result.backtest_id.is_empty(),
        "Should return valid backtest ID"
    );

    // Wait for backtest to complete (simplified for test)
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;

    // Get results
    let results_request = Request::new(GetBacktestResultsRequest {
        backtest_id: result.backtest_id.clone(),
        include_trades: true,
        include_metrics: true,
    });

    let results_response = service.get_backtest_results(results_request).await?;
    let results = results_response.into_inner();

    // Verify ML backtest produced meaningful results
    assert!(results.metrics.is_some(), "Should have metrics");
    let metrics = results.metrics.unwrap();

    assert!(metrics.total_trades > 0, "Should have executed trades");
    assert!(
        metrics.sharpe_ratio > 0.0,
        "Should have positive Sharpe ratio"
    );
    assert!(
        metrics.win_rate > 0.0 && metrics.win_rate <= 1.0,
        "Win rate should be 0-1"
    );

    println!("✅ ML Backtest Results:");
    println!("   Total Trades: {}", metrics.total_trades);
    println!("   Sharpe Ratio: {:.2}", metrics.sharpe_ratio);
    println!("   Win Rate: {:.2}%", metrics.win_rate * 100.0);
    println!("   Total Return: {:.2}%", metrics.total_return * 100.0);

    Ok(())
}

#[tokio::test]
async fn test_red_ml_vs_rule_based_comparison() -> Result<()> {
    // RED: This test will fail because strategy comparison doesn't exist yet

    let service = create_test_backtesting_service().await?;

    // Run ML backtest
    let ml_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![("confidence_threshold".to_string(), "0.6".to_string())]
            .into_iter()
            .collect(),
        save_results: true,
        description: "ML backtest for comparison".to_string(),
    });

    let ml_response = service.start_backtest(ml_request).await?;
    let ml_id = ml_response.into_inner().backtest_id;

    // Run rule-based backtest for comparison
    let rule_request = Request::new(StartBacktestRequest {
        strategy_name: "MovingAverageCrossover".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![
            ("fast_period".to_string(), "10".to_string()),
            ("slow_period".to_string(), "20".to_string()),
        ]
        .into_iter()
        .collect(),
        save_results: true,
        description: "Rule-based backtest for comparison".to_string(),
    });

    let rule_response = service.start_backtest(rule_request).await?;
    let rule_id = rule_response.into_inner().backtest_id;

    // Wait for both to complete
    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;

    // Get ML results
    let ml_results = service
        .get_backtest_results(Request::new(GetBacktestResultsRequest {
            backtest_id: ml_id.clone(),
            include_trades: false,
            include_metrics: true,
        }))
        .await?
        .into_inner();

    // Get rule-based results
    let rule_results = service
        .get_backtest_results(Request::new(GetBacktestResultsRequest {
            backtest_id: rule_id.clone(),
            include_trades: false,
            include_metrics: true,
        }))
        .await?
        .into_inner();

    let ml_metrics = ml_results.metrics.unwrap();
    let rule_metrics = rule_results.metrics.unwrap();

    println!("📊 Strategy Comparison:");
    println!(
        "   ML Sharpe: {:.2} | Rule Sharpe: {:.2}",
        ml_metrics.sharpe_ratio, rule_metrics.sharpe_ratio
    );
    println!(
        "   ML Win Rate: {:.2}% | Rule Win Rate: {:.2}%",
        ml_metrics.win_rate * 100.0,
        rule_metrics.win_rate * 100.0
    );
    println!(
        "   ML Return: {:.2}% | Rule Return: {:.2}%",
        ml_metrics.total_return * 100.0,
        rule_metrics.total_return * 100.0
    );

    // ML should generally outperform rule-based (but not guaranteed in all periods)
    // We just verify both produce valid results
    assert!(
        ml_metrics.sharpe_ratio > 0.0,
        "ML should have positive Sharpe"
    );
    assert!(
        rule_metrics.sharpe_ratio > 0.0,
        "Rule-based should have positive Sharpe"
    );

    Ok(())
}

#[tokio::test]
async fn test_red_ml_confidence_threshold_impact() -> Result<()> {
    // RED: This test will fail because confidence threshold filtering doesn't exist yet

    let service = create_test_backtesting_service().await?;

    // Run with low confidence threshold (more trades)
    let low_threshold_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![("confidence_threshold".to_string(), "0.5".to_string())]
            .into_iter()
            .collect(),
        save_results: true,
        description: "Low confidence threshold test".to_string(),
    });

    let low_response = service.start_backtest(low_threshold_request).await?;
    let low_id = low_response.into_inner().backtest_id;

    // Run with high confidence threshold (fewer trades)
    let high_threshold_request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![("confidence_threshold".to_string(), "0.8".to_string())]
            .into_iter()
            .collect(),
        save_results: true,
        description: "High confidence threshold test".to_string(),
    });

    let high_response = service.start_backtest(high_threshold_request).await?;
    let high_id = high_response.into_inner().backtest_id;

    // Wait for both to complete
    tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;

    // Get results
    let low_results = service
        .get_backtest_results(Request::new(GetBacktestResultsRequest {
            backtest_id: low_id,
            include_trades: false,
            include_metrics: true,
        }))
        .await?
        .into_inner();

    let high_results = service
        .get_backtest_results(Request::new(GetBacktestResultsRequest {
            backtest_id: high_id,
            include_trades: false,
            include_metrics: true,
        }))
        .await?
        .into_inner();

    let low_metrics = low_results.metrics.unwrap();
    let high_metrics = high_results.metrics.unwrap();

    // Higher threshold should result in fewer trades
    assert!(
        low_metrics.total_trades > high_metrics.total_trades,
        "Low threshold should produce more trades than high threshold"
    );

    // Higher threshold might have better win rate (filtering low-confidence trades)
    println!("📈 Confidence Threshold Impact:");
    println!(
        "   Low (0.5) - Trades: {}, Win Rate: {:.2}%",
        low_metrics.total_trades,
        low_metrics.win_rate * 100.0
    );
    println!(
        "   High (0.8) - Trades: {}, Win Rate: {:.2}%",
        high_metrics.total_trades,
        high_metrics.win_rate * 100.0
    );

    Ok(())
}

#[tokio::test]
async fn test_red_ml_target_metrics() -> Result<()> {
    // RED: This test verifies we meet target metrics once implemented

    let service = create_test_backtesting_service().await?;

    let request = Request::new(StartBacktestRequest {
        strategy_name: "MLEnsemble".to_string(),
        symbols: vec!["ES.FUT".to_string()],
        start_date_unix_nanos: date_to_unix_nanos("2024-01-02"),
        end_date_unix_nanos: date_to_unix_nanos("2024-01-10"),
        initial_capital: 100000.0,
        parameters: vec![("confidence_threshold".to_string(), "0.6".to_string())]
            .into_iter()
            .collect(),
        save_results: true,
        description: "Target metrics validation".to_string(),
    });

    let response = service.start_backtest(request).await?;
    let backtest_id = response.into_inner().backtest_id;

    // Wait for completion
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;

    let results = service
        .get_backtest_results(Request::new(GetBacktestResultsRequest {
            backtest_id,
            include_trades: false,
            include_metrics: true,
        }))
        .await?
        .into_inner();

    let metrics = results.metrics.unwrap();

    // Target metrics from CLAUDE.md
    println!("🎯 Target Metrics Validation:");
    println!(
        "   Sharpe Ratio: {:.2} (target: >1.5)",
        metrics.sharpe_ratio
    );
    println!(
        "   Win Rate: {:.2}% (target: >55%)",
        metrics.win_rate * 100.0
    );
    println!(
        "   Max Drawdown: {:.2}% (target: <20%)",
        metrics.max_drawdown * 100.0
    );

    // These are aggressive targets - we'll verify reasonable values for now
    assert!(metrics.sharpe_ratio > 0.0, "Sharpe should be positive");
    assert!(metrics.win_rate > 0.4, "Win rate should be >40%");
    assert!(metrics.max_drawdown < 0.5, "Max drawdown should be <50%");

    // Goal: Eventually achieve these targets with trained models
    if metrics.sharpe_ratio > 1.5 {
        println!("   ✅ ACHIEVED Sharpe target!");
    }
    if metrics.win_rate > 0.55 {
        println!("   ✅ ACHIEVED Win rate target!");
    }

    Ok(())
}