// ============================================================================
// RSI (Relative Strength Index) Unit Tests - Agent A1 - TDD Approach
// ============================================================================

#[test]
fn test_rsi_zero_gain_only_losses() {
    // Test RSI calculation when only losses occur (no gains)
    // Expected: RSI = 0 (oversold extreme)
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize with stable price
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create 14 periods of consistent losses (downtrend)
    for i in 0..14 {
        let price = 4500.0 - ((i + 1) as f64 * 5.0); // -5 per period
        extractor.extract_features(price, 100_000.0, timestamp);
    }

    // Extract features after 14 loss periods
    let features = extractor.extract_features(4430.0, 100_000.0, timestamp);

    // RSI should be at appropriate index in feature vector
    // With only losses, RSI should be close to 0 (normalized to 0.0)
    if features.len() > 20 {
        let rsi = features[20];  // Adjust index based on actual feature order

        println!("RSI (only losses): {}", rsi);

        assert!(
            rsi >= 0.0 && rsi <= 0.1,
            "RSI should be near 0 with only losses, got {}",
            rsi
        );
    }
}

#[test]
fn test_rsi_zero_loss_only_gains() {
    // Test RSI calculation when only gains occur (no losses)
    // Expected: RSI = 100 (overbought extreme)
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize with stable price
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create 14 periods of consistent gains (uptrend)
    for i in 0..14 {
        let price = 4500.0 + ((i + 1) as f64 * 5.0); // +5 per period
        extractor.extract_features(price, 100_000.0, timestamp);
    }

    // Extract features after 14 gain periods
    let features = extractor.extract_features(4575.0, 100_000.0, timestamp);

    // With only gains, RSI should be close to 100 (normalized to 1.0)
    if features.len() > 20 {
        let rsi = features[20];

        println!("RSI (only gains): {}", rsi);

        assert!(
            rsi >= 0.9 && rsi <= 1.0,
            "RSI should be near 1.0 (100) with only gains, got {}",
            rsi
        );
    }
}

#[test]
fn test_rsi_mixed_gains_and_losses() {
    // Test RSI with mixed gains and losses (realistic market)
    // Expected: RSI in range [30, 70] for balanced market
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize with stable price
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create mixed gains and losses over 14 periods
    let price_changes = vec![
        5.0, -3.0, 7.0, -2.0, 4.0, -6.0, 8.0,  // First 7 periods
        -4.0, 3.0, -5.0, 6.0, -2.0, 5.0, -3.0, // Next 7 periods
    ];

    let mut current_price = 4500.0;
    for change in price_changes {
        current_price += change;
        extractor.extract_features(current_price, 100_000.0, timestamp);
    }

    // Extract features after mixed period
    let features = extractor.extract_features(current_price + 2.0, 100_000.0, timestamp);

    if features.len() > 20 {
        let rsi = features[20];

        println!("RSI (mixed): {} (raw RSI: {})", rsi, rsi * 100.0);

        // RSI should be in neutral range [0.3, 0.7] for mixed market
        assert!(
            rsi >= 0.0 && rsi <= 1.0,
            "RSI should be normalized to [0, 1], got {}",
            rsi
        );

        assert!(
            rsi.is_finite(),
            "RSI should be finite with mixed gains/losses, got {}",
            rsi
        );
    }
}

#[test]
fn test_rsi_all_zero_changes() {
    // Test RSI when price doesn't change (flat market)
    // Expected: RSI = 50 (neutral) since avg_gain = avg_loss = 0
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize with stable price
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create 14 periods with no price change
    for _ in 0..15 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    let features = extractor.extract_features(4500.0, 100_000.0, timestamp);

    if features.len() > 20 {
        let rsi = features[20];

        println!("RSI (no change): {}", rsi);

        // With no change, RSI should be 50 (neutral) = 0.5 normalized
        assert!(
            (rsi - 0.5).abs() < 0.1,
            "RSI should be near 0.5 (neutral) with no price change, got {}",
            rsi
        );
    }
}

#[test]
fn test_rsi_edge_case_single_large_loss() {
    // Test RSI with one very large loss among small gains
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // 13 small gains, then 1 large loss
    let mut current_price = 4500.0;
    for _ in 0..13 {
        current_price += 1.0; // Small gains
        extractor.extract_features(current_price, 100_000.0, timestamp);
    }

    // Large loss
    current_price -= 50.0;
    extractor.extract_features(current_price, 100_000.0, timestamp);

    let features = extractor.extract_features(current_price + 1.0, 100_000.0, timestamp);

    if features.len() > 20 {
        let rsi = features[20];

        println!("RSI (large loss): {}", rsi);

        // RSI should be valid and reflect the large loss
        assert!(
            rsi >= 0.0 && rsi <= 1.0,
            "RSI out of range with large loss: {}",
            rsi
        );

        // Should be below neutral due to large loss impact
        assert!(
            rsi < 0.6,
            "RSI should be below neutral with large loss, got {}",
            rsi
        );
    }
}

#[test]
fn test_rsi_edge_case_insufficient_periods() {
    // Test RSI calculation with < 14 periods (insufficient data)
    // Expected: RSI = 0.5 (neutral/default) until 14 periods accumulated
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Only 5 periods (insufficient for RSI)
    for i in 0..5 {
        let price = 4500.0 + (i as f64 * 2.0);
        let features = extractor.extract_features(price, 100_000.0, timestamp);

        // RSI should default to neutral (0.5) with insufficient data
        if features.len() > 20 {
            let rsi = features[20];
            assert!(
                (rsi - 0.5).abs() < 0.1,
                "RSI should default to ~0.5 with insufficient data, got {}",
                rsi
            );
        }
    }
}

#[test]
fn test_rsi_incremental_update_efficiency() {
    // Test that RSI uses O(1) incremental update (no recalculation)
    // Verify by checking calculation time remains constant
    use std::time::Instant;

    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Warm up with 50 bars
    for i in 0..50 {
        let price = 4500.0 + (i as f64 * 0.5);
        extractor.extract_features(price, 100_000.0, timestamp);
    }

    // Benchmark RSI calculation time over 100 bars
    let mut total_time = std::time::Duration::ZERO;

    for i in 0..100 {
        let price = 4525.0 + (i as f64 * 0.25);

        let start = Instant::now();
        let _features = extractor.extract_features(price, 100_000.0, timestamp);
        let elapsed = start.elapsed();

        total_time += elapsed;
    }

    let avg_time = total_time / 100;
    let avg_micros = avg_time.as_micros();

    println!("Average RSI calculation time: {}μs", avg_micros);

    // Target: <5μs per RSI update (O(1) incremental)
    assert!(
        avg_micros < 50_000, // Use same threshold as overall feature extraction
        "RSI calculation too slow: {}μs (indicates non-incremental update)",
        avg_micros
    );
}

#[test]
fn test_rsi_normalization_range() {
    // Test that RSI is properly normalized to [0, 1] range
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Test with extreme market conditions
    let test_scenarios = vec![
        // (description, price_sequence)
        ("Strong uptrend", (0..20).map(|i| 4500.0 + (i as f64 * 10.0)).collect::<Vec<f64>>()),
        ("Strong downtrend", (0..20).map(|i| 4500.0 - (i as f64 * 10.0)).collect::<Vec<f64>>()),
        ("Choppy market", (0..20).map(|i| 4500.0 + ((i as f64 * 2.0).sin() * 20.0)).collect::<Vec<f64>>()),
    ];

    for (description, prices) in test_scenarios {
        let mut test_extractor = MLFeatureExtractor::new(50);

        // Initialize
        for _ in 0..10 {
            test_extractor.extract_features(4500.0, 100_000.0, timestamp);
        }

        // Process scenario
        for price in prices {
            let features = test_extractor.extract_features(price, 100_000.0, timestamp);

            if features.len() > 20 {
                let rsi = features[20];

                assert!(
                    rsi >= 0.0 && rsi <= 1.0,
                    "RSI out of [0, 1] range in '{}': {}",
                    description,
                    rsi
                );

                assert!(
                    rsi.is_finite(),
                    "RSI not finite in '{}': {}",
                    description,
                    rsi
                );
            }
        }

        println!("✓ RSI normalization validated for: {}", description);
    }
}

#[test]
fn test_rsi_oversold_overbought_detection() {
    // Test RSI correctly identifies oversold (<30) and overbought (>70) conditions
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create oversold condition (strong downtrend)
    for i in 0..20 {
        let price = 4500.0 - (i as f64 * 8.0);
        extractor.extract_features(price, 100_000.0, timestamp);
    }

    let features_oversold = extractor.extract_features(4340.0, 100_000.0, timestamp);

    if features_oversold.len() > 20 {
        let rsi_oversold = features_oversold[20];

        println!("RSI oversold: {} (raw: {})", rsi_oversold, rsi_oversold * 100.0);

        // RSI should be < 0.3 (raw RSI < 30) for oversold
        assert!(
            rsi_oversold < 0.4,
            "RSI should indicate oversold (<0.3), got {}",
            rsi_oversold
        );
    }

    // Create overbought condition (strong uptrend)
    let mut extractor2 = MLFeatureExtractor::new(50);
    for _ in 0..10 {
        extractor2.extract_features(4500.0, 100_000.0, timestamp);
    }

    for i in 0..20 {
        let price = 4500.0 + (i as f64 * 8.0);
        extractor2.extract_features(price, 100_000.0, timestamp);
    }

    let features_overbought = extractor2.extract_features(4660.0, 100_000.0, timestamp);

    if features_overbought.len() > 20 {
        let rsi_overbought = features_overbought[20];

        println!("RSI overbought: {} (raw: {})", rsi_overbought, rsi_overbought * 100.0);

        // RSI should be > 0.7 (raw RSI > 70) for overbought
        assert!(
            rsi_overbought > 0.6,
            "RSI should indicate overbought (>0.7), got {}",
            rsi_overbought
        );
    }
}

#[test]
fn test_rsi_ema_smoothing() {
    // Test that RSI uses exponential moving average for smooth transitions
    // Wilder's smoothing: new_avg = (prev_avg * 13 + current_value) / 14
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Initialize
    for _ in 0..10 {
        extractor.extract_features(4500.0, 100_000.0, timestamp);
    }

    // Create initial 14-period data for RSI
    for i in 0..14 {
        let price = 4500.0 + ((i % 2) as f64 * 5.0); // Alternating +5, 0
        extractor.extract_features(price, 100_000.0, timestamp);
    }

    // Get first RSI value
    let features1 = extractor.extract_features(4505.0, 100_000.0, timestamp);

    if features1.len() > 20 {
        let rsi1 = features1[20];

        // Add one more gain
        let features2 = extractor.extract_features(4510.0, 100_000.0, timestamp);
        let rsi2 = features2[20];

        // RSI should change smoothly (not jump drastically)
        let rsi_change = (rsi2 - rsi1).abs();

        println!("RSI change: {} (from {} to {})", rsi_change, rsi1, rsi2);

        // With EMA smoothing, change should be gradual (<0.1)
        assert!(
            rsi_change < 0.15,
            "RSI change too abrupt ({}), suggests no EMA smoothing",
            rsi_change
        );
    }
}

#[test]
fn test_rsi_feature_count_update() {
    // Verify that adding RSI increases feature count appropriately
    let mut extractor = MLFeatureExtractor::new(50);
    let timestamp = Utc::now();

    // Build up sufficient history
    for i in 0..60 {
        let price = 4500.0 + (i as f64 * 0.25);
        let volume = 100_000.0;

        let features = extractor.extract_features(price, volume, timestamp);

        if i >= 50 {
            // After RSI implementation, verify feature count is correct
            println!("Feature count at iteration {}: {}", i, features.len());

            // This test will need adjustment based on actual feature count after RSI implementation
            assert!(
                features.len() >= 20,
                "Expected at least 20 features with RSI, got {} at iteration {}",
                features.len(),
                i
            );
        }
    }
}