sta/backend/src/infrastructure/modbus/factory.rs

//! Factory module for creating relay controller instances.
//!
//! This module provides factory functions for creating relay controllers
//! with graceful degradation and retry logic.

use std::sync::Arc;

use crate::domain::relay::controller::RelayController;
use crate::settings::ModbusSettings;

// TODO: Uncomment when implementation is added (T039a)
// use super::client::ModbusRelayController;
// use super::mock_controller::MockRelayController;

/// Creates a relay controller with retry and fallback logic.
///
/// # Parameters
///
/// - `settings`: Modbus connection configuration
/// - `use_mock`: If true, returns `MockRelayController` immediately without attempting real connection
///
/// # Behavior
///
/// 1. If `use_mock` is true, returns `MockRelayController` immediately
/// 2. Otherwise, attempts to connect to real Modbus hardware with:
///    - 3 retry attempts
///    - 2 second backoff between retries
/// 3. If all retries fail, falls back to `MockRelayController` (graceful degradation per FR-023)
///
/// # Returns
///
/// An `Arc<dyn RelayController>` that can be either:
/// - `MockRelayController` (for testing or when hardware connection fails)
/// - `ModbusRelayController` (for real hardware communication)
pub async fn create_relay_controller(
    _settings: &ModbusSettings,
    _use_mock: bool,
) -> Arc<dyn RelayController> {
    // TODO: Implement in T039a
    unimplemented!("T039a: create_relay_controller factory not yet implemented")
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::time::Duration;

    // Helper to create test settings
    fn create_test_settings() -> ModbusSettings {
        ModbusSettings {
            host: "192.168.0.200".to_string(),
            port: 502,
            slave_id: 0,
            timeout_secs: 5,
        }
    }

    // T039a: Test 1 - use_mock=true returns MockRelayController immediately
    #[tokio::test]
    async fn test_create_relay_controller_with_mock_flag_returns_mock_immediately() {
        // GIVEN: Settings and use_mock=true
        let settings = create_test_settings();

        // WHEN: create_relay_controller is called with use_mock=true
        let start = std::time::Instant::now();
        let controller = create_relay_controller(&settings, true).await;
        let elapsed = start.elapsed();

        // THEN: Should return MockRelayController immediately (< 100ms)
        assert!(
            elapsed < Duration::from_millis(100),
            "Mock controller should be created immediately without delay, took {:?}",
            elapsed
        );

        // Verify it's a mock by checking if we can downcast to MockRelayController
        // This is a weak test - in reality we'd check the type more carefully
        // For now we just verify we got a controller back
        assert!(Arc::strong_count(&controller) > 0);
    }

    // T039a: Test 2 - Successful connection returns ModbusRelayController
    #[tokio::test]
    #[ignore] // Requires real Modbus hardware - run with --ignored
    async fn test_create_relay_controller_successful_connection() {
        // GIVEN: Valid settings for a real Modbus device
        let settings = create_test_settings();

        // WHEN: create_relay_controller is called with use_mock=false
        let controller = create_relay_controller(&settings, false).await;

        // THEN: Should return ModbusRelayController
        // We verify by attempting a real operation
        // Note: This test requires actual hardware and should be #[ignore]
        use crate::domain::relay::types::RelayId;
        let relay_id = RelayId::new(1).unwrap();
        let result = controller.read_relay_state(relay_id).await;

        // Should succeed if hardware is connected
        assert!(
            result.is_ok(),
            "Failed to read state from real hardware: {:?}",
            result.err()
        );
    }

    // T039a: Test 3 - Connection failure after 3 retries returns MockRelayController
    #[tokio::test]
    async fn test_create_relay_controller_fallback_to_mock_after_retries() {
        // GIVEN: Invalid settings that will fail to connect (invalid host)
        let settings = ModbusSettings {
            host: "192.0.2.1".to_string(), // TEST-NET-1 (reserved, unreachable)
            port: 502,
            slave_id: 0,
            timeout_secs: 1, // Short timeout for faster test
        };

        // WHEN: create_relay_controller attempts connection
        let start = std::time::Instant::now();
        let controller = create_relay_controller(&settings, false).await;
        let elapsed = start.elapsed();

        // THEN: Should fall back to MockRelayController after retries
        // Total time should be roughly: 3 retries * (timeout + 2s backoff) ≈ 9-10 seconds
        // With 1s timeout: ~9 seconds minimum (1s attempt + 2s wait + 1s attempt + 2s wait + 1s attempt)
        assert!(
            elapsed >= Duration::from_secs(8),
            "Should have retried 3 times with 2s delays, took {:?}",
            elapsed
        );

        // Verify we can still use the fallback controller
        use crate::domain::relay::types::RelayId;
        let relay_id = RelayId::new(1).unwrap();
        let result = controller.read_relay_state(relay_id).await;

        // Mock controller should work even if hardware connection failed
        assert!(
            result.is_ok() || result.is_err(),
            "Controller should be usable (mock or real)"
        );
    }

    // T039a: Test 4 - Retry delays are 2 seconds between attempts
    #[tokio::test]
    async fn test_create_relay_controller_retry_delays() {
        // GIVEN: Invalid settings to force retries
        let settings = ModbusSettings {
            host: "192.0.2.1".to_string(), // Unreachable address
            port: 502,
            slave_id: 0,
            timeout_secs: 1,
        };

        // WHEN: create_relay_controller attempts connection
        let start = std::time::Instant::now();
        let _controller = create_relay_controller(&settings, false).await;
        let elapsed = start.elapsed();

        // THEN: Should take approximately:
        // Attempt 1 (1s timeout) + 2s delay + Attempt 2 (1s) + 2s delay + Attempt 3 (1s)
        // = ~7 seconds minimum (allowing some variance)
        assert!(
            elapsed >= Duration::from_secs(7) && elapsed <= Duration::from_secs(15),
            "Retry timing incorrect: expected ~7-15s, got {:?}",
            elapsed
        );
    }

    // T039a: Test 5 - Logs appropriate messages for each connection attempt
    #[tokio::test]
    async fn test_create_relay_controller_logs_connection_attempts() {
        // This test verifies logging behavior
        // In a real implementation, we would use a test subscriber to capture logs
        // For now, this is a placeholder that will be updated when logging is added

        // GIVEN: Invalid settings to trigger logging
        let settings = ModbusSettings {
            host: "192.0.2.1".to_string(),
            port: 502,
            slave_id: 0,
            timeout_secs: 1,
        };

        // WHEN: create_relay_controller attempts connection
        let _controller = create_relay_controller(&settings, false).await;

        // THEN: Should have logged:
        // - Info message when using mock mode
        // - Warning for each failed retry attempt (3 times)
        // - Error message when falling back to mock
        // - Info message when successfully connecting

        // TODO: Add proper log capture and verification
        // For now, we just verify the function completes
        // This is acceptable for initial TDD - we'll enhance later
    }
}