foxhunt/tests/e2e/src/clients.rs

//! gRPC Client Implementations for E2E Testing
//!
//! Provides type-safe gRPC client wrappers for all services in the Foxhunt system.
//! These clients handle connection management, authentication, error handling,
//! and provide convenient methods for testing interactions.

use anyhow::{Context, Result};
use std::time::Duration;
use tonic::transport::{Channel, Endpoint};
use tracing::{debug, info, warn};

/// Trading Service gRPC Client
#[derive(Debug, Clone)]
pub struct TradingServiceClient {
    client: tli::proto::trading::trading_service_client::TradingServiceClient<Channel>,
    endpoint: String,
}

impl TradingServiceClient {
    /// Create a new Trading Service client
    pub async fn new(endpoint: &str) -> Result<Self> {
        info!("🔌 Connecting to Trading Service at {}", endpoint);

        let channel = Endpoint::from_shared(endpoint.to_string())?
            .timeout(Duration::from_secs(30))
            .connect_timeout(Duration::from_secs(10))
            .connect()
            .await
            .context("Failed to connect to Trading Service")?;

        let client =
            tli::proto::trading::trading_service_client::TradingServiceClient::new(channel);

        Ok(Self {
            client,
            endpoint: endpoint.to_string(),
        })
    }

    /// Submit an order
    pub async fn submit_order(
        &mut self,
        request: tli::proto::trading::SubmitOrderRequest,
    ) -> Result<tonic::Response<tli::proto::trading::SubmitOrderResponse>> {
        debug!("Submitting order: {:?}", request);

        self.client
            .submit_order(request)
            .await
            .context("Failed to submit order")
    }

    /// Cancel an order
    pub async fn cancel_order(
        &mut self,
        request: tli::proto::trading::CancelOrderRequest,
    ) -> Result<tonic::Response<tli::proto::trading::CancelOrderResponse>> {
        debug!("Cancelling order: {}", request.order_id);

        self.client
            .cancel_order(request)
            .await
            .context("Failed to cancel order")
    }

    /// Get order status
    pub async fn get_order_status(
        &mut self,
        request: tli::proto::trading::GetOrderStatusRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetOrderStatusResponse>> {
        self.client
            .get_order_status(request)
            .await
            .context("Failed to get order status")
    }

    /// Get account information
    pub async fn get_account_info(
        &mut self,
        request: tli::proto::trading::GetAccountInfoRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetAccountInfoResponse>> {
        self.client
            .get_account_info(request)
            .await
            .context("Failed to get account info")
    }

    /// Get positions
    pub async fn get_positions(
        &mut self,
        request: tli::proto::trading::GetPositionsRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetPositionsResponse>> {
        self.client
            .get_positions(request)
            .await
            .context("Failed to get positions")
    }

    /// Subscribe to market data
    pub async fn subscribe_market_data(
        &mut self,
        request: tli::proto::trading::SubscribeMarketDataRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::MarketDataEvent>>> {
        debug!(
            "Subscribing to market data for symbols: {:?}",
            request.symbols
        );

        self.client
            .subscribe_market_data(request)
            .await
            .context("Failed to subscribe to market data")
    }

    /// Subscribe to order updates
    pub async fn subscribe_order_updates(
        &mut self,
        request: tli::proto::trading::SubscribeOrderUpdatesRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::OrderUpdateEvent>>> {
        debug!("Subscribing to order updates");

        self.client
            .subscribe_order_updates(request)
            .await
            .context("Failed to subscribe to order updates")
    }

    /// Get VaR
    pub async fn get_va_r(
        &mut self,
        request: tli::proto::trading::GetVaRRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetVaRResponse>> {
        self.client
            .get_va_r(request)
            .await
            .context("Failed to get VaR")
    }

    /// Get position risk
    pub async fn get_position_risk(
        &mut self,
        request: tli::proto::trading::GetPositionRiskRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetPositionRiskResponse>> {
        self.client
            .get_position_risk(request)
            .await
            .context("Failed to get position risk")
    }

    /// Validate order
    pub async fn validate_order(
        &mut self,
        request: tli::proto::trading::ValidateOrderRequest,
    ) -> Result<tonic::Response<tli::proto::trading::ValidateOrderResponse>> {
        self.client
            .validate_order(request)
            .await
            .context("Failed to validate order")
    }

    /// Get risk metrics
    pub async fn get_risk_metrics(
        &mut self,
        request: tli::proto::trading::GetRiskMetricsRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetRiskMetricsResponse>> {
        self.client
            .get_risk_metrics(request)
            .await
            .context("Failed to get risk metrics")
    }

    /// Subscribe to risk alerts
    pub async fn subscribe_risk_alerts(
        &mut self,
        request: tli::proto::trading::SubscribeRiskAlertsRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::RiskAlertEvent>>> {
        self.client
            .subscribe_risk_alerts(request)
            .await
            .context("Failed to subscribe to risk alerts")
    }

    /// Emergency stop
    pub async fn emergency_stop(
        &mut self,
        request: tli::proto::trading::EmergencyStopRequest,
    ) -> Result<tonic::Response<tli::proto::trading::EmergencyStopResponse>> {
        warn!("🚨 TRIGGERING EMERGENCY STOP");

        self.client
            .emergency_stop(request)
            .await
            .context("Failed to trigger emergency stop")
    }

    /// Get metrics
    pub async fn get_metrics(
        &mut self,
        request: tli::proto::trading::GetMetricsRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetMetricsResponse>> {
        self.client
            .get_metrics(request)
            .await
            .context("Failed to get metrics")
    }

    /// Get latency
    pub async fn get_latency(
        &mut self,
        request: tli::proto::trading::GetLatencyRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetLatencyResponse>> {
        self.client
            .get_latency(request)
            .await
            .context("Failed to get latency")
    }

    /// Get throughput
    pub async fn get_throughput(
        &mut self,
        request: tli::proto::trading::GetThroughputRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetThroughputResponse>> {
        self.client
            .get_throughput(request)
            .await
            .context("Failed to get throughput")
    }

    /// Subscribe to metrics
    pub async fn subscribe_metrics(
        &mut self,
        request: tli::proto::trading::SubscribeMetricsRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::MetricsEvent>>> {
        self.client
            .subscribe_metrics(request)
            .await
            .context("Failed to subscribe to metrics")
    }

    /// Update parameters
    pub async fn update_parameters(
        &mut self,
        request: tli::proto::trading::UpdateParametersRequest,
    ) -> Result<tonic::Response<tli::proto::trading::UpdateParametersResponse>> {
        debug!("Updating {} parameters", request.parameters.len());

        self.client
            .update_parameters(request)
            .await
            .context("Failed to update parameters")
    }

    /// Get config
    pub async fn get_config(
        &mut self,
        request: tli::proto::trading::GetConfigRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetConfigResponse>> {
        self.client
            .get_config(request)
            .await
            .context("Failed to get config")
    }

    /// Subscribe to config changes
    pub async fn subscribe_config(
        &mut self,
        request: tli::proto::trading::SubscribeConfigRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::ConfigEvent>>> {
        self.client
            .subscribe_config(request)
            .await
            .context("Failed to subscribe to config")
    }

    /// Get system status
    pub async fn get_system_status(
        &mut self,
        request: tli::proto::trading::GetSystemStatusRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetSystemStatusResponse>> {
        self.client
            .get_system_status(request)
            .await
            .context("Failed to get system status")
    }

    /// Subscribe to system status
    pub async fn subscribe_system_status(
        &mut self,
        request: tli::proto::trading::SubscribeSystemStatusRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::SystemStatusEvent>>> {
        self.client
            .subscribe_system_status(request)
            .await
            .context("Failed to subscribe to system status")
    }
}

/// Backtesting Service gRPC Client
#[derive(Debug, Clone)]
pub struct BacktestingServiceClient {
    client: tli::proto::trading::backtesting_service_client::BacktestingServiceClient<Channel>,
    endpoint: String,
}

impl BacktestingServiceClient {
    /// Create a new Backtesting Service client
    pub async fn new(endpoint: &str) -> Result<Self> {
        info!("🔌 Connecting to Backtesting Service at {}", endpoint);

        let channel = Endpoint::from_shared(endpoint.to_string())?
            .timeout(Duration::from_secs(30))
            .connect_timeout(Duration::from_secs(10))
            .connect()
            .await
            .context("Failed to connect to Backtesting Service")?;

        let client =
            tli::proto::trading::backtesting_service_client::BacktestingServiceClient::new(channel);

        Ok(Self {
            client,
            endpoint: endpoint.to_string(),
        })
    }

    /// Start backtest
    pub async fn start_backtest(
        &mut self,
        request: tli::proto::trading::StartBacktestRequest,
    ) -> Result<tonic::Response<tli::proto::trading::StartBacktestResponse>> {
        debug!("Starting backtest: {}", request.strategy_name);

        self.client
            .start_backtest(request)
            .await
            .context("Failed to start backtest")
    }

    /// Get backtest status
    pub async fn get_backtest_status(
        &mut self,
        request: tli::proto::trading::GetBacktestStatusRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetBacktestStatusResponse>> {
        self.client
            .get_backtest_status(request)
            .await
            .context("Failed to get backtest status")
    }

    /// Get backtest results
    pub async fn get_backtest_results(
        &mut self,
        request: tli::proto::trading::GetBacktestResultsRequest,
    ) -> Result<tonic::Response<tli::proto::trading::GetBacktestResultsResponse>> {
        self.client
            .get_backtest_results(request)
            .await
            .context("Failed to get backtest results")
    }

    /// List backtests
    pub async fn list_backtests(
        &mut self,
        request: tli::proto::trading::ListBacktestsRequest,
    ) -> Result<tonic::Response<tli::proto::trading::ListBacktestsResponse>> {
        self.client
            .list_backtests(request)
            .await
            .context("Failed to list backtests")
    }

    /// Subscribe to backtest progress
    pub async fn subscribe_backtest_progress(
        &mut self,
        request: tli::proto::trading::SubscribeBacktestProgressRequest,
    ) -> Result<tonic::Response<tonic::Streaming<tli::proto::trading::BacktestProgressEvent>>> {
        debug!("Subscribing to backtest progress: {}", request.backtest_id);

        self.client
            .subscribe_backtest_progress(request)
            .await
            .context("Failed to subscribe to backtest progress")
    }

    /// Stop backtest
    pub async fn stop_backtest(
        &mut self,
        request: tli::proto::trading::StopBacktestRequest,
    ) -> Result<tonic::Response<tli::proto::trading::StopBacktestResponse>> {
        debug!("Stopping backtest: {}", request.backtest_id);

        self.client
            .stop_backtest(request)
            .await
            .context("Failed to stop backtest")
    }
}

/// Configuration Service Client (Database-backed)
#[derive(Debug)]
pub struct ConfigServiceClient {
    pool: sqlx::PgPool,
}

impl ConfigServiceClient {
    /// Create a new Configuration Service client
    pub async fn new() -> Result<Self> {
        info!("🔌 Connecting to Configuration Service (PostgreSQL)");

        let database_url = std::env::var("DATABASE_URL")
            .unwrap_or_else(|_| "postgresql://localhost/foxhunt".to_string());

        let pool = sqlx::postgres::PgPoolOptions::new()
            .max_connections(5)
            .connect(&database_url)
            .await
            .context("Failed to connect to configuration database")?;

        Ok(Self { pool })
    }

    /// Get configuration value
    pub async fn get_config(&self, key: &str) -> Result<Option<String>> {
        let row = sqlx::query!("SELECT value FROM configuration WHERE key = $1", key)
            .fetch_optional(&self.pool)
            .await
            .context("Failed to query configuration")?;

        Ok(row.map(|r| r.value))
    }

    /// Set configuration value
    pub async fn set_config(&self, key: &str, value: &str) -> Result<()> {
        sqlx::query!(
            "INSERT INTO configuration (key, value) VALUES ($1, $2)
             ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()",
            key,
            value
        )
        .execute(&self.pool)
        .await
        .context("Failed to set configuration")?;

        // Trigger NOTIFY for hot reload
        sqlx::query!("NOTIFY config_change, $1", key)
            .execute(&self.pool)
            .await
            .context("Failed to notify configuration change")?;

        Ok(())
    }

    /// Get all configuration values
    pub async fn get_all_config(&self) -> Result<std::collections::HashMap<String, String>> {
        let rows = sqlx::query!("SELECT key, value FROM configuration")
            .fetch_all(&self.pool)
            .await
            .context("Failed to query all configuration")?;

        Ok(rows.into_iter().map(|r| (r.key, r.value)).collect())
    }

    /// Delete configuration value
    pub async fn delete_config(&self, key: &str) -> Result<bool> {
        let result = sqlx::query!("DELETE FROM configuration WHERE key = $1", key)
            .execute(&self.pool)
            .await
            .context("Failed to delete configuration")?;

        if result.rows_affected() > 0 {
            // Trigger NOTIFY for hot reload
            sqlx::query!("NOTIFY config_change, $1", key)
                .execute(&self.pool)
                .await
                .context("Failed to notify configuration change")?;

            Ok(true)
        } else {
            Ok(false)
        }
    }
}

/// Health check for gRPC clients
pub async fn check_grpc_health(endpoint: &str) -> Result<bool> {
    use tokio::net::TcpStream;
    use tonic::transport::Uri;

    // Parse endpoint to get host and port
    let uri: Uri = endpoint.parse().context("Invalid endpoint URI")?;
    let host = uri.host().unwrap_or("localhost");
    let port = uri.port_u16().unwrap_or(50051);

    match TcpStream::connect((host, port)).await {
        Ok(_) => {
            debug!("Health check passed for {}", endpoint);
            Ok(true)
        }
        Err(e) => {
            debug!("Health check failed for {}: {}", endpoint, e);
            Ok(false)
        }
    }
}

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

    #[tokio::test]
    async fn test_grpc_health_check() {
        // This should fail since no service is running
        let health = check_grpc_health("http://localhost:50051").await.unwrap();
        // Don't assert on the result since services may or may not be running
        println!("Health check result: {}", health);
    }

    #[test]
    fn test_endpoint_parsing() {
        let endpoint = "http://localhost:50051";
        let uri: tonic::transport::Uri = endpoint.parse().unwrap();
        assert_eq!(uri.host().unwrap(), "localhost");
        assert_eq!(uri.port_u16().unwrap(), 50051);
    }
}