foxhunt/ml/tests/dqn_edge_cases_test.rs

//! DQN Edge Case Tests
//!
//! Comprehensive edge case testing for Deep Q-Learning Network:
//! - Experience buffer edge cases
//! - Replay buffer overflow/underflow
//! - Network gradient edge cases
//! - Reward calculation edge cases
//! - Action selection edge cases
//! - State transition edge cases

#![allow(unused_crate_dependencies)]

use ml::dqn::{
    DQNConfig, Experience, ReplayBuffer, ReplayBufferConfig,
    TradingAction, TradingState,
};
use std::path::PathBuf;

/// Helper to create a test path for replay buffer
fn test_buffer_path() -> PathBuf {
    PathBuf::from("/tmp/test_replay_buffer")
}

/// Test: Replay buffer - empty buffer handling
#[test]
fn test_replay_buffer_empty() {
    let config = ReplayBufferConfig {
        capacity: 1000,
        batch_size: 32,
        min_experiences: 100,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    // Empty buffer should have zero size
    let stats = buffer.stats();
    assert_eq!(stats.size, 0);
    assert_eq!(stats.capacity, 1000);
    assert_eq!(stats.experiences_added, 0);

    // Cannot sample from empty buffer
    let sample_result = buffer.sample(Some(32));
    assert!(
        sample_result.is_err(),
        "Should not be able to sample from empty buffer"
    );
}

/// Test: Replay buffer - single experience
#[test]
fn test_replay_buffer_single_experience() {
    let config = ReplayBufferConfig {
        capacity: 1000,
        batch_size: 32,
        min_experiences: 1, // Allow sampling with just 1 experience
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    // Create minimal experience with vector state
    let state = vec![100.0, 101.0, 99.5]; // Simple price features
    let next_state = vec![101.0, 102.0, 100.0];

    let experience = Experience::new(
        state.clone(),
        TradingAction::Hold.to_int(),
        0.0,
        next_state.clone(),
        false,
    );

    buffer.push(experience).unwrap();

    // Buffer should have one experience
    let stats = buffer.stats();
    assert_eq!(stats.size, 1);
    assert_eq!(stats.experiences_added, 1);
}

/// Test: Replay buffer - capacity overflow
#[test]
fn test_replay_buffer_capacity_overflow() {
    let config = ReplayBufferConfig {
        capacity: 10, // Small capacity
        batch_size: 5,
        min_experiences: 5,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    // Create dummy state
    let state = vec![100.0];

    // Add more experiences than capacity
    for i in 0..20 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Buffer should not exceed capacity
    let stats = buffer.stats();
    assert_eq!(stats.size, 10, "Buffer should cap at capacity");
    assert_eq!(
        stats.capacity, 10,
        "Capacity should remain unchanged"
    );
    assert_eq!(
        stats.experiences_added, 20,
        "Should track total additions"
    );
}

/// Test: Replay buffer - batch size larger than buffer
#[test]
fn test_replay_buffer_batch_size_exceeds_buffer() {
    let config = ReplayBufferConfig {
        capacity: 1000,
        batch_size: 32,
        min_experiences: 5,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    // Add only 5 experiences
    let state = vec![100.0];

    for i in 0..5 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Try to sample batch larger than buffer size
    let sample_result = buffer.sample(Some(32));
    assert!(
        sample_result.is_err(),
        "Should not be able to sample more than buffer size"
    );
}

/// Test: Replay buffer - exact batch size sampling
#[test]
fn test_replay_buffer_exact_batch_sampling() {
    let config = ReplayBufferConfig {
        capacity: 1000,
        batch_size: 32,
        min_experiences: 32,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    let state = vec![100.0];

    // Add exactly 32 experiences
    for i in 0..32 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Sample exactly the buffer size
    let sample_result = buffer.sample(Some(32));
    assert!(
        sample_result.is_ok(),
        "Should be able to sample exact buffer size"
    );

    let batch = sample_result.unwrap();
    assert_eq!(batch.batch_size, 32, "Batch should contain all experiences");
}

/// Test: Replay buffer stats - initial state
#[test]
fn test_replay_buffer_stats_initial() {
    let config = ReplayBufferConfig {
        capacity: 500,
        batch_size: 32,
        min_experiences: 100,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();
    let stats = buffer.stats();

    assert_eq!(stats.size, 0);
    assert_eq!(stats.capacity, 500);
    assert_eq!(stats.experiences_added, 0);
}

/// Test: Replay buffer stats - after additions
#[test]
fn test_replay_buffer_stats_after_additions() {
    let config = ReplayBufferConfig {
        capacity: 100,
        batch_size: 32,
        min_experiences: 10,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    let state = vec![100.0];

    // Add 50 experiences
    for i in 0..50 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    let stats = buffer.stats();
    assert_eq!(stats.size, 50);
    assert_eq!(stats.experiences_added, 50);
}

/// Test: DQN config - default values
#[test]
fn test_dqn_config_defaults() {
    let config = DQNConfig::default();

    // Verify reasonable defaults
    assert!(config.learning_rate > 0.0);
    assert!(config.gamma > 0.0 && config.gamma <= 1.0);
    assert!(config.epsilon_start > 0.0);
    assert!(config.epsilon_end >= 0.0);
    assert!(config.epsilon_decay > 0.0);
    assert!(config.batch_size > 0);
    assert!(config.target_update_freq > 0);
}

/// Test: DQN config - custom configuration
#[test]
fn test_dqn_config_customization() {
    let mut config = DQNConfig::default();

    config.learning_rate = 0.0001;
    config.gamma = 0.99;
    config.epsilon_start = 1.0;
    config.epsilon_end = 0.01;
    config.epsilon_decay = 0.995;
    config.batch_size = 64;
    config.target_update_freq = 1000;

    assert_eq!(config.learning_rate, 0.0001);
    assert_eq!(config.gamma, 0.99);
    assert_eq!(config.epsilon_start, 1.0);
    assert_eq!(config.epsilon_end, 0.01);
    assert_eq!(config.epsilon_decay, 0.995);
    assert_eq!(config.batch_size, 64);
    assert_eq!(config.target_update_freq, 1000);
}

/// Test: DQN config - gamma bounds
#[test]
fn test_dqn_config_gamma_bounds() {
    let config = DQNConfig::default();

    // Gamma should be in (0, 1]
    assert!(config.gamma > 0.0);
    assert!(config.gamma <= 1.0);
}

/// Test: DQN config - epsilon decay bounds
#[test]
fn test_dqn_config_epsilon_bounds() {
    let config = DQNConfig::default();

    // Epsilon start should be >= epsilon end
    assert!(config.epsilon_start >= config.epsilon_end);

    // Epsilon values should be in [0, 1]
    assert!(config.epsilon_start >= 0.0 && config.epsilon_start <= 1.0);
    assert!(config.epsilon_end >= 0.0 && config.epsilon_end <= 1.0);

    // Epsilon decay should be in (0, 1]
    assert!(config.epsilon_decay > 0.0);
    assert!(config.epsilon_decay <= 1.0);
}

/// Test: Experience - creation and field access
#[test]
fn test_experience_creation() {
    let state = vec![100.0, 101.0, 99.5, 1000.0, 1500.0, 2000.0];
    let next_state = vec![101.0, 102.0, 100.0, 1100.0, 1600.0, 2100.0];

    let experience = Experience::new(
        state.clone(),
        TradingAction::Buy.to_int(),
        100.0,
        next_state.clone(),
        false,
    );

    // Verify all fields
    assert_eq!(experience.state, state);
    assert_eq!(experience.action, TradingAction::Buy.to_int());
    assert_eq!(experience.reward_f32(), 100.0);
    assert_eq!(experience.next_state, next_state);
    assert!(!experience.done);
}

/// Test: Experience - terminal state
#[test]
fn test_experience_terminal_state() {
    let state = vec![100.0, 0.0]; // Bankrupt state

    let experience = Experience::new(
        state.clone(),
        TradingAction::Hold.to_int(),
        -10000.0, // Large negative reward
        state.clone(),
        true, // Terminal state
    );

    assert!(experience.done, "Terminal state should have done=true");
    assert!(experience.reward_f32() < 0.0, "Terminal state often has negative reward");
}

/// Test: Trading action variants
#[test]
fn test_trading_action_variants() {
    // Test all action types
    let hold = TradingAction::Hold;
    let buy = TradingAction::Buy;
    let sell = TradingAction::Sell;

    // Verify integer conversions
    assert_eq!(buy.to_int(), 0);
    assert_eq!(sell.to_int(), 1);
    assert_eq!(hold.to_int(), 2);

    // Verify reverse conversion
    assert_eq!(TradingAction::from_int(0), Some(TradingAction::Buy));
    assert_eq!(TradingAction::from_int(1), Some(TradingAction::Sell));
    assert_eq!(TradingAction::from_int(2), Some(TradingAction::Hold));
    assert_eq!(TradingAction::from_int(3), None);
}

/// Test: Trading state - default state
#[test]
fn test_trading_state_default() {
    let state = TradingState::default();

    // Default state should have 16 features in each category
    assert_eq!(state.price_features.len(), 16);
    assert_eq!(state.technical_indicators.len(), 16);
    assert_eq!(state.market_features.len(), 16);
    assert_eq!(state.portfolio_features.len(), 16);
    assert_eq!(state.dimension(), 64);
}

/// Test: Trading state - custom state
#[test]
fn test_trading_state_custom() {
    let state = TradingState {
        price_features: vec![100.0, 200.0, 50.0],
        technical_indicators: vec![0.5, 0.7],
        market_features: vec![1000.0, 2000.0],
        portfolio_features: vec![10.0, -5.0, 20.0],
    };

    assert_eq!(state.price_features.len(), 3);
    assert_eq!(state.technical_indicators.len(), 2);
    assert_eq!(state.market_features.len(), 2);
    assert_eq!(state.portfolio_features.len(), 3);
    assert_eq!(state.dimension(), 10);

    // Verify specific values
    assert_eq!(state.price_features[0], 100.0);
    assert_eq!(state.price_features[1], 200.0);
    assert_eq!(state.price_features[2], 50.0);

    assert_eq!(state.portfolio_features[0], 10.0);
    assert_eq!(state.portfolio_features[1], -5.0);
    assert_eq!(state.portfolio_features[2], 20.0);
}

/// Test: Trading state - to_vector conversion
#[test]
fn test_trading_state_to_vector() {
    let state = TradingState {
        price_features: vec![1.0, 2.0],
        technical_indicators: vec![3.0, 4.0],
        market_features: vec![5.0, 6.0],
        portfolio_features: vec![7.0, 8.0],
    };

    let vec = state.to_vector();
    assert_eq!(vec.len(), 8);
    assert_eq!(vec, vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]);
}

/// Test: Replay buffer config - edge case capacities
#[test]
fn test_replay_buffer_config_edge_capacities() {
    // Minimum capacity
    let config_small = ReplayBufferConfig {
        capacity: 1,
        batch_size: 1,
        min_experiences: 1,
    };
    assert_eq!(config_small.capacity, 1);

    // Large capacity
    let config_large = ReplayBufferConfig {
        capacity: 1_000_000,
        batch_size: 32,
        min_experiences: 1000,
    };
    assert_eq!(config_large.capacity, 1_000_000);
}

/// Test: Experience - validity checks
#[test]
fn test_experience_validity() {
    // Valid experience
    let valid_exp = Experience::new(
        vec![1.0, 2.0],
        0,
        1.0,
        vec![1.0, 2.0],
        false,
    );
    assert!(valid_exp.is_valid());

    // Invalid experience - empty state
    let invalid_exp = Experience::new(
        vec![],
        0,
        1.0,
        vec![1.0, 2.0],
        false,
    );
    assert!(!invalid_exp.is_valid());

    // Invalid experience - mismatched state dimensions
    let invalid_exp2 = Experience::new(
        vec![1.0, 2.0],
        0,
        1.0,
        vec![1.0],
        false,
    );
    assert!(!invalid_exp2.is_valid());
}

/// Test: Replay buffer - sample size validation
#[test]
fn test_replay_buffer_sample_size() {
    let config = ReplayBufferConfig {
        capacity: 100,
        batch_size: 32,
        min_experiences: 50,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    let state = vec![100.0];

    // Add experiences
    for i in 0..60 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Should be able to sample with default batch size
    let sample_result = buffer.sample(None);
    assert!(sample_result.is_ok(), "Should sample with default batch size");

    // Should be able to sample with custom batch size
    let sample_result2 = buffer.sample(Some(16));
    assert!(sample_result2.is_ok(), "Should sample with custom batch size");
    assert_eq!(sample_result2.unwrap().batch_size, 16);
}

/// Test: DQN config - state and action dimensions
#[test]
fn test_dqn_config_dimensions() {
    let config = DQNConfig::default();

    // Default should have 52-dimensional state (4 prices + 16 technical + 16 microstructure + 16 portfolio)
    assert_eq!(config.state_dim, 52);

    // Should have 3 actions (Buy, Sell, Hold)
    assert_eq!(config.num_actions, 3);

    // Hidden dimensions should be non-empty
    assert!(!config.hidden_dims.is_empty());
}

/// Test: Replay buffer - minimum experiences threshold
#[test]
fn test_replay_buffer_min_experiences() {
    let config = ReplayBufferConfig {
        capacity: 1000,
        batch_size: 32,
        min_experiences: 100,
    };

    let buffer = ReplayBuffer::new(&test_buffer_path(), config).unwrap();

    let state = vec![100.0];

    // Add fewer than minimum experiences
    for i in 0..50 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Should not be able to sample
    let sample_result = buffer.sample(Some(32));
    assert!(
        sample_result.is_err(),
        "Should not sample with insufficient experiences"
    );

    // Add more experiences
    for i in 50..100 {
        let experience = Experience::new(
            state.clone(),
            TradingAction::Hold.to_int(),
            i as f32,
            state.clone(),
            false,
        );
        buffer.push(experience).unwrap();
    }

    // Now should be able to sample
    let sample_result2 = buffer.sample(Some(32));
    assert!(
        sample_result2.is_ok(),
        "Should sample with sufficient experiences"
    );
}