foxhunt/ml/tests/ml_readiness_validation_tests.rs

//! # ML Readiness Validation Integration Tests
//!
//! End-to-end tests proving the ML system works with real data.
//! These tests validate:
//! - Data loading from DBN files
//! - Feature extraction and technical indicators
//! - Model inference pipelines
//! - End-to-end backtesting with baseline models
//!
//! ## Timeline
//!
//! These tests run in ~5-10 minutes and prove the system works.
//! Full ML training requires 4-6 weeks (see ML_TRAINING_ROADMAP.md).

use anyhow::Result;
use ml::inference_validator::{InferenceStatus, InferenceValidator};
use ml::random_model::{GaussianRandomModel, RandomModel};
use ml::real_data_loader::RealDataLoader;

/// Test 1: Load real DBN data and validate integrity
#[tokio::test]
async fn test_load_real_data() -> Result<()> {
    let mut loader = RealDataLoader::new_from_workspace()?;

    // Load ZN.FUT (Treasury futures - best quality data)
    let bars = loader.load_symbol_data("ZN.FUT").await?;

    // Validate data integrity
    assert!(
        bars.len() > 1000,
        "Expected >1000 bars for ZN.FUT, got {}",
        bars.len()
    );

    println!("✅ Loaded {} bars for ZN.FUT", bars.len());

    // Validate OHLCV relationships
    let mut valid_bars = 0;
    for bar in bars.iter().take(1000) {
        assert!(
            bar.high >= bar.low,
            "Invalid bar: high < low ({} < {})",
            bar.high,
            bar.low
        );
        assert!(
            bar.high >= bar.open && bar.high >= bar.close,
            "Invalid bar: high not highest"
        );
        assert!(
            bar.low <= bar.open && bar.low <= bar.close,
            "Invalid bar: low not lowest"
        );
        assert!(bar.volume >= 0.0, "Negative volume");
        valid_bars += 1;
    }

    println!("✅ Validated {} bars for OHLCV integrity", valid_bars);

    Ok(())
}

/// Test 2: Extract features and technical indicators
#[tokio::test]
async fn test_feature_extraction() -> Result<()> {
    let mut loader = RealDataLoader::new_from_workspace()?;
    let bars = loader.load_symbol_data("ZN.FUT").await?;

    // Extract features
    let features = loader.extract_features(&bars)?;

    assert_eq!(features.prices.len(), bars.len(), "Feature count mismatch");
    assert_eq!(features.returns.len(), bars.len(), "Returns count mismatch");

    println!("✅ Feature extraction: {} bars, 5 features/bar", bars.len());

    // Calculate technical indicators
    let indicators = loader.calculate_indicators(&bars)?;

    assert_eq!(indicators.rsi.len(), bars.len(), "RSI count mismatch");
    assert_eq!(indicators.macd.len(), bars.len(), "MACD count mismatch");
    assert_eq!(indicators.ema_fast.len(), bars.len(), "EMA count mismatch");

    // Validate RSI range (0-100)
    let valid_rsi = indicators
        .rsi
        .iter()
        .skip(14) // Skip warmup period
        .filter(|&&rsi| rsi >= 0.0 && rsi <= 100.0)
        .count();

    assert!(valid_rsi > 0, "No valid RSI values after warmup period");

    println!(
        "✅ Technical indicators: 10 indicators × {} bars",
        bars.len()
    );
    println!("   - RSI valid: {}/{}", valid_rsi, bars.len() - 14);

    Ok(())
}

/// Test 3: Validate model inference pipelines
#[tokio::test]
async fn test_model_inference_validation() -> Result<()> {
    let validator = InferenceValidator::new();

    // Validate all models
    let reports = validator.validate_all()?;

    assert_eq!(reports.len(), 4, "Expected 4 model reports");

    // Count ready vs missing
    let ready_count = reports
        .iter()
        .filter(|r| r.status == InferenceStatus::Ready)
        .count();
    let missing_count = reports
        .iter()
        .filter(|r| r.status == InferenceStatus::CheckpointMissing)
        .count();

    println!("🔍 Model Inference Validation:");
    println!("  Ready: {}/4", ready_count);
    println!("  Missing checkpoints: {}/4", missing_count);

    // All checkpoints should be missing (until we train models)
    assert_eq!(
        missing_count, 4,
        "Expected all checkpoints missing (no training yet)"
    );

    // Print detailed summary
    InferenceValidator::print_summary(&reports);

    Ok(())
}

/// Test 4: End-to-end system validation with random model
#[tokio::test]
async fn test_end_to_end_ml_pipeline() -> Result<()> {
    println!("\n🚀 End-to-End ML Pipeline Validation");
    println!("═══════════════════════════════════════════════════════════");

    // Step 1: Load data
    let mut loader = RealDataLoader::new_from_workspace()?;
    let bars = loader.load_symbol_data("ZN.FUT").await?;
    println!("✅ Data loading: {} bars", bars.len());

    // Step 2: Extract features
    let features = loader.extract_features(&bars)?;
    println!(
        "✅ Feature extraction: {} features/bar",
        features.prices[0].len()
    );

    // Step 3: Calculate indicators
    let indicators = loader.calculate_indicators(&bars)?;
    println!("✅ Technical indicators: 10 indicators");

    // Step 4: Test with random baseline model
    let model = RandomModel::new();

    // Simple backtest: predict direction, calculate returns
    let mut equity = 100_000.0;
    let mut trades = 0;
    let mut wins = 0;

    // Use last 1000 bars for testing
    let test_start = bars.len().saturating_sub(1000);
    for i in (test_start + 1)..bars.len() {
        let prediction = model.predict(&features);
        let actual_return = (bars[i].close - bars[i - 1].close) / bars[i - 1].close;

        // Take position based on prediction
        if prediction > 0.0 {
            // Long position
            let pnl = equity * actual_return;
            equity += pnl;
            trades += 1;
            if actual_return > 0.0 {
                wins += 1;
            }
        } else if prediction < 0.0 {
            // Short position
            let pnl = equity * (-actual_return);
            equity += pnl;
            trades += 1;
            if actual_return < 0.0 {
                wins += 1;
            }
        }
    }

    let total_return = (equity - 100_000.0) / 100_000.0 * 100.0;
    let win_rate = if trades > 0 {
        wins as f64 / trades as f64 * 100.0
    } else {
        0.0
    };

    println!("\n📊 Backtest Results (Random Baseline):");
    println!("  Trades: {}", trades);
    println!("  Win rate: {:.1}%", win_rate);
    println!("  Total return: {:.2}%", total_return);
    println!("  Final equity: ${:.2}", equity);

    println!("\n✅ End-to-end pipeline working!");
    println!("═══════════════════════════════════════════════════════════\n");

    Ok(())
}

/// Test 5: Compare uniform vs Gaussian random models
#[tokio::test]
async fn test_baseline_model_comparison() -> Result<()> {
    println!("\n📊 Baseline Model Comparison");
    println!("═══════════════════════════════════════════════════════════");

    let mut loader = RealDataLoader::new_from_workspace()?;
    let bars = loader.load_symbol_data("ZN.FUT").await?;
    let features = loader.extract_features(&bars)?;

    // Test uniform random model
    let uniform_model = RandomModel::new();
    let uniform_preds = uniform_model.predict_batch(100);

    // Test Gaussian random model
    let gaussian_model = GaussianRandomModel::new();
    let gaussian_preds = gaussian_model.predict_batch(100);

    // Compare distributions
    let uniform_mean: f32 = uniform_preds.iter().sum::<f32>() / uniform_preds.len() as f32;
    let gaussian_mean: f32 = gaussian_preds.iter().sum::<f32>() / gaussian_preds.len() as f32;

    println!("\n🔍 Distribution Analysis:");
    println!("  Uniform Random:");
    println!("    Mean: {:.3}", uniform_mean);
    println!(
        "    Min: {:.3}",
        uniform_preds.iter().fold(f32::MAX, |a, &b| a.min(b))
    );
    println!(
        "    Max: {:.3}",
        uniform_preds.iter().fold(f32::MIN, |a, &b| a.max(b))
    );

    println!("\n  Gaussian Random:");
    println!("    Mean: {:.3}", gaussian_mean);
    println!(
        "    Min: {:.3}",
        gaussian_preds.iter().fold(f32::MAX, |a, &b| a.min(b))
    );
    println!(
        "    Max: {:.3}",
        gaussian_preds.iter().fold(f32::MIN, |a, &b| a.max(b))
    );

    // Count near-zero predictions (Gaussian should have more)
    let uniform_near_zero = uniform_preds.iter().filter(|&&p| p.abs() < 0.2).count();
    let gaussian_near_zero = gaussian_preds.iter().filter(|&&p| p.abs() < 0.2).count();

    println!("\n  Near-zero predictions (|x| < 0.2):");
    println!(
        "    Uniform: {}/100 ({:.0}%)",
        uniform_near_zero, uniform_near_zero as f32
    );
    println!(
        "    Gaussian: {}/100 ({:.0}%)",
        gaussian_near_zero, gaussian_near_zero as f32
    );

    assert!(
        gaussian_near_zero > uniform_near_zero,
        "Gaussian should have more predictions near zero"
    );

    println!("\n✅ Baseline models working as expected");
    println!("═══════════════════════════════════════════════════════════\n");

    Ok(())
}

/// Test 6: Multi-symbol data quality validation
#[tokio::test]
async fn test_multi_symbol_validation() -> Result<()> {
    println!("\n📋 Multi-Symbol Data Quality Validation");
    println!("═══════════════════════════════════════════════════════════");

    let mut loader = RealDataLoader::new_from_workspace()?;

    // Test multiple symbols
    let symbols = vec!["ZN.FUT", "6E.FUT"];

    for symbol in symbols {
        let bars_result = loader.load_symbol_data(symbol).await;

        match bars_result {
            Ok(bars) => {
                println!("\n✅ {}: {} bars loaded", symbol, bars.len());

                // Calculate basic statistics
                let prices: Vec<f64> = bars.iter().map(|b| b.close).collect();
                let volumes: Vec<f64> = bars.iter().map(|b| b.volume).collect();

                let price_min = prices.iter().fold(f64::MAX, |a, &b| a.min(b));
                let price_max = prices.iter().fold(f64::MIN, |a, &b| a.max(b));
                let price_mean = prices.iter().sum::<f64>() / prices.len() as f64;

                let vol_mean = volumes.iter().sum::<f64>() / volumes.len() as f64;

                println!("   Price range: ${:.2} - ${:.2}", price_min, price_max);
                println!("   Price mean: ${:.2}", price_mean);
                println!("   Avg volume: {:.0}", vol_mean);

                // Test feature extraction
                let features = loader.extract_features(&bars)?;
                println!(
                    "   Features: {} bars × {} features",
                    features.prices.len(),
                    features.prices[0].len()
                );

                // Test indicators (only if enough data)
                if bars.len() >= 26 {
                    let indicators = loader.calculate_indicators(&bars)?;
                    println!("   Indicators: 10 technical indicators computed");

                    // Validate RSI
                    let valid_rsi = indicators
                        .rsi
                        .iter()
                        .skip(14)
                        .filter(|&&rsi| rsi >= 0.0 && rsi <= 100.0)
                        .count();
                    println!(
                        "   RSI validity: {}/{} ({:.1}%)",
                        valid_rsi,
                        indicators.rsi.len() - 14,
                        valid_rsi as f64 / (indicators.rsi.len() - 14) as f64 * 100.0
                    );
                }
            },
            Err(e) => {
                println!("\n⚠️ {}: File not found ({})", symbol, e);
                println!("   This is expected if data hasn't been downloaded");
            },
        }
    }

    println!("\n✅ Multi-symbol validation complete");
    println!("═══════════════════════════════════════════════════════════\n");

    Ok(())
}