foxhunt/config/src/lib.rs

//! Configuration management for Foxhunt HFT trading system

use serde::{Deserialize, Serialize};

// Module declarations
pub mod database;
pub mod error;
pub mod manager;
pub mod schemas;
pub mod structures;
pub mod vault;
pub mod storage_config;
pub mod ml_config;
pub mod data_config;
pub mod symbol_config;
pub mod risk_config;
pub mod asset_classification;

// Re-export commonly used types
pub use database::{DatabaseConfig, TransactionConfig, PoolConfig};
#[cfg(feature = "postgres")]
pub use database::{PostgresSymbolConfigLoader, PostgresAssetClassificationLoader};
pub use error::{ConfigError, ConfigResult};
pub use manager::{ConfigManager, ServiceConfig};
pub use schemas::*;
pub use structures::{AssetClassificationConfig, AssetClass as SimpleAssetClass, VolatilityProfile as SimpleVolatilityProfile, BrokerConfig, BrokerRoutingRule, CommissionConfig};
pub use vault::VaultConfig;
pub use storage_config::{ModelMetadata, TrainingMetrics, ModelArchitecture};
pub use ml_config::{
    MLConfig, ModelArchitectureConfig, Mamba2Config, SimulationConfig, MarketState,
    SymbolConfig as MLSymbolConfig, TrainingConfig
};
pub use data_config::DataConfig;
pub use symbol_config::{
    AssetClassification, SymbolConfig, VolatilityProfile, 
    VolatilityRegime, TradingHours, SymbolMetadata, SymbolConfigManager
};
pub use risk_config::{RiskConfig, StressScenarioConfig, AssetClass as RiskAssetClass, AssetClassMapping};
pub use asset_classification::{
    AssetClass, AssetConfig, AssetClassificationManager,
    VolatilityProfile as DetailedVolatilityProfile, TradingParameters,
    PositionLimits, RiskThresholds, ExecutionConfig, MarketMakingConfig,
    EquitySector, GeographicRegion, FutureType, ForexPairType,
    CryptoType, CommodityType, FixedIncomeType, DerivativeType,
    JumpRiskProfile, TradingHours as DetailedTradingHours,
    SettlementConfig, OrderType, TimeInForce, create_default_configurations
};

/// Configuration categories for organizing different aspects of the trading system.
/// 
/// This enum categorizes different types of configurations to enable organized
/// access and management of system settings across various functional domains.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ConfigCategory {
    /// Trading system configuration including order management and execution
    Trading,
    /// Risk management configuration including position limits and VaR settings
    Risk,
    /// Market data configuration for data providers and feeds
    MarketData,
    /// Machine learning model configuration and training parameters
    MachineLearning,
    /// Broker connectivity and execution configuration
    Brokers,
    /// Performance monitoring and optimization configuration
    Performance,
    /// Symbol classification and trading parameters configuration
    Symbols,
    /// Comprehensive asset classification with advanced features
    AssetClassification,
}

/// Production-ready asset classification system integration.
/// 
/// This module provides a comprehensive asset classification system that integrates
/// with the existing config infrastructure while offering advanced features like:
/// - Dynamic pattern-based classification
/// - Regime-aware volatility profiling  
/// - Hot-reload configuration management
/// - Performance caching and audit trails
/// 
/// # Usage
/// 
/// ```rust,no_run
/// use config::{AssetClassificationManager, create_default_configurations};
/// 
/// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
/// let mut manager = AssetClassificationManager::new();
/// let configs = create_default_configurations();
/// manager.load_configurations(configs).await?;
/// 
/// // Classify a symbol
/// let asset_class = manager.classify_symbol("AAPL");
/// 
/// // Get trading parameters
/// if let Some(params) = manager.get_trading_parameters("AAPL") {
///     let max_position = params.position_limits.max_position_fraction;
///     println!("Max position fraction for AAPL: {}", max_position);
/// }
/// # Ok(())
/// # }
/// ```
pub mod asset_classification_integration {
    pub use crate::asset_classification::*;

    /// Convenience function to create a fully configured asset classification manager
    /// with default configurations suitable for production use.
    pub async fn create_production_manager(
        database_pool: Option<sqlx::PgPool>
    ) -> Result<AssetClassificationManager, Box<dyn std::error::Error>> {
        let mut manager = AssetClassificationManager::new();

        // Load configurations from database if available, otherwise use defaults
        let configs = if let Some(_pool) = database_pool {
            // In production, load from database
            // let loader = crate::database::PostgresAssetClassificationLoader::with_pool(pool);
            // loader.load_asset_configurations().await?
            create_default_configurations()
        } else {
            create_default_configurations()
        };

        manager.load_configurations(configs).await?;
        Ok(manager)
    }
}