foxhunt/tli/tests/mocks/grpc_server.rs

//! Mock gRPC server implementations for testing TLI client functionality
//!
//! This module provides comprehensive mock servers that simulate the core
//! trading services for testing purposes, including realistic responses,
//! error scenarios, and streaming capabilities.

use std::collections::HashMap;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use tokio::sync::mpsc;
use tokio_stream::{wrappers::ReceiverStream, Stream};
use tonic::{transport::Server, Request, Response, Status};

// Import the generated protobuf types
use tli::proto::trading::{
    backtesting_service_server::{BacktestingService, BacktestingServiceServer},
    trading_service_server::{TradingService, TradingServiceServer},
    *,
};

use tli::proto::health::{
    health_check_response::ServingStatus,
    health_server::{Health, HealthServer},
    HealthCheckRequest, HealthCheckResponse,
};

/// Mock trading service that simulates ALL operations including monitoring and config
#[derive(Debug, Default)]
pub struct MockTradingService {
    orders: Arc<Mutex<HashMap<String, GetOrderStatusResponse>>>,
    positions: Arc<Mutex<Vec<Position>>>,
    order_counter: Arc<Mutex<u64>>,
    metrics: Arc<Mutex<HashMap<String, Metric>>>,
    config: Arc<Mutex<HashMap<String, String>>>,
}

impl MockTradingService {
    pub fn new() -> Self {
        let service = Self::default();

        // Pre-populate with test data
        let mut metrics = service.metrics.lock().unwrap();
        metrics.insert(
            "orders_per_second".to_string(),
            Metric {
                name: "orders_per_second".to_string(),
                value: 150.0,
                unit: "ops/sec".to_string(),
                labels: HashMap::from([("service".to_string(), "trading_engine".to_string())]),
                timestamp_unix_nanos: Self::current_timestamp_nanos(),
            },
        );
        drop(metrics);

        let mut config = service.config.lock().unwrap();
        config.insert("max_order_size".to_string(), "10000.0".to_string());
        config.insert("trading_enabled".to_string(), "true".to_string());
        drop(config);

        service
    }

    fn generate_order_id(&self) -> String {
        let mut counter = self.order_counter.lock().unwrap();
        *counter += 1;
        format!("ORDER_{:06}", *counter)
    }

    fn current_timestamp_nanos() -> i64 {
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos() as i64
    }
}

#[tonic::async_trait]
impl TradingService for MockTradingService {
    // Order Management
    async fn submit_order(
        &self,
        request: Request<SubmitOrderRequest>,
    ) -> Result<Response<SubmitOrderResponse>, Status> {
        let req = request.into_inner();

        if req.symbol.is_empty() {
            return Err(Status::invalid_argument("Symbol cannot be empty"));
        }

        if req.quantity <= 0.0 {
            return Err(Status::invalid_argument("Quantity must be positive"));
        }

        let order_id = self.generate_order_id();

        Ok(Response::new(SubmitOrderResponse {
            success: true,
            order_id,
            message: "Order submitted successfully".to_string(),
            timestamp_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    async fn cancel_order(
        &self,
        request: Request<CancelOrderRequest>,
    ) -> Result<Response<CancelOrderResponse>, Status> {
        let req = request.into_inner();

        if req.order_id.is_empty() {
            return Err(Status::invalid_argument("Order ID cannot be empty"));
        }

        Ok(Response::new(CancelOrderResponse {
            success: true,
            message: "Order cancelled successfully".to_string(),
            timestamp_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    async fn get_order_status(
        &self,
        request: Request<GetOrderStatusRequest>,
    ) -> Result<Response<GetOrderStatusResponse>, Status> {
        let req = request.into_inner();

        if req.order_id.is_empty() {
            return Err(Status::invalid_argument("Order ID cannot be empty"));
        }

        Ok(Response::new(GetOrderStatusResponse {
            order_id: req.order_id,
            symbol: "AAPL".to_string(),
            side: OrderSide::Buy as i32,
            order_type: OrderType::Limit as i32,
            quantity: 100.0,
            filled_quantity: 50.0,
            remaining_quantity: 50.0,
            average_price: 150.0,
            status: OrderStatus::PartiallyFilled as i32,
            created_at_unix_nanos: Self::current_timestamp_nanos(),
            updated_at_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    async fn get_account_info(
        &self,
        _request: Request<GetAccountInfoRequest>,
    ) -> Result<Response<GetAccountInfoResponse>, Status> {
        Ok(Response::new(GetAccountInfoResponse {
            account_id: "TEST_ACCOUNT".to_string(),
            total_value: 100000.0,
            cash_balance: 50000.0,
            buying_power: 75000.0,
            maintenance_margin: 5000.0,
            day_trading_buying_power: 200000.0,
        }))
    }

    async fn get_positions(
        &self,
        _request: Request<GetPositionsRequest>,
    ) -> Result<Response<GetPositionsResponse>, Status> {
        let positions = vec![Position {
            symbol: "AAPL".to_string(),
            quantity: 100.0,
            market_price: 150.0,
            market_value: 15000.0,
            average_cost: 145.0,
            unrealized_pnl: 500.0,
            realized_pnl: 200.0,
        }];

        Ok(Response::new(GetPositionsResponse { positions }))
    }

    // Market Data Streaming
    type SubscribeMarketDataStream =
        Pin<Box<dyn Stream<Item = Result<MarketDataEvent, Status>> + Send>>;

    async fn subscribe_market_data(
        &self,
        _request: Request<SubscribeMarketDataRequest>,
    ) -> Result<Response<Self::SubscribeMarketDataStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            for i in 1..=5 {
                let event = MarketDataEvent {
                    event: Some(market_data_event::Event::Tick(TickData {
                        symbol: "AAPL".to_string(),
                        timestamp_unix_nanos: Self::current_timestamp_nanos(),
                        price: 150.0 + i as f64,
                        size: 100,
                        exchange: "NASDAQ".to_string(),
                    })),
                };

                if tx.send(Ok(event)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(100)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }

    // Order Updates Streaming
    type SubscribeOrderUpdatesStream =
        Pin<Box<dyn Stream<Item = Result<OrderUpdateEvent, Status>> + Send>>;

    async fn subscribe_order_updates(
        &self,
        _request: Request<SubscribeOrderUpdatesRequest>,
    ) -> Result<Response<Self::SubscribeOrderUpdatesStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            for i in 1..=3 {
                let event = OrderUpdateEvent {
                    order_id: format!("ORDER_{}", i),
                    symbol: "AAPL".to_string(),
                    status: OrderStatus::Filled as i32,
                    filled_quantity: 100.0,
                    remaining_quantity: 0.0,
                    last_fill_price: 150.0,
                    last_fill_quantity: 100,
                    timestamp_unix_nanos: Self::current_timestamp_nanos(),
                    message: "Order filled".to_string(),
                };

                if tx.send(Ok(event)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(100)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }

    // Integrated Monitoring Methods
    async fn get_metrics(
        &self,
        _request: Request<GetMetricsRequest>,
    ) -> Result<Response<GetMetricsResponse>, Status> {
        let metrics = self.metrics.lock().unwrap();
        let metric_list: Vec<Metric> = metrics.values().cloned().collect();

        Ok(Response::new(GetMetricsResponse {
            metrics: metric_list,
            timestamp_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    async fn get_latency(
        &self,
        _request: Request<GetLatencyRequest>,
    ) -> Result<Response<GetLatencyResponse>, Status> {
        Ok(Response::new(GetLatencyResponse {
            p50_micros: 10.0,
            p95_micros: 25.0,
            p99_micros: 50.0,
            p999_micros: 100.0,
            avg_micros: 15.0,
            max_micros: 150.0,
            min_micros: 5.0,
            sample_count: 1000,
        }))
    }

    async fn get_throughput(
        &self,
        _request: Request<GetThroughputRequest>,
    ) -> Result<Response<GetThroughputResponse>, Status> {
        Ok(Response::new(GetThroughputResponse {
            requests_per_second: 1000.0,
            bytes_per_second: 50000.0,
            total_requests: 100000,
            total_bytes: 5000000,
            error_count: 10,
            error_rate: 0.01,
        }))
    }

    // Metrics Streaming
    type SubscribeMetricsStream = Pin<Box<dyn Stream<Item = Result<MetricsEvent, Status>> + Send>>;

    async fn subscribe_metrics(
        &self,
        _request: Request<SubscribeMetricsRequest>,
    ) -> Result<Response<Self::SubscribeMetricsStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            for i in 1..=5 {
                let event = MetricsEvent {
                    metrics: vec![Metric {
                        name: "live_orders".to_string(),
                        value: i as f64 * 10.0,
                        unit: "count".to_string(),
                        labels: HashMap::new(),
                        timestamp_unix_nanos: Self::current_timestamp_nanos(),
                    }],
                    timestamp_unix_nanos: Self::current_timestamp_nanos(),
                };

                if tx.send(Ok(event)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(100)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }

    // Integrated Configuration Methods
    async fn get_config(
        &self,
        request: Request<GetConfigRequest>,
    ) -> Result<Response<GetConfigResponse>, Status> {
        let req = request.into_inner();
        let config = self.config.lock().unwrap();

        let mut result_config = HashMap::new();

        if req.keys.is_empty() {
            // Return all config
            result_config = config.clone();
        } else {
            // Return requested keys
            for key in req.keys {
                if let Some(value) = config.get(&key) {
                    result_config.insert(key, value.clone());
                }
            }
        }

        Ok(Response::new(GetConfigResponse {
            config: result_config,
            version: 1,
            last_updated_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    async fn update_parameters(
        &self,
        request: Request<UpdateParametersRequest>,
    ) -> Result<Response<UpdateParametersResponse>, Status> {
        let req = request.into_inner();

        let mut config = self.config.lock().unwrap();
        let mut updated_keys = Vec::new();

        for (key, value) in req.parameters {
            config.insert(key.clone(), value);
            updated_keys.push(key);
        }

        Ok(Response::new(UpdateParametersResponse {
            success: true,
            message: "Parameters updated successfully".to_string(),
            updated_keys,
        }))
    }

    // Config Streaming
    type SubscribeConfigStream = Pin<Box<dyn Stream<Item = Result<ConfigEvent, Status>> + Send>>;

    async fn subscribe_config(
        &self,
        _request: Request<SubscribeConfigRequest>,
    ) -> Result<Response<Self::SubscribeConfigStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            let configs = [
                ("trading_enabled", "true", "false"),
                ("max_order_size", "10000.0", "15000.0"),
            ];

            for (key, old_value, new_value) in configs.iter() {
                let event = ConfigEvent {
                    key: key.to_string(),
                    value: new_value.to_string(),
                    old_value: old_value.to_string(),
                    timestamp_unix_nanos: Self::current_timestamp_nanos(),
                };

                if tx.send(Ok(event)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(200)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }

    // System Status
    async fn get_system_status(
        &self,
        _request: Request<GetSystemStatusRequest>,
    ) -> Result<Response<GetSystemStatusResponse>, Status> {
        let services = vec![ServiceStatus {
            name: "trading_engine".to_string(),
            status: SystemStatus::Healthy as i32,
            message: "All systems operational".to_string(),
            last_check_unix_nanos: Self::current_timestamp_nanos(),
            details: HashMap::from([("uptime".to_string(), "99.99%".to_string())]),
        }];

        Ok(Response::new(GetSystemStatusResponse {
            overall_status: SystemStatus::Healthy as i32,
            services,
            timestamp_unix_nanos: Self::current_timestamp_nanos(),
        }))
    }

    // System Status Streaming
    type SubscribeSystemStatusStream =
        Pin<Box<dyn Stream<Item = Result<SystemStatusEvent, Status>> + Send>>;

    async fn subscribe_system_status(
        &self,
        _request: Request<SubscribeSystemStatusRequest>,
    ) -> Result<Response<Self::SubscribeSystemStatusStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            let statuses = [
                SystemStatus::Healthy,
                SystemStatus::Degraded,
                SystemStatus::Healthy,
            ];

            for (i, status) in statuses.iter().enumerate() {
                let event = SystemStatusEvent {
                    service_name: "trading_engine".to_string(),
                    status: *status as i32,
                    previous_status: if i > 0 {
                        statuses[i - 1] as i32
                    } else {
                        SystemStatus::Healthy as i32
                    },
                    message: format!("Status update {}", i + 1),
                    timestamp_unix_nanos: Self::current_timestamp_nanos(),
                };

                if tx.send(Ok(event)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(300)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }

    // Risk Management - Stubs
    async fn get_va_r(
        &self,
        _request: Request<GetVaRRequest>,
    ) -> Result<Response<GetVaRResponse>, Status> {
        Err(Status::unimplemented("get_var"))
    }

    async fn get_position_risk(
        &self,
        _request: Request<GetPositionRiskRequest>,
    ) -> Result<Response<GetPositionRiskResponse>, Status> {
        Err(Status::unimplemented("get_position_risk"))
    }

    async fn validate_order(
        &self,
        _request: Request<ValidateOrderRequest>,
    ) -> Result<Response<ValidateOrderResponse>, Status> {
        Err(Status::unimplemented("validate_order"))
    }

    async fn get_risk_metrics(
        &self,
        _request: Request<GetRiskMetricsRequest>,
    ) -> Result<Response<GetRiskMetricsResponse>, Status> {
        Err(Status::unimplemented("get_risk_metrics"))
    }

    type SubscribeRiskAlertsStream =
        Pin<Box<dyn Stream<Item = Result<RiskAlertEvent, Status>> + Send>>;

    async fn subscribe_risk_alerts(
        &self,
        _request: Request<SubscribeRiskAlertsRequest>,
    ) -> Result<Response<Self::SubscribeRiskAlertsStream>, Status> {
        Err(Status::unimplemented("subscribe_risk_alerts"))
    }

    async fn emergency_stop(
        &self,
        _request: Request<EmergencyStopRequest>,
    ) -> Result<Response<EmergencyStopResponse>, Status> {
        Err(Status::unimplemented("emergency_stop"))
    }
}

/// Mock backtesting service
#[derive(Debug, Default)]
pub struct MockBacktestingService;

#[tonic::async_trait]
impl BacktestingService for MockBacktestingService {
    async fn start_backtest(
        &self,
        _request: Request<StartBacktestRequest>,
    ) -> Result<Response<StartBacktestResponse>, Status> {
        Ok(Response::new(StartBacktestResponse {
            success: true,
            backtest_id: "BACKTEST_001".to_string(),
            message: "Backtest started successfully".to_string(),
            estimated_duration_seconds: 300,
        }))
    }

    async fn get_backtest_status(
        &self,
        _request: Request<GetBacktestStatusRequest>,
    ) -> Result<Response<GetBacktestStatusResponse>, Status> {
        Ok(Response::new(GetBacktestStatusResponse {
            backtest_id: "BACKTEST_001".to_string(),
            status: BacktestStatus::Running as i32,
            progress_percent: 75.0,
            current_date: "2024-01-15".to_string(),
            trades_executed: 150,
            current_pnl: 2500.0,
            started_at_unix_nanos: MockTradingService::current_timestamp_nanos(),
            completed_at_unix_nanos: None,
            error_message: None,
        }))
    }

    async fn get_backtest_results(
        &self,
        _request: Request<GetBacktestResultsRequest>,
    ) -> Result<Response<GetBacktestResultsResponse>, Status> {
        Err(Status::unimplemented("get_backtest_results"))
    }

    async fn list_backtests(
        &self,
        _request: Request<ListBacktestsRequest>,
    ) -> Result<Response<ListBacktestsResponse>, Status> {
        Err(Status::unimplemented("list_backtests"))
    }

    type SubscribeBacktestProgressStream =
        Pin<Box<dyn Stream<Item = Result<BacktestProgressEvent, Status>> + Send>>;

    async fn subscribe_backtest_progress(
        &self,
        _request: Request<SubscribeBacktestProgressRequest>,
    ) -> Result<Response<Self::SubscribeBacktestProgressStream>, Status> {
        Err(Status::unimplemented("subscribe_backtest_progress"))
    }

    async fn stop_backtest(
        &self,
        _request: Request<StopBacktestRequest>,
    ) -> Result<Response<StopBacktestResponse>, Status> {
        Err(Status::unimplemented("stop_backtest"))
    }
}

/// Mock health service
#[derive(Debug, Default)]
pub struct MockHealthService;

#[tonic::async_trait]
impl Health for MockHealthService {
    async fn check(
        &self,
        _request: Request<HealthCheckRequest>,
    ) -> Result<Response<HealthCheckResponse>, Status> {
        Ok(Response::new(HealthCheckResponse {
            status: ServingStatus::Serving as i32,
        }))
    }

    type WatchStream = Pin<Box<dyn Stream<Item = Result<HealthCheckResponse, Status>> + Send>>;

    async fn watch(
        &self,
        _request: Request<HealthCheckRequest>,
    ) -> Result<Response<Self::WatchStream>, Status> {
        let (tx, rx) = mpsc::channel(128);

        tokio::spawn(async move {
            for _ in 0..3 {
                let response = HealthCheckResponse {
                    status: ServingStatus::Serving as i32,
                };

                if tx.send(Ok(response)).await.is_err() {
                    break;
                }

                tokio::time::sleep(Duration::from_millis(500)).await;
            }
        });

        let stream = ReceiverStream::new(rx);
        Ok(Response::new(Box::pin(stream)))
    }
}

/// Mock server manager for integration tests
pub struct MockGrpcServer {
    pub address: String,
    pub port: u16,
}

impl MockGrpcServer {
    /// Start a mock gRPC server with all services
    pub async fn start(port: u16) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
        let address = format!("127.0.0.1:{}", port);
        let addr = address.parse()?;

        let trading_service = MockTradingService::new();
        let backtesting_service = MockBacktestingService::default();
        let health_service = MockHealthService::default();

        tokio::spawn(async move {
            let result = Server::builder()
                .add_service(TradingServiceServer::new(trading_service))
                .add_service(BacktestingServiceServer::new(backtesting_service))
                .add_service(HealthServer::new(health_service))
                .serve(addr)
                .await;

            if let Err(e) = result {
                eprintln!("Mock server error: {}", e);
            }
        });

        // Give the server time to start
        tokio::time::sleep(Duration::from_millis(100)).await;

        Ok(Self {
            address: format!("http://{}", address),
            port,
        })
    }
}