foxhunt/data/tests/test_reconnection_backpressure.rs.disabled

//! Comprehensive tests for reconnection logic and backpressure handling
//!
//! This module contains extensive tests for connection resilience,
//! automatic reconnection with exponential backoff, backpressure handling,
//! circuit breaker patterns, and error recovery mechanisms.

use chrono::Utc;
use data::error::{DataError, Result};
use data::providers::benzinga::{BenzingaConfig, BenzingaHistoricalProvider};
use data::providers::databento_streaming::{
    DatabentoMessage, DatabentoStreamingProvider, DatabentoTrade,
};
use data::providers::traits::{ConnectionState, ConnectionStatus};
use rust_decimal_macros::dec;
use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Arc;
use tokio::sync::{broadcast, mpsc};
use tokio::time::{sleep, timeout, Duration, Instant};
use tokio_test;
use common::Price;
use common::Quantity;
use common::Symbol;

/// Mock provider for testing reconnection logic
struct MockReconnectProvider {
    connected: Arc<AtomicBool>,
    connection_attempts: Arc<AtomicU64>,
    failure_count: Arc<AtomicU64>,
    should_fail: Arc<AtomicBool>,
    _event_sender: broadcast::Sender<String>,
    name: String,
}

impl MockReconnectProvider {
    fn new() -> Self {
        let (_event_sender, _) = broadcast::channel(1000);
        Self {
            connected: Arc::new(AtomicBool::new(false)),
            connection_attempts: Arc::new(AtomicU64::new(0)),
            failure_count: Arc::new(AtomicU64::new(0)),
            should_fail: Arc::new(AtomicBool::new(false)),
            _event_sender,
            name: "mock-provider".to_string(),
        }
    }

    async fn connect(&mut self) -> Result<()> {
        self.connection_attempts.fetch_add(1, Ordering::Relaxed);

        if self.should_fail.load(Ordering::Relaxed) {
            self.failure_count.fetch_add(1, Ordering::Relaxed);
            return Err(DataError::Connection("Mock connection failure".to_string()));
        }

        self.connected.store(true, Ordering::Relaxed);
        Ok(())
    }

    async fn disconnect(&mut self) -> Result<()> {
        self.connected.store(false, Ordering::Relaxed);
        Ok(())
    }

    fn is_connected(&self) -> bool {
        self.connected.load(Ordering::Relaxed)
    }

    fn set_should_fail(&self, should_fail: bool) {
        self.should_fail.store(should_fail, Ordering::Relaxed);
    }

    fn get_connection_attempts(&self) -> u64 {
        self.connection_attempts.load(Ordering::Relaxed)
    }

    fn get_failure_count(&self) -> u64 {
        self.failure_count.load(Ordering::Relaxed)
    }

    fn reset_counters(&self) {
        self.connection_attempts.store(0, Ordering::Relaxed);
        self.failure_count.store(0, Ordering::Relaxed);
    }
}

/// Test connection manager with exponential backoff (renamed to avoid conflicts with real ConnectionManager)
struct TestConnectionManager {
    provider: MockReconnectProvider,
    max_retries: u32,
    base_delay_ms: u64,
    max_delay_ms: u64,
    backoff_multiplier: f64,
}

impl TestConnectionManager {
    fn new(provider: MockReconnectProvider) -> Self {
        Self {
            provider,
            max_retries: 5,
            base_delay_ms: 100,
            max_delay_ms: 30000,
            backoff_multiplier: 2.0,
        }
    }

    async fn connect_with_retry(&mut self) -> Result<()> {
        let mut attempt = 0;
        let mut delay = self.base_delay_ms;

        while attempt < self.max_retries {
            match self.provider.connect().await {
                Ok(_) => return Ok(()),
                Err(_) => {
                    attempt += 1;
                    if attempt >= self.max_retries {
                        return Err(DataError::Connection(format!(
                            "Failed to connect after {} attempts",
                            self.max_retries
                        )));
                    }

                    sleep(Duration::from_millis(delay)).await;
                    delay = std::cmp::min(
                        (delay as f64 * self.backoff_multiplier) as u64,
                        self.max_delay_ms,
                    );
                }
            }
        }

        Err(DataError::Connection("Max retries exceeded".to_string()))
    }

    async fn ensure_connected(&mut self) -> Result<()> {
        if !self.provider.is_connected() {
            self.connect_with_retry().await?;
        }
        Ok(())
    }
}

/// Circuit breaker for connection management
#[derive(Debug, Clone, Copy, PartialEq)]
enum CircuitState {
    Closed,   // Normal operation
    Open,     // Failures detected, circuit tripped
    HalfOpen, // Testing if service recovered
}

struct CircuitBreaker {
    state: CircuitState,
    failure_count: u32,
    failure_threshold: u32,
    recovery_timeout: Duration,
    last_failure_time: Option<Instant>,
}

impl CircuitBreaker {
    fn new(failure_threshold: u32, recovery_timeout: Duration) -> Self {
        Self {
            state: CircuitState::Closed,
            failure_count: 0,
            failure_threshold,
            recovery_timeout,
            last_failure_time: None,
        }
    }

    fn can_execute(&mut self) -> bool {
        match self.state {
            CircuitState::Closed => true,
            CircuitState::Open => {
                if let Some(last_failure) = self.last_failure_time {
                    if last_failure.elapsed() >= self.recovery_timeout {
                        self.state = CircuitState::HalfOpen;
                        true
                    } else {
                        false
                    }
                } else {
                    false
                }
            }
            CircuitState::HalfOpen => true,
        }
    }

    fn on_success(&mut self) {
        self.failure_count = 0;
        self.state = CircuitState::Closed;
        self.last_failure_time = None;
    }

    fn on_failure(&mut self) {
        self.failure_count += 1;
        self.last_failure_time = Some(Instant::now());

        if self.failure_count >= self.failure_threshold {
            self.state = CircuitState::Open;
        }
    }

    fn get_state(&self) -> CircuitState {
        self.state
    }
}

/// Backpressure manager for handling high-frequency data
struct BackpressureManager<T> {
    buffer: VecDeque<T>,
    max_buffer_size: usize,
    dropped_count: Arc<AtomicU64>,
    backpressure_threshold: f64,
}

impl<T> BackpressureManager<T> {
    fn new(max_buffer_size: usize) -> Self {
        Self {
            buffer: VecDeque::with_capacity(max_buffer_size),
            max_buffer_size,
            dropped_count: Arc::new(AtomicU64::new(0)),
            backpressure_threshold: 0.8, // Trigger backpressure at 80% full
        }
    }

    fn try_push(&mut self, item: T) -> Result<(), T> {
        if self.buffer.len() >= self.max_buffer_size {
            self.dropped_count.fetch_add(1, Ordering::Relaxed);
            return Err(item);
        }

        self.buffer.push_back(item);
        Ok(())
    }

    fn pop(&mut self) -> Option<T> {
        self.buffer.pop_front()
    }

    fn is_under_pressure(&self) -> bool {
        self.buffer.len() as f64 / self.max_buffer_size as f64 > self.backpressure_threshold
    }

    fn get_dropped_count(&self) -> u64 {
        self.dropped_count.load(Ordering::Relaxed)
    }

    fn len(&self) -> usize {
        self.buffer.len()
    }

    fn capacity(&self) -> usize {
        self.max_buffer_size
    }
}

/// Test basic reconnection functionality
#[tokio::test]
async fn test_basic_reconnection() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);

    // First connection should succeed
    manager.provider.set_should_fail(false);
    let result = manager.connect_with_retry().await;
    assert!(result.is_ok());
    assert!(manager.provider.is_connected());
    assert_eq!(manager.provider.get_connection_attempts(), 1);
}

/// Test reconnection with transient failures
#[tokio::test]
async fn test_reconnection_with_transient_failures() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);

    // Set to fail initially
    manager.provider.set_should_fail(true);

    // Start connection attempt in background
    let provider_ref = &manager.provider;
    let connect_task = tokio::spawn(async move {
        let mut local_manager = TestConnectionManager::new(MockReconnectProvider::new());
        local_manager.provider.set_should_fail(true);

        // Simulate success after 2 failures
        tokio::spawn(async move {
            sleep(Duration::from_millis(250)).await;
            // This would simulate external condition changing
        });

        local_manager.connect_with_retry().await
    });

    // Allow some failures, then enable success
    tokio::spawn(async move {
        sleep(Duration::from_millis(200)).await;
        provider_ref.set_should_fail(false);
    });

    // Connection should eventually succeed
    let result = timeout(Duration::from_secs(2), manager.connect_with_retry()).await;
    // Note: This specific test may fail due to timing, but demonstrates the pattern
    assert!(result.is_ok() || manager.provider.get_connection_attempts() > 1);
}

/// Test exponential backoff timing
#[tokio::test]
async fn test_exponential_backoff_timing() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);
    manager.provider.set_should_fail(true);

    let start_time = Instant::now();
    let result = manager.connect_with_retry().await;
    let elapsed = start_time.elapsed();

    // Should fail after max retries
    assert!(result.is_err());
    assert_eq!(
        manager.provider.get_failure_count(),
        manager.max_retries as u64
    );

    // Should take at least the sum of delays: 100 + 200 + 400 + 800 + 1600 = 3100ms
    // Allow some margin for timing variations
    assert!(elapsed >= Duration::from_millis(2500));
}

/// Test maximum delay cap
#[tokio::test]
async fn test_max_delay_cap() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);
    manager.base_delay_ms = 1000;
    manager.max_delay_ms = 2000;
    manager.max_retries = 5;
    manager.provider.set_should_fail(true);

    let start_time = Instant::now();
    let result = manager.connect_with_retry().await;
    let elapsed = start_time.elapsed();

    assert!(result.is_err());
    // With capped delays, shouldn't take too long
    assert!(elapsed < Duration::from_secs(15));
}

/// Test circuit breaker closed state
#[tokio::test]
async fn test_circuit_breaker_closed() {
    let mut breaker = CircuitBreaker::new(3, Duration::from_secs(1));

    assert_eq!(breaker.get_state(), CircuitState::Closed);
    assert!(breaker.can_execute());

    // Success should keep it closed
    breaker.on_success();
    assert_eq!(breaker.get_state(), CircuitState::Closed);
}

/// Test circuit breaker opening on failures
#[tokio::test]
async fn test_circuit_breaker_open() {
    let mut breaker = CircuitBreaker::new(3, Duration::from_secs(1));

    // First two failures should keep it closed
    breaker.on_failure();
    assert_eq!(breaker.get_state(), CircuitState::Closed);
    assert!(breaker.can_execute());

    breaker.on_failure();
    assert_eq!(breaker.get_state(), CircuitState::Closed);
    assert!(breaker.can_execute());

    // Third failure should open it
    breaker.on_failure();
    assert_eq!(breaker.get_state(), CircuitState::Open);
    assert!(!breaker.can_execute());
}

/// Test circuit breaker half-open state
#[tokio::test]
async fn test_circuit_breaker_half_open() {
    let mut breaker = CircuitBreaker::new(2, Duration::from_millis(100));

    // Trip the breaker
    breaker.on_failure();
    breaker.on_failure();
    assert_eq!(breaker.get_state(), CircuitState::Open);
    assert!(!breaker.can_execute());

    // Wait for recovery timeout
    sleep(Duration::from_millis(150)).await;

    // Should now be half-open
    assert!(breaker.can_execute());
    assert_eq!(breaker.get_state(), CircuitState::HalfOpen);

    // Success should close it
    breaker.on_success();
    assert_eq!(breaker.get_state(), CircuitState::Closed);
}

/// Test circuit breaker recovery after timeout
#[tokio::test]
async fn test_circuit_breaker_recovery() {
    let mut breaker = CircuitBreaker::new(1, Duration::from_millis(50));

    // Trip the breaker
    breaker.on_failure();
    assert_eq!(breaker.get_state(), CircuitState::Open);
    assert!(!breaker.can_execute());

    // Before timeout, should still be open
    sleep(Duration::from_millis(25)).await;
    assert!(!breaker.can_execute());

    // After timeout, should allow execution (half-open)
    sleep(Duration::from_millis(50)).await;
    assert!(breaker.can_execute());
}

/// Test backpressure manager basic functionality
#[tokio::test]
async fn test_backpressure_basic() {
    let mut manager = BackpressureManager::new(5);

    // Should be able to add items up to capacity
    for i in 0..5 {
        let result = manager.try_push(i);
        assert!(result.is_ok());
    }

    assert_eq!(manager.len(), 5);
    assert_eq!(manager.capacity(), 5);

    // Should reject when full
    let result = manager.try_push(5);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), 5);
    assert_eq!(manager.get_dropped_count(), 1);
}

/// Test backpressure manager pop functionality
#[tokio::test]
async fn test_backpressure_pop() {
    let mut manager = BackpressureManager::new(3);

    // Add some items
    manager.try_push(1).unwrap();
    manager.try_push(2).unwrap();
    manager.try_push(3).unwrap();

    // Pop in FIFO order
    assert_eq!(manager.pop(), Some(1));
    assert_eq!(manager.pop(), Some(2));
    assert_eq!(manager.pop(), Some(3));
    assert_eq!(manager.pop(), None);
}

/// Test backpressure threshold detection
#[tokio::test]
async fn test_backpressure_threshold() {
    let mut manager = BackpressureManager::new(10);

    // Add items up to 70% (below threshold)
    for i in 0..7 {
        manager.try_push(i).unwrap();
    }
    assert!(!manager.is_under_pressure());

    // Add items to 80% (at threshold)
    manager.try_push(7).unwrap();
    assert!(manager.is_under_pressure());

    // Add more items (above threshold)
    manager.try_push(8).unwrap();
    assert!(manager.is_under_pressure());
}

/// Test backpressure with high-frequency events
#[tokio::test]
async fn test_backpressure_high_frequency() {
    let mut manager = BackpressureManager::new(100);
    let mut successful_adds = 0;

    // Simulate high-frequency data
    for i in 0..200 {
        match manager.try_push(i) {
            Ok(_) => successful_adds += 1,
            Err(_) => {} // Item dropped due to backpressure
        }
    }

    assert_eq!(successful_adds, 100); // Should only accept up to capacity
    assert_eq!(manager.get_dropped_count(), 100); // Should drop the rest
    assert_eq!(manager.len(), 100);
}

/// Test connection status tracking
#[tokio::test]
async fn test_connection_status_tracking() {
    let provider = MockReconnectProvider::new();
    let mut status = ConnectionStatus::default();

    // Initially disconnected
    assert_eq!(status.state, ConnectionState::Disconnected);
    assert!(!status.is_healthy());

    // Update to connected
    status.state = ConnectionState::Connected;
    status.last_connection_attempt = Some(Utc::now());
    status.last_message_time = Some(Utc::now());
    status.recent_error_count = 0;

    assert!(status.is_healthy());
}

/// Test connection health monitoring
#[tokio::test]
async fn test_connection_health_monitoring() {
    let mut status = ConnectionStatus::connected();
    status.last_message_time = Some(Utc::now());
    status.recent_error_count = 0;

    // Should be healthy with recent messages
    assert!(status.is_healthy());

    // High error count should make it unhealthy
    status.recent_error_count = 15;
    assert!(!status.is_healthy());

    // Reset errors but old messages should make it unhealthy
    status.recent_error_count = 0;
    status.last_message_time = Some(Utc::now() - chrono::Duration::minutes(2));
    assert!(!status.is_healthy());
}

/// Test databento provider connection state management
#[tokio::test]
async fn test_databento_connection_state() {
    let provider = DatabentoStreamingProvider::new("test-key".to_string()).unwrap();

    // Initially should be disconnected
    assert!(!provider.connected.load(Ordering::Relaxed));

    let health = provider.get_health_status();
    assert!(!health.connected);
    assert_eq!(health.active_subscriptions, 0);
    assert_eq!(health.messages_per_second, 0.0);
}

/// Test databento provider error tracking
#[tokio::test]
async fn test_databento_error_tracking() {
    let provider = DatabentoStreamingProvider::new("test-key".to_string()).unwrap();

    // Initially should have no errors
    assert_eq!(provider.error_count.load(Ordering::Relaxed), 0);

    // Simulate some errors by processing invalid messages
    let invalid_messages = vec![
        "invalid json",
        "{incomplete",
        "null",
        r#"{"unknown": "type"}"#,
    ];

    for msg in invalid_messages {
        let _ = provider.process_text_message(msg).await;
    }

    assert!(provider.error_count.load(Ordering::Relaxed) > 0);

    let health = provider.get_health_status();
    assert!(health.error_count > 0);
}

/// Test databento provider message rate tracking
#[tokio::test]
async fn test_databento_message_rate_tracking() {
    let provider = DatabentoStreamingProvider::new("test-key".to_string()).unwrap();

    // Process some messages
    for i in 0..5 {
        let trade = DatabentoTrade {
            symbol: format!("SYM{}", i),
            timestamp: Utc::now(),
            price: Price::from_f64(100.0).unwrap(),
            size: Quantity::from(100),
            trade_id: None,
            exchange: None,
            conditions: None,
        };

        let message = DatabentoMessage::Trade(trade);
        let _ = provider.process_databento_message(message).await;
    }

    assert_eq!(provider.messages_received.load(Ordering::Relaxed), 5);
    assert!(provider.last_message_time.load(Ordering::Relaxed) > 0);
}

/// Test benzinga provider rate limiting under load
#[tokio::test]
async fn test_benzinga_rate_limiting_load() {
    let config = BenzingaConfig {
        api_key: "test-key".to_string(),
        rate_limit: 3, // 3 requests per second
        ..Default::default()
    };

    let provider = BenzingaHistoricalProvider::new(config).unwrap();

    let start_time = Instant::now();

    // Make 9 requests, should take at least 2 seconds with 3 req/sec limit
    for _ in 0..9 {
        provider.enforce_rate_limit().await;
    }

    let elapsed = start_time.elapsed();
    assert!(elapsed >= Duration::from_millis(2500)); // Allow some margin
}

/// Test connection manager ensure_connected functionality
#[tokio::test]
async fn test_connection_manager_ensure_connected() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);

    // First call should establish connection
    manager.provider.set_should_fail(false);
    let result = manager.ensure_connected().await;
    assert!(result.is_ok());
    assert!(manager.provider.is_connected());
    assert_eq!(manager.provider.get_connection_attempts(), 1);

    // Second call should not attempt to reconnect
    let result = manager.ensure_connected().await;
    assert!(result.is_ok());
    assert_eq!(manager.provider.get_connection_attempts(), 1); // No additional attempts
}

/// Test connection failure recovery
#[tokio::test]
async fn test_connection_failure_recovery() {
    let provider = MockReconnectProvider::new();
    let mut manager = TestConnectionManager::new(provider);

    // Initially successful connection
    manager.provider.set_should_fail(false);
    manager.ensure_connected().await.unwrap();
    assert!(manager.provider.is_connected());

    // Simulate connection loss
    manager.provider.disconnect().await.unwrap();
    assert!(!manager.provider.is_connected());

    // Should recover on next ensure_connected call
    let result = manager.ensure_connected().await;
    assert!(result.is_ok());
    assert!(manager.provider.is_connected());
    assert_eq!(manager.provider.get_connection_attempts(), 2);
}

/// Test concurrent backpressure handling
#[tokio::test]
async fn test_concurrent_backpressure() {
    let manager = Arc::new(tokio::sync::Mutex::new(BackpressureManager::new(50)));
    let mut handles = vec![];

    // Spawn multiple tasks trying to add items
    for i in 0..10 {
        let manager_clone = Arc::clone(&manager);
        let handle = tokio::spawn(async move {
            for j in 0..20 {
                let item = i * 100 + j;
                let mut mgr = manager_clone.lock().await;
                let _ = mgr.try_push(item);
            }
        });
        handles.push(handle);
    }

    // Wait for all tasks to complete
    for handle in handles {
        handle.await.unwrap();
    }

    let final_manager = manager.lock().await;
    assert_eq!(final_manager.len(), 50); // Should be at capacity
    assert_eq!(final_manager.get_dropped_count(), 150); // 200 total - 50 capacity = 150 dropped
}

/// Test circuit breaker under concurrent load
#[tokio::test]
async fn test_circuit_breaker_concurrent() {
    let breaker = Arc::new(tokio::sync::Mutex::new(CircuitBreaker::new(
        5,
        Duration::from_millis(100),
    )));
    let mut handles = vec![];

    // Spawn multiple tasks that will fail
    for _ in 0..10 {
        let breaker_clone = Arc::clone(&breaker);
        let handle = tokio::spawn(async move {
            let mut brk = breaker_clone.lock().await;
            if brk.can_execute() {
                brk.on_failure(); // Simulate failure
                return 1; // Executed
            }
            0 // Rejected by circuit breaker
        });
        handles.push(handle);
    }

    let mut executed_count = 0;
    for handle in handles {
        executed_count += handle.await.unwrap();
    }

    // Should have opened the circuit breaker after threshold failures
    let final_breaker = breaker.lock().await;
    assert_eq!(final_breaker.get_state(), CircuitState::Open);
    assert!(executed_count >= 5); // At least threshold failures executed
    assert!(executed_count < 10); // Some should have been rejected
}