foxhunt/tli/src/client/mod.rs

//! TLI gRPC client modules
//!
//! This module contains comprehensive gRPC client implementations for all
//! core trading system services with advanced features including:
//! - Connection pooling and health monitoring
//! - Real-time streaming support
//! - Automatic reconnection and circuit breakers
//! - Comprehensive error handling
//! - Metrics collection and alerting

pub mod backtesting_client;
pub mod connection_manager;
pub mod event_stream;
pub mod ml_training_client;
pub mod stream_manager;
pub mod trading_client;

// Re-export main components
// DO NOT RE-EXPORT - Use explicit imports at usage sites

/// Service endpoints configuration
#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct ServiceEndpoints {
    /// Trading engine endpoint
    pub trading_engine: String,
    /// Market data endpoint
    pub market_data: String,
    /// Backtesting service endpoint
    pub backtesting_service: String,
    /// ML training service endpoint
    pub ml_training_service: String,
}

impl ServiceEndpoints {
    /// Create default endpoints for local development
    pub fn localhost() -> Self {
        Self {
            trading_engine: "http://localhost:50051".to_string(),
            market_data: "http://localhost:50052".to_string(),
            backtesting_service: "http://localhost:50053".to_string(),
            ml_training_service: "http://localhost:50054".to_string(),
        }
    }
}

/// Client factory for creating and managing all service clients
#[derive(Debug)]
pub struct ClientFactory {
    /// Connection manager shared across all clients
    connection_manager: std::sync::Arc<ConnectionManager>,
    /// Global connection configuration
    connection_config: ConnectionConfig,
}

impl ClientFactory {
    /// Create a new client factory
    pub fn new(connection_config: ConnectionConfig) -> Self {
        let connection_manager =
            std::sync::Arc::new(ConnectionManager::new(connection_config.clone()));

        Self {
            connection_manager,
            connection_config,
        }
    }

    /// Create a trading client
    pub fn create_trading_client(&self, config: TradingClientConfig) -> TradingClient {
        TradingClient::new(self.connection_manager.clone(), config)
    }

    /// Create a backtesting client
    pub fn create_backtesting_client(&self, config: BacktestingClientConfig) -> BacktestingClient {
        BacktestingClient::new(self.connection_manager.clone(), config)
    }

    /// Create an ML training client
    pub fn create_ml_training_client(&self, config: MLTrainingClientConfig) -> MLTrainingClient {
        MLTrainingClient::new(self.connection_manager.clone(), config)
    }

    /// Add a service connection to the pool
    pub async fn add_service(
        &self,
        service_name: String,
        config: ConnectionConfig,
    ) -> crate::error::TliResult<()> {
        self.connection_manager
            .add_service(service_name, config)
            .await
    }

    /// Get connection statistics for all services
    pub async fn get_connection_stats(
        &self,
    ) -> std::collections::HashMap<String, Vec<ConnectionStats>> {
        self.connection_manager.get_pool_stats().await
    }

    /// Shutdown all connections and clients
    pub async fn shutdown(&self) {
        self.connection_manager.shutdown().await;
    }
}

/// Convenience builder for creating a complete TLI client setup
#[derive(Debug)]
pub struct TliClientBuilder {
    /// Connection configuration
    connection_config: ConnectionConfig,
    /// Service endpoints
    service_endpoints: std::collections::HashMap<String, String>,
    /// Client configurations
    trading_config: Option<TradingClientConfig>,
    backtesting_config: Option<BacktestingClientConfig>,
    ml_training_config: Option<MLTrainingClientConfig>,
}

impl Default for TliClientBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl TliClientBuilder {
    /// Create a new builder
    pub fn new() -> Self {
        Self {
            connection_config: ConnectionConfig::default(),
            service_endpoints: std::collections::HashMap::new(),
            trading_config: None,
            backtesting_config: None,
            ml_training_config: None,
        }
    }

    /// Set connection configuration
    pub fn with_connection_config(mut self, config: ConnectionConfig) -> Self {
        self.connection_config = config;
        self
    }

    /// Add a service endpoint
    pub fn with_service_endpoint(mut self, service_name: String, endpoint: String) -> Self {
        self.service_endpoints.insert(service_name, endpoint);
        self
    }

    /// Set trading client configuration
    pub fn with_trading_config(mut self, config: TradingClientConfig) -> Self {
        self.trading_config = Some(config);
        self
    }

    /// Set backtesting client configuration
    pub fn with_backtesting_config(mut self, config: BacktestingClientConfig) -> Self {
        self.backtesting_config = Some(config);
        self
    }

    /// Set ML training client configuration
    pub fn with_ml_training_config(mut self, config: MLTrainingClientConfig) -> Self {
        self.ml_training_config = Some(config);
        self
    }

    /// Build the complete TLI client setup
    pub async fn build(self) -> crate::error::TliResult<TliClientSuite> {
        let factory = ClientFactory::new(self.connection_config.clone());

        // Add service connections
        for (service_name, endpoint) in self.service_endpoints {
            let mut service_config = self.connection_config.clone();
            service_config.endpoint = endpoint;
            factory.add_service(service_name, service_config).await?;
        }

        // Create clients
        let trading_client = if let Some(config) = self.trading_config {
            Some(factory.create_trading_client(config))
        } else {
            None
        };

        let backtesting_client = if let Some(config) = self.backtesting_config {
            Some(factory.create_backtesting_client(config))
        } else {
            None
        };

        let ml_training_client = if let Some(config) = self.ml_training_config {
            Some(factory.create_ml_training_client(config))
        } else {
            None
        };

        Ok(TliClientSuite {
            factory,
            trading_client,
            backtesting_client,
            ml_training_client,
        })
    }
}

/// Complete TLI client suite with all service clients
#[derive(Debug)]
pub struct TliClientSuite {
    /// Client factory
    pub factory: ClientFactory,
    /// Trading client (includes all operations: trading, risk, monitoring, config, system status)
    pub trading_client: Option<TradingClient>,
    /// Backtesting client
    pub backtesting_client: Option<BacktestingClient>,
    /// ML training client
    pub ml_training_client: Option<MLTrainingClient>,
}

impl TliClientSuite {
    /// Get connection statistics for all services
    pub async fn get_connection_stats(
        &self,
    ) -> std::collections::HashMap<String, Vec<ConnectionStats>> {
        self.factory.get_connection_stats().await
    }

    /// Shutdown all clients and connections
    pub async fn shutdown(self) {
        if let Some(client) = self.trading_client {
            client.shutdown().await;
        }
        if let Some(client) = self.backtesting_client {
            client.shutdown().await;
        }
        if let Some(client) = self.ml_training_client {
            client.shutdown().await;
        }

        self.factory.shutdown().await;
    }
}

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

    #[test]
    fn test_client_factory_creation() {
        let config = ConnectionConfig::default();
        let factory = ClientFactory::new(config);

        // Test that factory can create clients
        let trading_config = TradingClientConfig::default();
        let _trading_client = factory.create_trading_client(trading_config);
    }

    #[test]
    fn test_builder_pattern() {
        let builder = TliClientBuilder::new()
            .with_service_endpoint(
                "trading_service".to_string(),
                "http://localhost:50051".to_string(),
            )
            .with_trading_config(TradingClientConfig::default())
            .with_backtesting_config(BacktestingClientConfig::default())
            .with_ml_training_config(MLTrainingClientConfig::default());

        // Builder should have the configuration set
        assert!(builder.trading_config.is_some());
        assert!(builder.backtesting_config.is_some());
        assert!(builder.ml_training_config.is_some());
        assert!(builder.service_endpoints.contains_key("trading_service"));
    }
}