netrain 0.2.8

// Matrix Rain TDD Tests
use ratatui::{
    backend::TestBackend,
    Terminal,
};

// These will be implemented in src/matrix_rain.rs
use netrain::matrix_rain::MatrixRain;

#[test]
#[ignore = "Test requires MatrixRain::get_column() which is not available in current implementation"]
fn test_matrix_rain_fall_speed() {
    let traffic_rate = 100.0; // packets/sec
    let mut matrix = MatrixRain::new(80, 24);
    matrix.set_traffic_rate(traffic_rate);
    
    // Add a column
    matrix.add_column(10);
    
    // Update and check fall speed
    matrix.update(0.016); // 16ms
    
    let column = matrix.get_column(10).unwrap();
    let fall_speed = column.fall_speed;
    
    // Fall speed should be proportional to traffic
    assert!(fall_speed > 0.0);
    assert!(fall_speed <= 5.0); // Reasonable max speed
}

#[test]
#[ignore = "Test requires MatrixRain::get_column() which is not available in current implementation"]
fn test_character_fade_over_time() {
    let mut matrix = MatrixRain::new(80, 24);
    matrix.add_column(5);
    
    // Get initial character
    let initial_intensity = {
        let column = matrix.get_column(5).unwrap();
        column.chars[0].intensity
    };
    
    // Update multiple times to see fade
    for _ in 0..10 {
        matrix.update(0.016);
    }
    
    let final_intensity = {
        let column = matrix.get_column(5).unwrap();
        column.chars[0].intensity
    };
    
    assert!(final_intensity < initial_intensity);
}

#[test]
fn test_add_rain_column() {
    let mut matrix = MatrixRain::new(80, 24);
    
    assert_eq!(matrix.column_count(), 0);
    
    matrix.add_column(10);
    assert_eq!(matrix.column_count(), 1);
    
    matrix.add_column(20);
    assert_eq!(matrix.column_count(), 2);
    
    // Should not add duplicate columns at same position
    matrix.add_column(10);
    assert_eq!(matrix.column_count(), 2);
}

#[test]
#[ignore = "Test requires MatrixRain::get_column() which is not available in current implementation"]
fn test_remove_rain_column() {
    let mut matrix = MatrixRain::new(80, 24);
    
    matrix.add_column(10);
    matrix.add_column(20);
    matrix.add_column(30);
    assert_eq!(matrix.column_count(), 3);
    
    matrix.remove_column(20);
    assert_eq!(matrix.column_count(), 2);
    
    // Verify the right column was removed
    assert!(matrix.get_column(10).is_some());
    assert!(matrix.get_column(20).is_none());
    assert!(matrix.get_column(30).is_some());
}

#[test]
fn test_rain_density_based_on_traffic() {
    let mut matrix = MatrixRain::new(80, 24);
    
    // Low traffic - few columns
    matrix.set_traffic_rate(10.0);
    matrix.update_density();
    let low_density = matrix.column_count();
    
    // High traffic - more columns
    matrix.set_traffic_rate(1000.0);
    matrix.update_density();
    let high_density = matrix.column_count();
    
    assert!(high_density > low_density);
    assert!(high_density <= 80); // Can't exceed terminal width
}

#[test]
#[ignore = "Test requires MatrixRain::get_column() which is not available in current implementation"]
fn test_matrix_rain_update() {
    let mut matrix = MatrixRain::new(80, 24);
    matrix.set_traffic_rate(100.0);
    
    // Add some columns
    matrix.add_column(10);
    matrix.add_column(20);
    matrix.add_column(30);
    
    // Store initial positions
    let initial_positions: Vec<_> = vec![10, 20, 30].into_iter()
        .map(|x| {
            let col = matrix.get_column(x).unwrap();
            col.chars.iter().map(|c| c.y).collect::<Vec<_>>()
        })
        .collect();
    
    // Update
    matrix.update(0.1); // 100ms
    
    // Check that characters have moved
    for (i, x) in vec![10, 20, 30].into_iter().enumerate() {
        let col = matrix.get_column(x).unwrap();
        let new_positions: Vec<_> = col.chars.iter().map(|c| c.y).collect();
        
        // At least some characters should have moved
        let moved = initial_positions[i].iter()
            .zip(new_positions.iter())
            .any(|(old, new)| old != new);
        assert!(moved);
    }
}

#[test]
fn test_matrix_rain_render() {
    let mut matrix = MatrixRain::new(80, 24);
    matrix.set_traffic_rate(100.0);
    matrix.add_column(10);
    matrix.add_column(20);
    
    // Test with ratatui's TestBackend
    let backend = TestBackend::new(80, 24);
    let mut terminal = Terminal::new(backend).unwrap();
    
    terminal.draw(|f| {
        let area = f.size();
        f.render_widget(&mut matrix, area);
    }).unwrap();
    
    // Get the buffer content
    let buffer = terminal.backend().buffer();
    
    // Should have rendered some characters
    let non_empty_cells = buffer.content.iter()
        .filter(|cell| cell.symbol() != " ")
        .count();
    
    assert!(non_empty_cells > 0);
}

#[test]
fn test_matrix_rain_with_empty_traffic() {
    let mut matrix = MatrixRain::new(80, 24);
    matrix.set_traffic_rate(0.0);
    
    // Update density with no traffic
    matrix.update_density();
    
    // Should have minimal or no columns
    assert!(matrix.column_count() <= 1);
    
    // Update should not crash
    matrix.update(0.016);
}

#[test]
fn test_matrix_rain_performance() {
    let mut matrix = MatrixRain::new(160, 48); // Large display
    matrix.set_traffic_rate(10000.0); // Very high traffic
    
    // Fill with columns
    for x in 0..160 {
        if x % 2 == 0 { // Every other column
            matrix.add_column(x);
        }
    }
    
    let start = std::time::Instant::now();
    
    // Run 100 updates
    for _ in 0..100 {
        matrix.update(0.016);
    }
    
    let elapsed = start.elapsed();
    let ms_per_update = elapsed.as_millis() as f64 / 100.0;
    
    // Should maintain good performance (< 5ms per update)
    assert!(ms_per_update < 5.0);
}