foxhunt/tli/tests/integration/end_to_end_tests.rs

//! End-to-end integration tests for TLI system
//!
//! This module tests complete workflows including order lifecycle management,
//! backtesting workflows, configuration management, and security authentication flows.

use chrono::{DateTime, Utc};
use fake::{Fake, Faker};
use std::collections::HashMap;
use std::time::Duration;
use tokio::time::{sleep, timeout};
use uuid::Uuid;

use crate::integration::{TestConfig, TestUtilities};
use crate::mocks::grpc_server::{MockBacktestingServer, MockRiskServer, MockTradingServer};
// Auth types removed - TLI is pure client
// use tli::auth::{AuthenticationManager, RbacManager, SessionManager};
use tli::client::{TliClientBuilder, TliClientSuite};
// Database imports removed - TLI is pure client
use tli::prelude::*;

/// End-to-end test environment
pub struct EndToEndTestEnvironment {
    config: TestConfig,
    client_suite: Option<TliClientSuite>,
    mock_servers: Vec<Box<dyn MockServer>>,
    // Auth managers removed - TLI is pure client
    // auth_manager: Option<AuthenticationManager>,
    // session_manager: Option<SessionManager>,
    config_manager: Option<ConfigurationManager>,
}

impl EndToEndTestEnvironment {
    pub fn new(config: TestConfig) -> Self {
        Self {
            config,
            client_suite: None,
            mock_servers: Vec::new(),
            // Auth managers removed - TLI is pure client
            // auth_manager: None,
            // session_manager: None,
            config_manager: None,
        }
    }

    /// Setup complete end-to-end test environment
    pub async fn setup(&mut self) -> TliResult<()> {
        tracing::info!("Setting up end-to-end test environment");

        // Start mock services
        self.start_mock_services().await?;

        // Setup authentication and session management - DISABLED (TLI is pure client)
        // self.setup_auth_services().await?;

        // Setup configuration management
        self.setup_config_management().await?;

        // Create TLI client suite
        self.setup_client_suite().await?;

        tracing::info!("End-to-end test environment setup complete");
        Ok(())
    }

    async fn start_mock_services(&mut self) -> TliResult<()> {
        let base_port = self.config.mock_server_port;

        // Start trading service
        let mut trading_server = MockTradingServer::new(base_port)?;
        trading_server.start()?;
        self.mock_servers.push(Box::new(trading_server));

        // Start backtesting service
        let mut backtesting_server = MockBacktestingServer::new(base_port + 10)?;
        backtesting_server.start()?;
        self.mock_servers.push(Box::new(backtesting_server));

        // Start risk management service
        let mut risk_server = MockRiskServer::new(base_port + 20)?;
        risk_server.start()?;
        self.mock_servers.push(Box::new(risk_server));

        // Wait for services to be ready
        sleep(Duration::from_millis(500)).await;

        Ok(())
    }

    // Auth setup disabled - TLI is pure client
    // async fn setup_auth_services(&mut self) -> TliResult<()> { ... }

    async fn setup_config_management(&mut self) -> TliResult<()> {
        // Create temporary database for testing
        let temp_dir = tempfile::TempDir::new().map_err(|e| TliError::Database(e.to_string()))?;
        let db_path = temp_dir.path().join("test_config.db");
        let db_url = format!("sqlite:{}", db_path.display());

        let config_db_config = DatabaseConfig {
            url: db_url,
            max_connections: 5,
            connection_timeout: Duration::from_secs(10),
            idle_timeout: Some(Duration::from_secs(300)),
            max_lifetime: Some(Duration::from_secs(1800)),
        };

        self.config_manager = Some(ConfigurationManager::new(config_db_config).await?);

        Ok(())
    }

    async fn setup_client_suite(&mut self) -> TliResult<()> {
        let base_port = self.config.mock_server_port;

        let client_suite = TliClientBuilder::new()
            .with_service_endpoint(
                "trading_service".to_string(),
                format!("http://localhost:{}", base_port),
            )
            .with_service_endpoint(
                "backtesting_service".to_string(),
                format!("http://localhost:{}", base_port + 10),
            )
            .with_service_endpoint(
                "risk_service".to_string(),
                format!("http://localhost:{}", base_port + 20),
            )
            .with_trading_config(TradingClientConfig::default())
            .with_backtesting_config(BacktestingClientConfig::default())
            .build()
            .await?;

        self.client_suite = Some(client_suite);

        Ok(())
    }

    /// Cleanup test environment
    pub async fn teardown(&mut self) -> TliResult<()> {
        tracing::info!("Tearing down end-to-end test environment");

        // Shutdown client suite
        if let Some(client_suite) = self.client_suite.take() {
            client_suite.shutdown().await;
        }

        // Stop mock servers
        for server in &mut self.mock_servers {
            let _ = server.stop();
        }
        self.mock_servers.clear();

        tracing::info!("End-to-end test environment teardown complete");
        Ok(())
    }

    pub fn get_trading_client(&self) -> &TradingClient {
        self.client_suite
            .as_ref()
            .expect("Client suite not initialized")
            .trading_client
            .as_ref()
            .expect("Trading client not available")
    }

    pub fn get_backtesting_client(&self) -> &BacktestingClient {
        self.client_suite
            .as_ref()
            .expect("Client suite not initialized")
            .backtesting_client
            .as_ref()
            .expect("Backtesting client not available")
    }
}

/// Complete order lifecycle tests
#[cfg(test)]
mod order_lifecycle_tests {
    use super::*;

    #[tokio::test]
    async fn test_complete_order_lifecycle() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();
        let symbol = TestUtilities::generate_test_symbol("AAPL");
        let client_order_id = Uuid::new_v4().to_string();

        // Step 1: Pre-trade risk check
        let risk_check_request = PreTradeRiskCheckRequest {
            symbol: symbol.clone(),
            side: OrderSide::Buy as i32,
            quantity: 100.0,
            estimated_price: Some(150.0),
            order_type: OrderType::Limit as i32,
            account_id: "test_account".to_string(),
        };

        let risk_response = trading_client
            .check_pre_trade_risk(risk_check_request)
            .await
            .expect("Failed to perform pre-trade risk check");

        assert!(risk_response.approved, "Order should pass risk checks");
        tracing::info!(
            "Pre-trade risk check passed with score: {}",
            risk_response.risk_score
        );

        // Step 2: Submit order
        let order_request = SubmitOrderRequest {
            symbol: symbol.clone(),
            side: OrderSide::Buy as i32,
            order_type: OrderType::Limit as i32,
            quantity: 100.0,
            price: Some(150.0),
            stop_price: None,
            time_in_force: "DAY".to_string(),
            client_order_id: client_order_id.clone(),
        };

        let submit_response = trading_client
            .submit_order(order_request)
            .await
            .expect("Failed to submit order");

        assert!(submit_response.success, "Order submission should succeed");
        assert!(
            !submit_response.order_id.is_empty(),
            "Order ID should be provided"
        );

        let order_id = submit_response.order_id.clone();
        tracing::info!("Order submitted successfully: {}", order_id);

        // Step 3: Monitor order status
        let mut order_status = OrderStatus::Pending;
        let mut status_checks = 0;
        let max_status_checks = 10;

        while status_checks < max_status_checks && order_status != OrderStatus::Filled {
            let status_request = GetOrderStatusRequest {
                order_id: order_id.clone(),
                include_fills: true,
            };

            let status_response = trading_client
                .get_order_status(status_request)
                .await
                .expect("Failed to get order status");

            order_status =
                OrderStatus::from_i32(status_response.status).unwrap_or(OrderStatus::Unknown);

            tracing::info!(
                "Order status check {}: {:?}",
                status_checks + 1,
                order_status
            );

            if order_status == OrderStatus::Filled {
                assert!(
                    !status_response.fills.is_empty(),
                    "Filled order should have fills"
                );
                break;
            }

            status_checks += 1;
            sleep(Duration::from_millis(100)).await;
        }

        // Step 4: Check position update
        let position_request = GetPositionsRequest {
            account_id: Some("test_account".to_string()),
            symbol_filter: Some(symbol.clone()),
            include_zero_positions: false,
        };

        let positions_response = trading_client
            .get_positions(position_request)
            .await
            .expect("Failed to get positions");

        let position = positions_response
            .positions
            .iter()
            .find(|p| p.symbol == symbol)
            .expect("Should have position for traded symbol");

        assert!(
            position.quantity > 0.0,
            "Position quantity should be positive after buy"
        );
        tracing::info!(
            "Position updated: {} shares of {}",
            position.quantity,
            symbol
        );

        // Step 5: Check portfolio analytics
        let analytics_request = PortfolioAnalyticsRequest {
            account_id: "test_account".to_string(),
            calculation_date: Utc::now().timestamp(),
            include_realized_pnl: true,
            include_unrealized_pnl: true,
            include_risk_metrics: true,
        };

        let analytics_response = trading_client
            .get_portfolio_analytics(analytics_request)
            .await
            .expect("Failed to get portfolio analytics");

        assert!(
            analytics_response.total_portfolio_value.is_some(),
            "Portfolio value should be calculated"
        );
        tracing::info!("Portfolio analytics updated successfully");

        // Step 6: Place offsetting order (sell)
        let sell_request = SubmitOrderRequest {
            symbol: symbol.clone(),
            side: OrderSide::Sell as i32,
            order_type: OrderType::Market as i32,
            quantity: 100.0,
            price: None,
            stop_price: None,
            time_in_force: "DAY".to_string(),
            client_order_id: Uuid::new_v4().to_string(),
        };

        let sell_response = trading_client
            .submit_order(sell_request)
            .await
            .expect("Failed to submit sell order");

        assert!(sell_response.success, "Sell order should succeed");
        tracing::info!(
            "Offsetting sell order submitted: {}",
            sell_response.order_id
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_order_modification_lifecycle() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();
        let symbol = TestUtilities::generate_test_symbol("GOOGL");

        // Submit initial order
        let order_request = SubmitOrderRequest {
            symbol: symbol.clone(),
            side: OrderSide::Buy as i32,
            order_type: OrderType::Limit as i32,
            quantity: 50.0,
            price: Some(2800.0),
            stop_price: None,
            time_in_force: "GTC".to_string(),
            client_order_id: Uuid::new_v4().to_string(),
        };

        let submit_response = trading_client
            .submit_order(order_request)
            .await
            .expect("Failed to submit order");

        let order_id = submit_response.order_id.clone();

        // Modify order price
        let modify_request = ModifyOrderRequest {
            order_id: order_id.clone(),
            new_quantity: Some(75.0),
            new_price: Some(2850.0),
            new_stop_price: None,
        };

        let modify_response = trading_client
            .modify_order(modify_request)
            .await
            .expect("Failed to modify order");

        assert!(modify_response.success, "Order modification should succeed");

        // Verify modification
        let status_request = GetOrderStatusRequest {
            order_id: order_id.clone(),
            include_fills: false,
        };

        let status_response = trading_client
            .get_order_status(status_request)
            .await
            .expect("Failed to get order status");

        assert_eq!(status_response.quantity, 75.0, "Quantity should be updated");
        assert_eq!(
            status_response.price.unwrap(),
            2850.0,
            "Price should be updated"
        );

        // Cancel order
        let cancel_request = CancelOrderRequest {
            order_id: order_id.clone(),
            symbol: symbol.clone(),
        };

        let cancel_response = trading_client
            .cancel_order(cancel_request)
            .await
            .expect("Failed to cancel order");

        assert!(cancel_response.success, "Order cancellation should succeed");

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_batch_order_operations() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();

        // Create batch of orders
        let mut batch_orders = Vec::new();
        let symbols = ["AAPL", "GOOGL", "MSFT", "TSLA", "AMZN"];

        for (i, symbol) in symbols.into_iter().enumerate() {
            batch_orders.push(SubmitOrderRequest {
                symbol: TestUtilities::generate_test_symbol(symbol),
                side: OrderSide::Buy as i32,
                order_type: OrderType::Limit as i32,
                quantity: (i + 1) as f64 * 100.0,
                price: Some(100.0 + (i as f64 * 50.0)),
                stop_price: None,
                time_in_force: "DAY".to_string(),
                client_order_id: Uuid::new_v4().to_string(),
            });
        }

        // Submit batch orders
        let batch_request = SubmitBatchOrdersRequest {
            orders: batch_orders,
            all_or_none: false,
            max_acceptable_failures: 1,
        };

        let batch_response = trading_client
            .submit_batch_orders(batch_request)
            .await
            .expect("Failed to submit batch orders");

        assert!(
            batch_response.success,
            "Batch order submission should succeed"
        );
        assert_eq!(
            batch_response.order_results.len(),
            5,
            "Should have results for all orders"
        );

        // Verify individual order results
        let successful_orders: Vec<_> = batch_response
            .order_results
            .iter()
            .filter(|result| result.success)
            .collect();

        assert!(successful_orders.len() >= 4, "Most orders should succeed");

        // Get batch order status
        let order_ids: Vec<String> = successful_orders
            .iter()
            .map(|result| result.order_id.clone())
            .collect();

        let batch_status_request = GetBatchOrderStatusRequest {
            order_ids: order_ids.clone(),
        };

        let batch_status_response = trading_client
            .get_batch_order_status(batch_status_request)
            .await
            .expect("Failed to get batch order status");

        assert_eq!(
            batch_status_response.order_statuses.len(),
            order_ids.len(),
            "Should have status for all orders"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }
}

/// Backtesting workflow tests
#[cfg(test)]
mod backtesting_workflow_tests {
    use super::*;

    #[tokio::test]
    async fn test_complete_backtesting_workflow() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let backtesting_client = test_env.get_backtesting_client();

        // Step 1: Check data availability
        let data_check_request = CheckDataAvailabilityRequest {
            symbols: vec!["AAPL".to_string(), "GOOGL".to_string()],
            start_date: "2024-01-01".to_string(),
            end_date: "2024-01-31".to_string(),
            data_types: vec![DataType::OHLCV as i32, DataType::Trades as i32],
        };

        let data_availability = backtesting_client
            .check_data_availability(data_check_request)
            .await
            .expect("Failed to check data availability");

        assert!(
            !data_availability.symbol_availability.is_empty(),
            "Should have data availability info"
        );
        tracing::info!(
            "Data availability confirmed for {} symbols",
            data_availability.symbol_availability.len()
        );

        // Step 2: Create backtest configuration
        let mut strategy_parameters = HashMap::new();
        strategy_parameters.insert("lookback_period".to_string(), "20".to_string());
        strategy_parameters.insert("threshold".to_string(), "0.02".to_string());

        let backtest_request = CreateBacktestRequest {
            name: format!("E2E Test Backtest {}", Uuid::new_v4()),
            strategy_id: "mean_reversion_strategy".to_string(),
            start_date: "2024-01-01".to_string(),
            end_date: "2024-01-31".to_string(),
            initial_capital: 100000.0,
            symbols: vec!["AAPL".to_string(), "GOOGL".to_string()],
            parameters: strategy_parameters,
        };

        let create_response = backtesting_client
            .create_backtest(backtest_request)
            .await
            .expect("Failed to create backtest");

        assert!(create_response.success, "Backtest creation should succeed");
        let backtest_id = create_response.backtest_id.clone();
        tracing::info!("Backtest created: {}", backtest_id);

        // Step 3: Start backtest execution
        let start_request = StartBacktestRequest {
            backtest_id: backtest_id.clone(),
            async_execution: true,
        };

        let start_response = backtesting_client
            .start_backtest(start_request)
            .await
            .expect("Failed to start backtest");

        assert!(start_response.success, "Backtest start should succeed");
        tracing::info!("Backtest execution started");

        // Step 4: Monitor backtest progress
        let mut progress_percentage = 0.0;
        let mut status_checks = 0;
        let max_status_checks = 20;

        while status_checks < max_status_checks && progress_percentage < 100.0 {
            let status_request = GetBacktestStatusRequest {
                backtest_id: backtest_id.clone(),
            };

            let status_response = backtesting_client
                .get_backtest_status(status_request)
                .await
                .expect("Failed to get backtest status");

            progress_percentage = status_response.progress_percentage;
            let status =
                BacktestStatus::from_i32(status_response.status).unwrap_or(BacktestStatus::Unknown);

            tracing::info!(
                "Backtest progress: {}%, Status: {:?}",
                progress_percentage,
                status
            );

            if status == BacktestStatus::Completed {
                break;
            }

            if status == BacktestStatus::Failed {
                panic!(
                    "Backtest failed: {}",
                    status_response.error_message.unwrap_or_default()
                );
            }

            status_checks += 1;
            sleep(Duration::from_millis(200)).await;
        }

        // Step 5: Retrieve backtest results
        let results_request = GetBacktestResultsRequest {
            backtest_id: backtest_id.clone(),
            include_trades: true,
            include_metrics: true,
        };

        let results_response = backtesting_client
            .get_backtest_results(results_request)
            .await
            .expect("Failed to get backtest results");

        // Validate results
        assert!(
            results_response.performance_summary.is_some(),
            "Should have performance summary"
        );
        let performance = results_response.performance_summary.unwrap();

        assert!(
            performance.total_return != 0.0,
            "Should have calculated total return"
        );
        assert!(
            performance.sharpe_ratio.is_some(),
            "Should have Sharpe ratio"
        );
        assert!(
            performance.max_drawdown.is_some(),
            "Should have max drawdown"
        );

        assert!(
            !results_response.trades.is_empty(),
            "Should have executed trades"
        );
        tracing::info!(
            "Backtest completed with {} trades",
            results_response.trades.len()
        );

        // Step 6: Generate backtest report
        let report_request = GenerateBacktestReportRequest {
            backtest_id: backtest_id.clone(),
            report_format: ReportFormat::Pdf as i32,
            include_charts: true,
            include_trade_details: true,
        };

        let report_response = backtesting_client
            .generate_backtest_report(report_request)
            .await
            .expect("Failed to generate backtest report");

        assert!(report_response.success, "Report generation should succeed");
        assert!(
            !report_response.report_url.is_empty(),
            "Should have report URL"
        );
        tracing::info!("Backtest report generated: {}", report_response.report_url);

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_strategy_optimization_workflow() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let backtesting_client = test_env.get_backtesting_client();

        // Define parameter ranges for optimization
        let mut parameter_ranges = HashMap::new();
        parameter_ranges.insert(
            "lookback_period".to_string(),
            ParameterRange {
                min_value: 10.0,
                max_value: 50.0,
                step_size: 5.0,
                parameter_type: ParameterType::Integer as i32,
            },
        );

        parameter_ranges.insert(
            "threshold".to_string(),
            ParameterRange {
                min_value: 0.01,
                max_value: 0.05,
                step_size: 0.005,
                parameter_type: ParameterType::Float as i32,
            },
        );

        // Start optimization
        let optimization_request = StrategyOptimizationRequest {
            strategy_id: "mean_reversion_strategy".to_string(),
            start_date: "2024-01-01".to_string(),
            end_date: "2024-02-29".to_string(),
            symbols: vec!["AAPL".to_string()],
            parameter_ranges,
            optimization_metric: OptimizationMetric::SharpeRatio as i32,
            max_iterations: 20,
        };

        let optimization_response = backtesting_client
            .optimize_strategy(optimization_request)
            .await
            .expect("Failed to start strategy optimization");

        assert!(
            optimization_response.success,
            "Optimization should start successfully"
        );
        let optimization_id = optimization_response.optimization_id.clone();
        tracing::info!("Strategy optimization started: {}", optimization_id);

        // Monitor optimization progress
        let mut iterations_completed = 0;
        let mut status_checks = 0;
        let max_status_checks = 30;

        while status_checks < max_status_checks && iterations_completed < 20 {
            let status_request = GetOptimizationStatusRequest {
                optimization_id: optimization_id.clone(),
            };

            let status_response = backtesting_client
                .get_optimization_status(status_request)
                .await
                .expect("Failed to get optimization status");

            iterations_completed = status_response.iterations_completed;
            let status = OptimizationStatus::from_i32(status_response.status)
                .unwrap_or(OptimizationStatus::Unknown);

            tracing::info!(
                "Optimization progress: {}/{} iterations, Status: {:?}",
                iterations_completed,
                20,
                status
            );

            if status == OptimizationStatus::Completed {
                break;
            }

            status_checks += 1;
            sleep(Duration::from_millis(300)).await;
        }

        // Get optimization results
        let results_request = GetOptimizationResultsRequest {
            optimization_id: optimization_id.clone(),
        };

        let results_response = backtesting_client
            .get_optimization_results(results_request)
            .await
            .expect("Failed to get optimization results");

        assert!(
            !results_response.parameter_combinations.is_empty(),
            "Should have parameter combinations"
        );
        assert!(
            results_response.best_parameters.is_some(),
            "Should have best parameters"
        );

        let best_params = results_response.best_parameters.unwrap();
        tracing::info!(
            "Best optimization result: Sharpe Ratio = {}, Parameters: {:?}",
            best_params.metric_value,
            best_params.parameters
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_walk_forward_analysis_workflow() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let backtesting_client = test_env.get_backtesting_client();

        // Setup walk-forward analysis
        let walk_forward_request = CreateWalkForwardAnalysisRequest {
            strategy_id: "mean_reversion_strategy".to_string(),
            start_date: "2024-01-01".to_string(),
            end_date: "2024-06-30".to_string(),
            symbols: vec!["AAPL".to_string()],
            in_sample_period_days: 60,
            out_of_sample_period_days: 30,
            optimization_metric: OptimizationMetric::SharpeRatio as i32,
            reoptimization_frequency_days: 30,
        };

        let walk_forward_response = backtesting_client
            .create_walk_forward_analysis(walk_forward_request)
            .await
            .expect("Failed to start walk-forward analysis");

        assert!(
            walk_forward_response.success,
            "Walk-forward analysis should start"
        );
        let analysis_id = walk_forward_response.analysis_id.clone();

        // Monitor analysis progress
        let mut periods_completed = 0;
        let mut status_checks = 0;
        let max_status_checks = 40;

        while status_checks < max_status_checks {
            let status_request = GetWalkForwardStatusRequest {
                analysis_id: analysis_id.clone(),
            };

            let status_response = backtesting_client
                .get_walk_forward_status(status_request)
                .await
                .expect("Failed to get walk-forward status");

            periods_completed = status_response.periods_completed;
            let status = WalkForwardStatus::from_i32(status_response.status)
                .unwrap_or(WalkForwardStatus::Unknown);

            tracing::info!(
                "Walk-forward progress: {} periods completed, Status: {:?}",
                periods_completed,
                status
            );

            if status == WalkForwardStatus::Completed {
                break;
            }

            status_checks += 1;
            sleep(Duration::from_millis(500)).await;
        }

        // Get walk-forward results
        let results_request = GetWalkForwardResultsRequest {
            analysis_id: analysis_id.clone(),
        };

        let results_response = backtesting_client
            .get_walk_forward_results(results_request)
            .await
            .expect("Failed to get walk-forward results");

        assert!(
            !results_response.period_results.is_empty(),
            "Should have period results"
        );
        assert!(
            results_response.aggregate_statistics.is_some(),
            "Should have aggregate statistics"
        );

        let aggregate_stats = results_response.aggregate_statistics.unwrap();
        tracing::info!(
            "Walk-forward analysis completed: Overall Sharpe = {}, Stability = {}",
            aggregate_stats.average_sharpe_ratio,
            aggregate_stats.stability_metric
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }
}

/// Configuration management flow tests
#[cfg(test)]
mod configuration_flow_tests {
    use super::*;

    #[tokio::test]
    async fn test_configuration_update_with_hot_reload() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();

        // Step 1: Get current configuration
        let get_config_request = GetConfigurationRequest {
            config_type: ConfigurationType::TradingLimits as i32,
            account_id: Some("test_account".to_string()),
        };

        let initial_config = trading_client
            .get_configuration(get_config_request.clone())
            .await
            .expect("Failed to get initial configuration");

        assert!(
            !initial_config.configurations.is_empty(),
            "Should have initial configurations"
        );

        // Step 2: Update configuration
        let mut updated_config = initial_config.configurations[0].clone();
        updated_config.value = "999999".to_string(); // Update to new value

        let update_request = UpdateConfigurationRequest {
            configurations: vec![updated_config.clone()],
            validate_before_update: true,
        };

        let update_response = trading_client
            .update_configuration(update_request)
            .await
            .expect("Failed to update configuration");

        assert!(
            update_response.success,
            "Configuration update should succeed"
        );
        assert!(
            update_response.validation_errors.is_empty(),
            "Should have no validation errors"
        );

        // Step 3: Trigger hot reload
        let reload_request = TriggerConfigReloadRequest {
            services: vec!["trading_service".to_string(), "risk_service".to_string()],
            config_types: vec![ConfigurationType::TradingLimits as i32],
        };

        let reload_response = trading_client
            .trigger_config_reload(reload_request)
            .await
            .expect("Failed to trigger config reload");

        assert!(reload_response.success, "Config reload should succeed");

        // Verify all services reloaded successfully
        for service_result in &reload_response.service_results {
            assert!(
                service_result.success,
                "Service {} should reload successfully",
                service_result.service_name
            );
        }

        // Step 4: Verify configuration took effect
        sleep(Duration::from_millis(500)).await; // Allow time for reload

        let final_config = trading_client
            .get_configuration(get_config_request)
            .await
            .expect("Failed to get final configuration");

        let updated_value = final_config
            .configurations
            .iter()
            .find(|c| c.id == updated_config.id)
            .expect("Should find updated configuration");

        assert_eq!(
            updated_value.value, "999999",
            "Configuration should be updated"
        );

        // Step 5: Verify configuration history
        let history_request = GetConfigurationHistoryRequest {
            config_id: updated_config.id.clone(),
            limit: Some(10),
        };

        let history_response = trading_client
            .get_configuration_history(history_request)
            .await
            .expect("Failed to get configuration history");

        assert!(
            history_response.history.len() >= 2,
            "Should have at least 2 history entries"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_configuration_validation_workflow() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();

        // Test configuration validation with invalid values
        let invalid_config = Configuration {
            id: Uuid::new_v4().to_string(),
            config_type: ConfigurationType::TradingLimits as i32,
            key: "max_position_size".to_string(),
            value: "-1000".to_string(), // Invalid negative value
            account_id: Some("test_account".to_string()),
            last_updated: Utc::now().timestamp(),
        };

        let validation_request = ValidateConfigurationRequest {
            configurations: vec![invalid_config.clone()],
        };

        let validation_response = trading_client
            .validate_configuration(validation_request)
            .await
            .expect("Failed to validate configuration");

        assert!(
            !validation_response.is_valid,
            "Invalid configuration should fail validation"
        );
        assert!(
            !validation_response.validation_errors.is_empty(),
            "Should have validation errors"
        );

        // Test with valid configuration
        let valid_config = Configuration {
            id: Uuid::new_v4().to_string(),
            config_type: ConfigurationType::TradingLimits as i32,
            key: "max_position_size".to_string(),
            value: "1000000".to_string(),
            account_id: Some("test_account".to_string()),
            last_updated: Utc::now().timestamp(),
        };

        let valid_validation_request = ValidateConfigurationRequest {
            configurations: vec![valid_config.clone()],
        };

        let valid_validation_response = trading_client
            .validate_configuration(valid_validation_request)
            .await
            .expect("Failed to validate valid configuration");

        assert!(
            valid_validation_response.is_valid,
            "Valid configuration should pass validation"
        );
        assert!(
            valid_validation_response.validation_errors.is_empty(),
            "Should have no validation errors"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }
}

/// Security authentication and authorization flow tests - DISABLED (TLI is pure client)
#[cfg(disabled_auth_tests)]
mod security_flow_tests {
    use super::*;

    #[tokio::test]
    async fn test_authentication_and_authorization_flow() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let auth_manager = test_env
            .auth_manager
            .as_ref()
            .expect("Authentication manager not available");

        // Step 1: User registration/creation
        let user_credentials = UserCredentials {
            username: "test_trader".to_string(),
            password: "SecurePassword123!".to_string(),
            email: Some("test.trader@example.com".to_string()),
            full_name: Some("Test Trader".to_string()),
        };

        let registration_result = auth_manager
            .register_user(user_credentials.clone())
            .await
            .expect("Failed to register user");

        assert!(
            registration_result.success,
            "User registration should succeed"
        );
        let user_id = registration_result.user_id.expect("Should have user ID");

        // Step 2: Authentication
        let login_request = LoginRequest {
            username: user_credentials.username.clone(),
            password: user_credentials.password.clone(),
            mfa_token: None,
        };

        let login_response = auth_manager
            .authenticate(login_request)
            .await
            .expect("Failed to authenticate user");

        assert!(login_response.success, "Authentication should succeed");
        assert!(
            login_response.access_token.is_some(),
            "Should have access token"
        );
        assert!(
            login_response.refresh_token.is_some(),
            "Should have refresh token"
        );

        let access_token = login_response.access_token.unwrap();

        // Step 3: Authorization check
        let auth_request = AuthorizationRequest {
            access_token: access_token.clone(),
            resource: "trading_service".to_string(),
            action: "submit_order".to_string(),
        };

        let auth_response = auth_manager
            .authorize(auth_request)
            .await
            .expect("Failed to check authorization");

        assert!(
            auth_response.authorized,
            "User should be authorized for trading"
        );

        // Step 4: Session management
        let session_manager = test_env
            .session_manager
            .as_ref()
            .expect("Session manager not available");

        let session_info = session_manager
            .get_session_info(&access_token)
            .await
            .expect("Failed to get session info");

        assert_eq!(
            session_info.user_id, user_id,
            "Session should belong to correct user"
        );
        assert!(session_info.is_active, "Session should be active");

        // Step 5: Token refresh
        let refresh_token = login_response.refresh_token.unwrap();
        let refresh_request = RefreshTokenRequest {
            refresh_token: refresh_token.clone(),
        };

        let refresh_response = auth_manager
            .refresh_token(refresh_request)
            .await
            .expect("Failed to refresh token");

        assert!(refresh_response.success, "Token refresh should succeed");
        assert!(
            refresh_response.access_token.is_some(),
            "Should have new access token"
        );

        // Step 6: Logout
        let logout_request = LogoutRequest {
            access_token: access_token.clone(),
        };

        let logout_response = auth_manager
            .logout(logout_request)
            .await
            .expect("Failed to logout");

        assert!(logout_response.success, "Logout should succeed");

        // Verify session is invalidated
        let post_logout_session = session_manager.get_session_info(&access_token).await;
        assert!(
            post_logout_session.is_err() || !post_logout_session.unwrap().is_active,
            "Session should be invalidated after logout"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }

    #[tokio::test]
    async fn test_role_based_access_control() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let auth_manager = test_env
            .auth_manager
            .as_ref()
            .expect("Authentication manager not available");

        // Create users with different roles
        let trader_credentials = UserCredentials {
            username: "trader_user".to_string(),
            password: "TraderPass123!".to_string(),
            email: Some("trader@example.com".to_string()),
            full_name: Some("Trader User".to_string()),
        };

        let admin_credentials = UserCredentials {
            username: "admin_user".to_string(),
            password: "AdminPass123!".to_string(),
            email: Some("admin@example.com".to_string()),
            full_name: Some("Admin User".to_string()),
        };

        // Register users
        let trader_registration = auth_manager
            .register_user(trader_credentials.clone())
            .await
            .expect("Failed to register trader");
        let admin_registration = auth_manager
            .register_user(admin_credentials.clone())
            .await
            .expect("Failed to register admin");

        let trader_user_id = trader_registration.user_id.unwrap();
        let admin_user_id = admin_registration.user_id.unwrap();

        // Assign roles
        let rbac_manager = RbacManager::new()?;

        rbac_manager
            .assign_role_to_user(trader_user_id.clone(), "trader".to_string())
            .await
            .expect("Failed to assign trader role");

        rbac_manager
            .assign_role_to_user(admin_user_id.clone(), "admin".to_string())
            .await
            .expect("Failed to assign admin role");

        // Test trader permissions
        let trader_login = auth_manager
            .authenticate(LoginRequest {
                username: trader_credentials.username,
                password: trader_credentials.password,
                mfa_token: None,
            })
            .await
            .expect("Failed to login trader");

        let trader_token = trader_login.access_token.unwrap();

        // Trader should have trading permissions
        let trading_auth = auth_manager
            .authorize(AuthorizationRequest {
                access_token: trader_token.clone(),
                resource: "trading_service".to_string(),
                action: "submit_order".to_string(),
            })
            .await
            .expect("Failed to check trading authorization");

        assert!(
            trading_auth.authorized,
            "Trader should have trading permissions"
        );

        // Trader should NOT have admin permissions
        let admin_auth = auth_manager
            .authorize(AuthorizationRequest {
                access_token: trader_token,
                resource: "admin_service".to_string(),
                action: "modify_user".to_string(),
            })
            .await
            .expect("Failed to check admin authorization");

        assert!(
            !admin_auth.authorized,
            "Trader should NOT have admin permissions"
        );

        // Test admin permissions
        let admin_login = auth_manager
            .authenticate(LoginRequest {
                username: admin_credentials.username,
                password: admin_credentials.password,
                mfa_token: None,
            })
            .await
            .expect("Failed to login admin");

        let admin_token = admin_login.access_token.unwrap();

        // Admin should have admin permissions
        let admin_admin_auth = auth_manager
            .authorize(AuthorizationRequest {
                access_token: admin_token.clone(),
                resource: "admin_service".to_string(),
                action: "modify_user".to_string(),
            })
            .await
            .expect("Failed to check admin admin authorization");

        assert!(
            admin_admin_auth.authorized,
            "Admin should have admin permissions"
        );

        // Admin should also have trading permissions
        let admin_trading_auth = auth_manager
            .authorize(AuthorizationRequest {
                access_token: admin_token,
                resource: "trading_service".to_string(),
                action: "submit_order".to_string(),
            })
            .await
            .expect("Failed to check admin trading authorization");

        assert!(
            admin_trading_auth.authorized,
            "Admin should have trading permissions"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }
}

/// Event storage and retrieval tests
#[cfg(test)]
mod event_storage_tests {
    use super::*;

    #[tokio::test]
    async fn test_event_lifecycle_and_retrieval() {
        let mut test_env = EndToEndTestEnvironment::new(TestConfig::default());
        test_env
            .setup()
            .await
            .expect("Failed to setup test environment");

        let trading_client = test_env.get_trading_client();

        // Subscribe to events to capture them
        let subscription_request = EventSubscriptionRequest {
            event_types: vec![
                EventType::OrderExecuted as i32,
                EventType::PositionChanged as i32,
                EventType::ConfigurationChanged as i32,
            ],
            filters: HashMap::new(),
        };

        let mut event_stream = trading_client
            .subscribe_to_events(subscription_request)
            .await
            .expect("Failed to subscribe to events");

        let events_start_time = Utc::now();

        // Generate events by performing various operations
        let order_request = SubmitOrderRequest {
            symbol: TestUtilities::generate_test_symbol("AAPL"),
            side: OrderSide::Buy as i32,
            order_type: OrderType::Market as i32,
            quantity: 100.0,
            price: None,
            stop_price: None,
            time_in_force: "DAY".to_string(),
            client_order_id: Uuid::new_v4().to_string(),
        };

        // Submit order to generate events
        let _order_response = trading_client
            .submit_order(order_request)
            .await
            .expect("Failed to submit order");

        // Update configuration to generate config events
        let config_update = Configuration {
            id: Uuid::new_v4().to_string(),
            config_type: ConfigurationType::TradingLimits as i32,
            key: "test_event_config".to_string(),
            value: "test_value".to_string(),
            account_id: Some("test_account".to_string()),
            last_updated: Utc::now().timestamp(),
        };

        let update_request = UpdateConfigurationRequest {
            configurations: vec![config_update],
            validate_before_update: true,
        };

        let _config_response = trading_client
            .update_configuration(update_request)
            .await
            .expect("Failed to update configuration");

        // Collect events from stream
        let mut collected_events = Vec::new();
        let mut event_collection_attempts = 0;
        let max_collection_attempts = 10;

        while event_collection_attempts < max_collection_attempts && collected_events.len() < 3 {
            match timeout(Duration::from_millis(500), event_stream.recv()).await {
                Ok(Some(event)) => {
                    tracing::info!(
                        "Collected event: {:?} for {}",
                        event.event_type,
                        event.event_id
                    );
                    collected_events.push(event);
                }
                Ok(None) => break,
                Err(_) => {
                    tracing::debug!(
                        "Event collection timeout on attempt {}",
                        event_collection_attempts + 1
                    );
                }
            }
            event_collection_attempts += 1;
        }

        assert!(
            !collected_events.is_empty(),
            "Should have collected some events"
        );

        // Test event retrieval by time range
        let events_end_time = Utc::now();
        let time_range_request = GetEventsRequest {
            start_time: Some(events_start_time.timestamp()),
            end_time: Some(events_end_time.timestamp()),
            event_types: vec![
                EventType::OrderExecuted as i32,
                EventType::PositionChanged as i32,
                EventType::ConfigurationChanged as i32,
            ],
            limit: Some(100),
            offset: None,
        };

        let time_range_response = trading_client
            .get_events(time_range_request)
            .await
            .expect("Failed to get events by time range");

        assert!(
            !time_range_response.events.is_empty(),
            "Should have events in time range"
        );

        // Test event retrieval by type
        let type_filter_request = GetEventsRequest {
            start_time: Some(events_start_time.timestamp()),
            end_time: Some(events_end_time.timestamp()),
            event_types: vec![EventType::OrderExecuted as i32],
            limit: Some(50),
            offset: None,
        };

        let type_filter_response = trading_client
            .get_events(type_filter_request)
            .await
            .expect("Failed to get events by type");

        // All returned events should be of the requested type
        for event in &type_filter_response.events {
            assert_eq!(
                event.event_type,
                EventType::OrderExecuted as i32,
                "All events should be of OrderExecuted type"
            );
        }

        // Test event statistics
        let stats_request = GetEventStatisticsRequest {
            start_time: events_start_time.timestamp(),
            end_time: events_end_time.timestamp(),
            group_by_type: true,
            group_by_service: true,
        };

        let stats_response = trading_client
            .get_event_statistics(stats_request)
            .await
            .expect("Failed to get event statistics");

        assert!(
            stats_response.total_events > 0,
            "Should have total event count"
        );
        assert!(
            !stats_response.events_by_type.is_empty(),
            "Should have events grouped by type"
        );

        test_env
            .teardown()
            .await
            .expect("Failed to teardown test environment");
    }
}