//! Trending Regime Classifier - Comprehensive TDD Tests
//!
//! This test suite validates the TrendingClassifier implementation across:
//! - Unit tests: ADX calculation accuracy, Hurst exponent correctness
//! - Integration tests: Real ES.FUT/NQ.FUT data validation
//! - Property-based tests: Invariants and edge cases
//! - Performance tests: <150μs per bar target
//!
//! ## Test Coverage Goals
//! - ADX calculation: ±5% error vs TA-Lib reference (if available)
//! - Trending vs ranging: >80% discrimination accuracy
//! - Real data validation: January 2024 ES.FUT volatility spike detection
//!
//! ## Test Execution
//! ```bash
//! cargo test -p ml --test trending_test
//! cargo test -p ml --test trending_test -- --nocapture  # With output
//! ```

use chrono::{DateTime, Utc};

// Import from ml crate
use ml::regime::trending::{Direction, OHLCVBar, TrendingClassifier, TrendingSignal};

// =============================================================================
// Test Utilities
// =============================================================================

/// Create test OHLCV bar with timestamp
fn create_bar(
    timestamp: DateTime<Utc>,
    open: f64,
    high: f64,
    low: f64,
    close: f64,
    volume: f64,
) -> OHLCVBar {
    OHLCVBar {
        timestamp,
        open,
        high,
        low,
        close,
        volume,
    }
}

/// Create simple test bar with close price only (auto-generate OHLC)
fn create_simple_bar(close: f64) -> OHLCVBar {
    OHLCVBar {
        timestamp: Utc::now(),
        open: close,
        high: close * 1.01,
        low: close * 0.99,
        close,
        volume: 1000.0,
    }
}

/// Generate synthetic trending data (persistent uptrend)
fn generate_uptrend_data(start_price: f64, bars: usize, trend_strength: f64) -> Vec<OHLCVBar> {
    let mut data = Vec::with_capacity(bars);
    let mut price = start_price;

    for i in 0..bars {
        price += trend_strength; // Linear trend
        let noise = (i as f64 * 0.1).sin() * 0.2; // Small noise
        let close = price + noise;
        data.push(create_simple_bar(close));
    }

    data
}

/// Generate synthetic ranging data (mean-reverting oscillation)
fn generate_ranging_data(base_price: f64, bars: usize, oscillation: f64) -> Vec<OHLCVBar> {
    let mut data = Vec::with_capacity(bars);

    for i in 0..bars {
        let phase = i as f64 * 0.2; // Oscillation frequency
        let price = base_price + phase.sin() * oscillation;
        data.push(create_simple_bar(price));
    }

    data
}

/// Generate synthetic downtrend data
fn generate_downtrend_data(start_price: f64, bars: usize, trend_strength: f64) -> Vec<OHLCVBar> {
    let mut data = Vec::with_capacity(bars);
    let mut price = start_price;

    for i in 0..bars {
        price -= trend_strength; // Linear downtrend
        let noise = (i as f64 * 0.15).cos() * 0.3; // Small noise
        let close = price + noise;
        data.push(create_simple_bar(close));
    }

    data
}

// =============================================================================
// Unit Tests: ADX Calculation Validation
// =============================================================================

#[test]
fn test_adx_uptrend_increases() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_uptrend_data(100.0, 50, 0.5);

    let mut adx_values = Vec::new();
    for bar in data {
        classifier.classify(bar);
        adx_values.push(classifier.get_trend_strength());
    }

    // ADX should increase during consistent trend
    let initial_adx = adx_values[10]; // After initialization
    let final_adx = adx_values[adx_values.len() - 1];
    assert!(
        final_adx > initial_adx,
        "ADX should increase during uptrend: initial={:.2}, final={:.2}",
        initial_adx,
        final_adx
    );
}

#[test]
fn test_adx_ranging_low() {
    let mut classifier = TrendingClassifier::new(20.0, 0.5, 50);
    let data = generate_ranging_data(100.0, 60, 2.0);

    for bar in data {
        classifier.classify(bar);
    }

    let final_adx = classifier.get_trend_strength();
    assert!(
        final_adx < 30.0,
        "Ranging market should have low ADX, got {:.2}",
        final_adx
    );
}

#[test]
fn test_adx_range_bounds() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_uptrend_data(100.0, 100, 1.0);

    for bar in data {
        classifier.classify(bar);
        let adx = classifier.get_trend_strength();
        assert!(
            adx >= 0.0 && adx <= 100.0,
            "ADX must be in [0, 100], got {:.2}",
            adx
        );
    }
}

#[test]
fn test_directional_indicators_sum() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_uptrend_data(100.0, 50, 0.8);

    for bar in data {
        classifier.classify(bar);
    }

    let (plus_di, minus_di) = classifier.get_directional_indicators();
    if let (Some(plus), Some(minus)) = (plus_di, minus_di) {
        assert!(plus >= 0.0, "+DI must be non-negative");
        assert!(minus >= 0.0, "-DI must be non-negative");
        assert!(
            plus + minus > 0.0,
            "At least one DI should be positive in trending market"
        );
    }
}

#[test]
fn test_plus_di_dominates_uptrend() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_uptrend_data(100.0, 60, 0.7);

    for bar in data {
        classifier.classify(bar);
    }

    let (plus_di, minus_di) = classifier.get_directional_indicators();
    if let (Some(plus), Some(minus)) = (plus_di, minus_di) {
        assert!(
            plus > minus,
            "In uptrend, +DI should dominate: +DI={:.2}, -DI={:.2}",
            plus,
            minus
        );
    }
}

#[test]
fn test_minus_di_dominates_downtrend() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_downtrend_data(100.0, 60, 0.7);

    for bar in data {
        classifier.classify(bar);
    }

    let (plus_di, minus_di) = classifier.get_directional_indicators();
    if let (Some(plus), Some(minus)) = (plus_di, minus_di) {
        assert!(
            minus > plus,
            "In downtrend, -DI should dominate: +DI={:.2}, -DI={:.2}",
            plus,
            minus
        );
    }
}

// =============================================================================
// Unit Tests: Hurst Exponent Validation
// =============================================================================

#[test]
fn test_hurst_trending_series() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_uptrend_data(100.0, 60, 0.8);

    for bar in data {
        let signal = classifier.classify(bar);
        // After sufficient data, check Hurst
        if classifier.bar_count() >= 30 {
            match signal {
                TrendingSignal::StrongTrend { .. } | TrendingSignal::WeakTrend { .. } => {
                    // Trending signals should have Hurst > 0.5 (persistent)
                },
                TrendingSignal::Ranging { hurst, .. } => {
                    if classifier.bar_count() > 40 {
                        // Late in trend, if still ranging, Hurst should be borderline
                        assert!(
                            hurst > 0.4,
                            "Trending series should have Hurst > 0.4, got {:.3}",
                            hurst
                        );
                    }
                },
            }
        }
    }
}

#[test]
fn test_hurst_ranging_series() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_ranging_data(100.0, 60, 2.0);

    for bar in data {
        classifier.classify(bar);
    }

    // Ranging series typically has Hurst ≈ 0.5 (random walk)
    // Due to oscillation, may be slightly mean-reverting (H < 0.5)
    let signal = classifier.classify(create_simple_bar(100.0));
    match signal {
        TrendingSignal::Ranging { hurst, .. } => {
            assert!(
                hurst < 0.7,
                "Ranging series should have Hurst < 0.7, got {:.3}",
                hurst
            );
        },
        _ => {
            // Acceptable if classified as weak trend
        },
    }
}

#[test]
fn test_hurst_mean_reverting() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Create strong mean-reverting series (alternating +/- moves)
    let mut price = 100.0;
    for i in 0..60 {
        if i % 2 == 0 {
            price += 1.5;
        } else {
            price -= 1.5;
        }
        let bar = create_simple_bar(price);
        classifier.classify(bar);
    }

    let signal = classifier.classify(create_simple_bar(price));
    match signal {
        TrendingSignal::Ranging { hurst, .. } => {
            // Mean-reverting should have Hurst < 0.5
            assert!(
                hurst < 0.6,
                "Mean-reverting series should have lower Hurst, got {:.3}",
                hurst
            );
        },
        _ => {
            // May classify as weak trend, acceptable
        },
    }
}

// =============================================================================
// Integration Tests: Classification Logic
// =============================================================================

#[test]
fn test_strong_trend_classification() {
    let mut classifier = TrendingClassifier::new(20.0, 0.5, 50);
    let data = generate_uptrend_data(100.0, 70, 0.8);

    let mut strong_trend_count = 0;
    for (i, bar) in data.into_iter().enumerate() {
        let signal = classifier.classify(bar);
        if i > 40 {
            // After sufficient data
            match signal {
                TrendingSignal::StrongTrend {
                    direction,
                    strength,
                } => {
                    assert_eq!(direction, Direction::Bullish);
                    assert!(strength >= 20.0, "Strong trend should have ADX >= 20");
                    strong_trend_count += 1;
                },
                TrendingSignal::WeakTrend { direction, .. } => {
                    assert_eq!(direction, Direction::Bullish);
                },
                _ => {},
            }
        }
    }

    assert!(
        strong_trend_count > 10,
        "Should detect strong trend in later bars, got {} detections",
        strong_trend_count
    );
}

#[test]
fn test_ranging_classification() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let data = generate_ranging_data(100.0, 60, 1.5);

    let mut ranging_count = 0;
    for (i, bar) in data.into_iter().enumerate() {
        let signal = classifier.classify(bar);
        if i > 30 {
            // After sufficient data
            match signal {
                TrendingSignal::Ranging { .. } => {
                    ranging_count += 1;
                },
                _ => {},
            }
        }
    }

    assert!(
        ranging_count > 15,
        "Should detect ranging market in oscillating data, got {} detections",
        ranging_count
    );
}

#[test]
fn test_weak_trend_classification() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Generate moderate trend (not strong enough for StrongTrend)
    let data = generate_uptrend_data(100.0, 60, 0.3);

    let mut weak_or_ranging_count = 0;
    for (i, bar) in data.into_iter().enumerate() {
        let signal = classifier.classify(bar);
        if i > 30 {
            match signal {
                TrendingSignal::WeakTrend {
                    direction,
                    strength,
                } => {
                    assert_eq!(direction, Direction::Bullish);
                    assert!(strength < 30.0, "Weak trend should have moderate ADX");
                    weak_or_ranging_count += 1;
                },
                TrendingSignal::Ranging { .. } => {
                    weak_or_ranging_count += 1;
                },
                _ => {},
            }
        }
    }

    assert!(
        weak_or_ranging_count > 10,
        "Moderate trend should be classified as weak or ranging"
    );
}

#[test]
fn test_trend_direction_bullish() {
    let mut classifier = TrendingClassifier::new(20.0, 0.5, 50);
    let data = generate_uptrend_data(100.0, 50, 0.8);

    for bar in data {
        classifier.classify(bar);
    }

    let direction = classifier.get_trend_direction();
    assert_eq!(
        direction,
        Some(Direction::Bullish),
        "Should detect bullish trend"
    );
}

#[test]
fn test_trend_direction_bearish() {
    let mut classifier = TrendingClassifier::new(20.0, 0.5, 50);
    let data = generate_downtrend_data(100.0, 50, 0.8);

    for bar in data {
        classifier.classify(bar);
    }

    let direction = classifier.get_trend_direction();
    assert_eq!(
        direction,
        Some(Direction::Bearish),
        "Should detect bearish trend"
    );
}

// =============================================================================
// Edge Cases & Robustness Tests
// =============================================================================

#[test]
fn test_zero_volatility_data() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Flat prices (zero volatility)
    for _ in 0..50 {
        let bar = create_simple_bar(100.0);
        let signal = classifier.classify(bar);
        match signal {
            TrendingSignal::Ranging { adx, hurst } => {
                assert_eq!(adx, 0.0, "Zero volatility should have ADX = 0");
                assert!(
                    (hurst - 0.5).abs() < 0.1,
                    "Zero volatility should have Hurst ≈ 0.5"
                );
            },
            _ => panic!("Zero volatility should be classified as Ranging"),
        }
    }
}

#[test]
fn test_extreme_price_spike() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Normal data followed by extreme spike
    let mut data = generate_uptrend_data(100.0, 40, 0.5);
    data.push(create_simple_bar(200.0)); // 100% spike
    data.extend(generate_uptrend_data(200.0, 10, 0.5));

    for bar in data {
        let signal = classifier.classify(bar);
        // Should not panic, should handle gracefully
        match signal {
            TrendingSignal::StrongTrend { strength, .. }
            | TrendingSignal::WeakTrend { strength, .. } => {
                assert!(strength <= 100.0, "ADX should be capped at 100");
            },
            TrendingSignal::Ranging { adx, .. } => {
                assert!(adx <= 100.0, "ADX should be capped at 100");
            },
        }
    }
}

#[test]
fn test_negative_prices() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Some instruments can have negative prices (e.g., oil futures)
    let mut price = -10.0;
    for _ in 0..50 {
        price -= 0.5;
        let bar = OHLCVBar {
            timestamp: Utc::now(),
            open: price,
            high: price + 0.2,
            low: price - 0.2,
            close: price,
            volume: 1000.0,
        };
        classifier.classify(bar); // Should not panic
    }

    // Should still detect downtrend
    let direction = classifier.get_trend_direction();
    assert_eq!(
        direction,
        Some(Direction::Bearish),
        "Should detect bearish trend in negative prices"
    );
}

#[test]
fn test_minimum_data_requirement() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Single bar
    let signal1 = classifier.classify(create_simple_bar(100.0));
    assert!(matches!(signal1, TrendingSignal::Ranging { .. }));

    // Two bars - ADX should initialize
    let signal2 = classifier.classify(create_simple_bar(101.0));
    match signal2 {
        TrendingSignal::Ranging { adx, .. } => {
            assert!(adx >= 0.0, "ADX should be non-negative after 2 bars");
        },
        _ => panic!("Expected Ranging signal with 2 bars"),
    }
}

// =============================================================================
// Performance Tests
// =============================================================================

#[test]
fn test_performance_target() {
    use std::time::Instant;

    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Warm up with initial data
    let warmup_data = generate_uptrend_data(100.0, 50, 0.5);
    for bar in warmup_data {
        classifier.classify(bar);
    }

    // Measure incremental update performance
    let iterations = 1000;
    let start = Instant::now();

    for i in 0..iterations {
        let bar = create_simple_bar(100.0 + i as f64 * 0.1);
        classifier.classify(bar);
    }

    let elapsed = start.elapsed();
    let avg_time_us = elapsed.as_micros() as f64 / iterations as f64;

    println!(
        "Average classification time: {:.2} μs per bar (target: <150 μs)",
        avg_time_us
    );
    assert!(
        avg_time_us < 200.0,
        "Classification should be <200μs per bar, got {:.2}μs",
        avg_time_us
    );
}

#[test]
fn test_memory_efficiency() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 100);

    // Add 1000 bars (10x lookback)
    for i in 0..1000 {
        let bar = create_simple_bar(100.0 + i as f64 * 0.1);
        classifier.classify(bar);
    }

    // Verify lookback window is maintained (no unbounded growth)
    assert_eq!(
        classifier.bar_count(),
        100,
        "Lookback window should be capped at 100 bars"
    );
}

// =============================================================================
// Real Data Simulation Tests (ES.FUT-like patterns)
// =============================================================================

#[test]
fn test_es_fut_volatility_spike_simulation() {
    // Simulate January 2024 ES.FUT volatility spike pattern
    // Normal trading → Sharp selloff → Recovery
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Phase 1: Normal ranging (20 bars)
    let phase1 = generate_ranging_data(4500.0, 20, 10.0);
    for bar in phase1 {
        classifier.classify(bar);
    }

    // Phase 2: Sharp downtrend (15 bars, -2% per bar)
    let phase2 = generate_downtrend_data(4500.0, 15, 50.0);
    let mut bearish_count = 0;
    for bar in phase2 {
        let signal = classifier.classify(bar);
        match signal {
            TrendingSignal::StrongTrend {
                direction: Direction::Bearish,
                ..
            }
            | TrendingSignal::WeakTrend {
                direction: Direction::Bearish,
                ..
            } => {
                bearish_count += 1;
            },
            _ => {},
        }
    }

    assert!(
        bearish_count > 5,
        "Should detect bearish trend during selloff, got {} detections",
        bearish_count
    );

    // Phase 3: Recovery uptrend (20 bars)
    let phase3 = generate_uptrend_data(4200.0, 20, 30.0);
    let mut bullish_count = 0;
    for bar in phase3 {
        let signal = classifier.classify(bar);
        match signal {
            TrendingSignal::StrongTrend {
                direction: Direction::Bullish,
                ..
            }
            | TrendingSignal::WeakTrend {
                direction: Direction::Bullish,
                ..
            } => {
                bullish_count += 1;
            },
            _ => {},
        }
    }

    assert!(
        bullish_count > 5,
        "Should detect bullish trend during recovery, got {} detections",
        bullish_count
    );
}

#[test]
fn test_intraday_choppy_pattern() {
    // Simulate choppy intraday ES.FUT trading (low ADX, low Hurst)
    let mut classifier = TrendingClassifier::new(20.0, 0.5, 50);

    let base_price = 4500.0;
    let mut ranging_count = 0;

    for i in 0..60 {
        // Random walk with small moves
        let noise = ((i as f64 * 0.3).sin() + (i as f64 * 0.7).cos()) * 5.0;
        let price = base_price + noise;
        let bar = create_simple_bar(price);
        let signal = classifier.classify(bar);

        if i > 30 {
            match signal {
                TrendingSignal::Ranging { .. } => {
                    ranging_count += 1;
                },
                _ => {},
            }
        }
    }

    assert!(
        ranging_count > 15,
        "Choppy intraday pattern should be mostly ranging, got {} ranging detections",
        ranging_count
    );
}

// =============================================================================
// Regression Tests (prevent future bugs)
// =============================================================================

#[test]
fn test_atr_initialization() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    classifier.classify(create_simple_bar(100.0));
    classifier.classify(create_simple_bar(102.0));

    assert!(
        classifier.get_atr().is_some(),
        "ATR should initialize after 2 bars"
    );
    assert!(
        classifier.get_atr().unwrap() > 0.0,
        "ATR should be positive with price movement"
    );
}

#[test]
fn test_wilder_smoothing_constant() {
    let classifier = TrendingClassifier::new(25.0, 0.55, 50);
    let expected_alpha = 1.0 / 14.0; // Wilder's 14-period
    assert!(
        (classifier.get_alpha_wilder() - expected_alpha).abs() < 1e-10,
        "Wilder's alpha should be 1/14"
    );
}

#[test]
fn test_state_persistence() {
    let mut classifier = TrendingClassifier::new(25.0, 0.55, 50);

    // Add 30 bars
    for i in 0..30 {
        classifier.classify(create_simple_bar(100.0 + i as f64));
    }

    let adx_before = classifier.get_trend_strength();
    let (plus_di_before, minus_di_before) = classifier.get_directional_indicators();

    // Add one more bar
    classifier.classify(create_simple_bar(130.0));

    let adx_after = classifier.get_trend_strength();
    let (plus_di_after, minus_di_after) = classifier.get_directional_indicators();

    // State should evolve, not reset
    assert_ne!(
        adx_before, adx_after,
        "ADX should update incrementally, not reset"
    );
    assert!(
        plus_di_before.is_some() && plus_di_after.is_some(),
        "+DI should persist"
    );
    assert!(
        minus_di_before.is_some() && minus_di_after.is_some(),
        "-DI should persist"
    );
}