foxhunt/ml/src/microstructure/portfolio_integration.rs

//! # Portfolio Integration for Microstructure ML Models
//!
//! This module provides seamless integration between the advanced microstructure models
//! and the Portfolio Transformer, creating a unified ML system for HFT alpha generation.
//! 
//! ## Key Features
//!
//! - **Unified Interface**: Single entry point for all microstructure ML predictions
//! - **Portfolio Enhancement**: Integrates microstructure signals with portfolio optimization
//! - **Real-time Processing**: Sub-25μs microstructure signal generation for portfolio decisions
//! - **Risk-Aware Integration**: Combines microstructure risk signals with portfolio risk management
//! - **Performance Tracking**: Comprehensive metrics for microstructure contribution to alpha

use std::{

use candle_core::Device;
use candle_core::{Device, Tensor};
use chrono::{DateTime, Utc};
// use error_handling::{FoxhuntError, AppResult}; // Commented out - crate doesn't exist
use portfolio_management::advanced_black_litterman::{
use serde::{Serialize, Deserialize};
use tokio::sync::RwLock;
use tracing::{debug, info, warn, instrument};
use core::types::prelude::*;

use crate::portfolio_transformer::{PortfolioTransformer, PortfolioState, PortfolioOptimizationResult};
use crate::portfolio_transformer::{PortfolioTransformerConfig};
use super::*;
use super::{
// use crate::safe_operations; // DISABLED - module not found


    async fn create_test_integrator() -> Result<PortfolioMicrostructureIntegrator, Box<dyn std::error::Error>> {
        let portfolio_config = PortfolioTransformerConfig::nano();
        let device = Device::Cpu;
        let portfolio_transformer = Arc::new(
            PortfolioTransformer::new(portfolio_config, device)?
        );

        let integration_config = PortfolioMicrostructureConfig::default();
        let bl_config = AdvancedBlackLittermanConfig::default();

        PortfolioMicrostructureIntegrator::new(
            integration_config,
            portfolio_transformer,
            bl_config,
        ).await
    }

    fn create_test_portfolio_state() -> PortfolioState {
        PortfolioState {
            weights: vec![0.25, 0.25, 0.25, 0.25],
            expected_returns: vec![0.08, 0.12, 0.06, 0.10],
            volatilities: vec![0.15, 0.25, 0.12, 0.18],
            correlations: vec![0.6, 0.3, 0.4, 0.7, 0.5, 0.2],
            market_regime: vec![1.0, 0.0, 0.0, 0.0],
            risk_metrics: vec![0.05, 0.08, 0.03, 0.15],
            confidence_scores: vec![0.8, 0.7, 0.9, 0.6],
            alpha_signals: vec![0.02, -0.01, 0.03, 0.01],
            timestamp: Utc::now(),
        }
    }

    fn create_test_asset_symbols() -> Vec<Symbol> {
        vec![
            Symbol::from_static("AAPL"),
            Symbol::from_static("MSFT"),
            Symbol::from_static("GOOGL"),
            Symbol::from_static("AMZN"),
        ]
    }

    #[tokio::test]
    async fn test_integrator_creation() {
        let integrator = create_test_integrator().await;
        assert!(integrator.is_ok());
    }

    #[tokio::test]
    async fn test_portfolio_optimization_integration() {
        let integrator = create_test_integrator().await?;
        let portfolio_state = create_test_portfolio_state();
        let asset_symbols = create_test_asset_symbols();

        let result = integrator.optimize_portfolio_integrated(
            &portfolio_state,
            None,
            &asset_symbols,
        ).await;

        assert!(result.is_ok());
        let optimization_result = result?;
        assert_eq!(optimization_result.integrated_weights.len(), 4);
        assert!(optimization_result.integration_confidence > 0.0);
        assert!(optimization_result.total_optimization_time_us > 0);
    }

    #[tokio::test]
    async fn test_signal_combination() {
        let integrator = create_test_integrator().await?;
        let portfolio_state = create_test_portfolio_state();
        
        let portfolio_result = PortfolioOptimizationResult {
            optimal_weights: vec![0.3, 0.3, 0.2, 0.2],
            expected_return: 0.08,
            expected_volatility: 0.15,
            sharpe_ratio: 0.8,
            optimization_confidence: 0.9,
            inference_time_us: 1000,
            model_components: HashMap::new(),
        };

        let microstructure_prediction = EnsemblePrediction {
            ensemble_alpha: 0.02,
            ensemble_confidence: 0.8,
            recommended_action: crate::ml_integration::TradingAction::Buy,
            total_inference_time_us: 500,
            model_predictions: HashMap::new(),
            risk_metrics: HashMap::new(),
            market_quality_score: 0.9,
            signal_strength: 0.7,
            execution_recommendation: "Execute gradually".to_string(),
        };

        let integrated_weights = integrator.combine_signals(
            &portfolio_result,
            &microstructure_prediction,
            None,
            &portfolio_state,
        ).await;

        assert!(integrated_weights.is_ok());
        let weights = integrated_weights?;
        assert_eq!(weights.len(), 4);
        
        // Check that weights sum to approximately 1
        let total_weight: f64 = weights.iter().sum();
        assert!((total_weight - 1.0).abs() < 1e-6);
    }

    #[tokio::test]
    async fn test_metrics_tracking() {
        let integrator = create_test_integrator().await?;
        
        integrator.update_metrics(1500, 0.85).await;
        
        let metrics = integrator.get_metrics().await;
        assert_eq!(metrics.total_optimizations.load(Ordering::Relaxed), 1);
        assert_eq!(metrics.average_optimization_time_us, 1500.0);
        assert_eq!(metrics.average_integration_confidence, 0.85);
        assert!(metrics.last_optimization_time.is_some());
    }

    #[test]
    fn test_config_defaults() {
        let config = PortfolioMicrostructureConfig::default();
        assert_eq!(config.microstructure_weight, 0.3);
        assert_eq!(config.portfolio_weight, 0.7);
        assert!(config.risk_adjustment_config.enable_adverse_selection_adjustment);
        assert!(config.execution_config.enable_execution_optimization);
    }
}