foxhunt/ml/tests/dqn_adaptive_buffer_test.rs

//! Adaptive Replay Buffer Sizing Tests
//!
//! Validates adaptive buffer capacity adjustment based on epsilon decay.
//! Tests memory savings, data preservation, and multi-epoch growth patterns.

use ml::dqn::{Experience, WorkingDQN, WorkingDQNConfig};
use ml::dqn::replay_buffer_type::ReplayBufferType;

/// BASE_CAPACITY constant (must match replay_buffer_type.rs)
const BASE_CAPACITY: usize = 10_000;

/// Helper: Create test experience
fn create_test_experience(reward: f32) -> Experience {
    let state = vec![0.1, 0.2, 0.3, 0.4, 0.5];
    let next_state = vec![0.2, 0.3, 0.4, 0.5, 0.6];
    Experience::new(state, 0, reward, next_state, false)
}

#[test]
fn test_adaptive_capacity_formula() {
    // Test 1: Verify capacity calculation at key epsilon values
    let mut buffer = ReplayBufferType::new_uniform(100_000);
    
    // ε=1.0 (epoch 1): Should be near BASE_CAPACITY (10K)
    let capacity_at_1_0 = buffer.capacity_at_threshold(1.0, 100_000);
    assert_eq!(capacity_at_1_0, 10_000, "ε=1.0 should give BASE_CAPACITY");
    
    // ε=0.5 (mid-training): Should be 55K (10K + 90K × 0.5)
    let capacity_at_0_5 = buffer.capacity_at_threshold(0.5, 100_000);
    assert_eq!(capacity_at_0_5, 55_000, "ε=0.5 should give 55K capacity");
    
    // ε=0.05 (late training): Should be 95.5K (10K + 90K × 0.95)
    let capacity_at_0_05 = buffer.capacity_at_threshold(0.05, 100_000);
    assert_eq!(capacity_at_0_05, 95_500, "ε=0.05 should give 95.5K capacity");
    
    // ε=0.0 (fully exploited): Should be 100K (max)
    let capacity_at_0_0 = buffer.capacity_at_threshold(0.0, 100_000);
    assert_eq!(capacity_at_0_0, 100_000, "ε=0.0 should give max capacity");
}

#[test]
fn test_threshold_based_resize() -> Result<(), Box<dyn std::error::Error>> {
    // Test 2: Confirm resize only at thresholds (0.9, 0.7, 0.5, 0.3, 0.1)
    // FIX: Initialize at BASE_CAPACITY instead of max_capacity
    let mut buffer = ReplayBufferType::new_uniform(BASE_CAPACITY);
    
    // Initial state: No resize (ε=1.0, capacity=10K)
    let resized = buffer.adaptive_resize(1.0, 100_000)?;
    assert!(!resized, "Should not resize at ε=1.0 (starting state)");
    assert_eq!(buffer.get_capacity(), 10_000);
    
    // Cross first threshold (ε=0.9)
    let resized = buffer.adaptive_resize(0.9, 100_000)?;
    assert!(resized, "Should resize when crossing ε=0.9 threshold");
    let capacity_after_0_9 = buffer.get_capacity();
    assert!(capacity_after_0_9 > 10_000, "Capacity should increase");
    
    // Micro-step (ε=0.89): No resize (not at threshold)
    let resized = buffer.adaptive_resize(0.89, 100_000)?;
    assert!(!resized, "Should not resize for micro-step ε=0.89");
    assert_eq!(buffer.get_capacity(), capacity_after_0_9, "Capacity unchanged");
    
    // Cross second threshold (ε=0.7)
    let resized = buffer.adaptive_resize(0.7, 100_000)?;
    assert!(resized, "Should resize when crossing ε=0.7 threshold");
    let capacity_after_0_7 = buffer.get_capacity();
    assert!(capacity_after_0_7 > capacity_after_0_9, "Capacity should increase further");
    
    // Cross third threshold (ε=0.5)
    let resized = buffer.adaptive_resize(0.5, 100_000)?;
    assert!(resized, "Should resize when crossing ε=0.5 threshold");
    assert_eq!(buffer.get_capacity(), 55_000, "ε=0.5 → 55K capacity");
    
    Ok(())
}

#[test]
fn test_uniform_buffer_resize_data_preservation() -> Result<(), Box<dyn std::error::Error>> {
    // Test 3: Validate data preservation during uniform resize
    let mut buffer = ReplayBufferType::new_uniform(50_000);
    
    // Add 1000 experiences
    for i in 0..1000 {
        buffer.add(create_test_experience(i as f32))?;
    }
    
    assert_eq!(buffer.len(), 1000, "Should have 1000 experiences");
    
    // Resize from 50K → 100K (grow)
    let resized = buffer.adaptive_resize(0.5, 100_000)?;
    assert!(resized, "Resize should succeed");
    assert_eq!(buffer.len(), 1000, "All 1000 experiences preserved");
    assert_eq!(buffer.get_capacity(), 55_000, "Capacity grown to 55K");
    
    // Verify we can still sample
    let batch = buffer.sample(32)?;
    assert_eq!(batch.experiences.len(), 32, "Should sample 32 experiences");
    
    Ok(())
}

#[test]
fn test_never_shrink_buffer() -> Result<(), Box<dyn std::error::Error>> {
    // Test 4: Ensure buffer NEVER shrinks (only grows)
    // FIX: Initialize at BASE_CAPACITY instead of max_capacity
    let mut buffer = ReplayBufferType::new_uniform(BASE_CAPACITY);
    
    // Resize to ε=0.1 (91K capacity)
    buffer.adaptive_resize(0.1, 100_000)?;
    let capacity_at_0_1 = buffer.get_capacity();
    assert_eq!(capacity_at_0_1, 91_000, "Should be at 91K");
    
    // Try to "shrink" by increasing epsilon (simulate restart with higher ε)
    // This should NOT shrink the buffer
    let resized = buffer.adaptive_resize(0.5, 100_000)?;
    assert!(!resized, "Should NOT resize when epsilon increases");
    assert_eq!(buffer.get_capacity(), 91_000, "Capacity should remain at 91K");
    
    // Confirm buffer never shrinks even at ε=1.0
    let resized = buffer.adaptive_resize(1.0, 100_000)?;
    assert!(!resized, "Should NOT resize to smaller capacity");
    assert_eq!(buffer.get_capacity(), 91_000, "Capacity unchanged");
    
    Ok(())
}

#[test]
fn test_memory_savings_early_training() -> Result<(), Box<dyn std::error::Error>> {
    // Test 5: Measure actual memory reduction early in training
    let max_capacity = 92_000; // Production baseline
    // FIX: Initialize at BASE_CAPACITY instead of max_capacity
    let mut buffer = ReplayBufferType::new_uniform(BASE_CAPACITY);
    
    // Early training (ε=1.0): Should use BASE_CAPACITY (10K)
    buffer.adaptive_resize(1.0, max_capacity)?;
    let early_capacity = buffer.get_capacity();
    assert_eq!(early_capacity, 10_000, "Early training uses minimal capacity");
    
    // Calculate memory savings
    let baseline_bytes = max_capacity * 4_000; // Estimate: 4KB per experience
    let adaptive_bytes = early_capacity * 4_000;
    let savings_pct = ((baseline_bytes - adaptive_bytes) as f64 / baseline_bytes as f64) * 100.0;
    
    println!("Memory savings (early training): {:.1}%", savings_pct);
    assert!(savings_pct >= 89.0, "Should save at least 89% memory early");
    
    // Mid-training (ε=0.5): Should use 55K
    buffer.adaptive_resize(0.5, max_capacity)?;
    let mid_capacity = buffer.get_capacity();
    let mid_savings_pct = ((baseline_bytes - mid_capacity * 4_000) as f64 / baseline_bytes as f64) * 100.0;
    
    println!("Memory savings (mid training): {:.1}%", mid_savings_pct);
    assert!(mid_savings_pct >= 40.0, "Should save at least 40% memory mid-training");
    
    Ok(())
}

#[test]
fn test_multi_epoch_adaptive_growth() -> Result<(), Box<dyn std::error::Error>> {
    // Test 6: End-to-end validation across simulated epochs
    // NOTE: WorkingDQN::new() initializes buffer at BASE_CAPACITY (10K)
    // config.replay_buffer_capacity specifies the MAX capacity for adaptive growth
    let mut config = WorkingDQNConfig::emergency_safe_defaults();
    config.state_dim = 5;
    config.num_actions = 3;
    config.replay_buffer_capacity = 100_000; // Max capacity for adaptive growth
    config.epsilon_start = 1.0;
    config.epsilon_end = 0.05;
    config.epsilon_decay = 0.995; // Decay rate per epoch

    let mut dqn = WorkingDQN::new(config)?;
    
    let mut resize_events = Vec::new();
    let mut capacities = Vec::new();
    
    // Simulate 300 epochs with epsilon decay
    for epoch in 0..300 {
        let epsilon_before = dqn.get_epsilon();
        
        // Try adaptive resize
        let resized = dqn.adaptive_buffer_resize()?;
        
        if resized {
            let capacity = dqn.memory.get_capacity();
            resize_events.push((epoch, epsilon_before, capacity));
            println!("Resize at epoch {}: ε={:.3}, capacity={}", epoch, epsilon_before, capacity);
        }
        
        capacities.push(dqn.memory.get_capacity());
        
        // Decay epsilon (simulate epoch end)
        dqn.update_epsilon();
    }
    
    // Validate resize events
    println!("\nTotal resize events: {}", resize_events.len());
    assert!(resize_events.len() >= 3, "Should have at least 3 resize events");
    assert!(resize_events.len() <= 5, "Should have at most 5 resize events");

    // Validate capacity growth pattern
    let final_capacity = capacities.last().unwrap();
    println!("Final capacity: {}", final_capacity);
    // After 300 epochs with decay=0.995: epsilon=0.299 → capacity=73,109 (73.1% of max)
    // This is correct behavior - test should validate >70K, not >80K
    assert!(*final_capacity >= 70_000, "Final capacity should be >70K after 300 epochs");
    
    // Verify monotonic growth (never shrinks)
    for i in 1..capacities.len() {
        assert!(capacities[i] >= capacities[i-1], "Capacity should never decrease");
    }
    
    Ok(())
}

#[test]
fn test_prioritized_replay_skip_resize() -> Result<(), Box<dyn std::error::Error>> {
    // Test 7: Confirm PER buffers skip resize (not yet implemented)
    let mut buffer = ReplayBufferType::new_prioritized(
        100_000,
        0.6,  // alpha
        0.4,  // beta
        1.0,  // beta_max
        10000 // beta_annealing_steps
    )?;
    
    // Add some experiences
    for i in 0..100 {
        buffer.add(create_test_experience(i as f32))?;
    }
    
    let initial_capacity = buffer.get_capacity();
    
    // Try to resize (should be skipped for PER)
    let resized = buffer.adaptive_resize(0.5, 100_000)?;
    
    assert!(!resized, "PER resize should be skipped (not yet implemented)");
    assert_eq!(buffer.get_capacity(), initial_capacity, "PER capacity unchanged");
    
    Ok(())
}

#[test]
fn test_edge_case_max_capacity_reached() -> Result<(), Box<dyn std::error::Error>> {
    // Test 8: Validate behavior when max capacity is reached
    let max_capacity = 50_000;
    let mut buffer = ReplayBufferType::new_uniform(max_capacity);
    
    // Resize to ε=0.05 (should hit max capacity)
    buffer.adaptive_resize(0.05, max_capacity)?;
    let capacity = buffer.get_capacity();
    
    // Should be at or near max (47,750 for ε=0.05)
    assert!(capacity >= max_capacity - 3_000, "Should be near max capacity");
    
    // Further epsilon decrease should not resize beyond max
    let resized = buffer.adaptive_resize(0.01, max_capacity)?;
    assert!(!resized || buffer.get_capacity() <= max_capacity, "Should not exceed max");
    
    Ok(())
}

#[test]
fn test_checkpoint_restart_consistency() -> Result<(), Box<dyn std::error::Error>> {
    // Test 9: Validate buffer resizes correctly after checkpoint restart
    // NOTE: WorkingDQN::new() initializes buffer at BASE_CAPACITY (10K)
    // config.replay_buffer_capacity specifies the MAX capacity for adaptive growth
    let mut config = WorkingDQNConfig::emergency_safe_defaults();
    config.state_dim = 5;
    config.num_actions = 3;
    config.replay_buffer_capacity = 100_000; // Max capacity for adaptive growth
    config.epsilon_start = 0.3; // Simulate restart mid-training

    let mut dqn = WorkingDQN::new(config)?;
    
    // Initial capacity should be 10K (default)
    let initial_capacity = dqn.memory.get_capacity();
    assert_eq!(initial_capacity, 10_000);
    
    // First resize should jump to match current epsilon (0.3)
    let resized = dqn.adaptive_buffer_resize()?;
    assert!(resized, "Should resize on first call to match epsilon");
    
    let post_resize_capacity = dqn.memory.get_capacity();
    let expected_capacity = 10_000 + ((100_000 - 10_000) as f64 * 0.7) as usize;
    assert_eq!(post_resize_capacity, expected_capacity, "Should resize to match ε=0.3");
    
    Ok(())
}

#[test]
fn test_hyperopt_varying_max_capacity() -> Result<(), Box<dyn std::error::Error>> {
    // Test 10: Validate formula handles different max_capacity values
    let test_cases = vec![
        (50_000, 0.5, 30_000),   // Small buffer
        (92_000, 0.5, 51_000),   // Production baseline
        (150_000, 0.5, 80_000),  // Large buffer
    ];
    
    for (max_cap, epsilon, expected_cap) in test_cases {
        // FIX: Initialize at BASE_CAPACITY instead of max_capacity
        let mut buffer = ReplayBufferType::new_uniform(BASE_CAPACITY);
        buffer.adaptive_resize(epsilon, max_cap)?;
        
        let actual_cap = buffer.get_capacity();
        let diff = (actual_cap as i64 - expected_cap as i64).abs();
        
        assert!(diff < 1000, 
            "For max={}, ε={}: expected ~{}, got {}",
            max_cap, epsilon, expected_cap, actual_cap
        );
    }
    
    Ok(())
}