foxhunt/adaptive-strategy/src/lib.rs

#![allow(missing_docs)] // Internal implementation details don't require documentation
#![deny(clippy::unwrap_used)]
#![deny(clippy::expect_used)]
#![recursion_limit = "256"]

//! # Adaptive Strategy Library
//!
//! A comprehensive framework for adaptive trading strategies that combines:
//! - Ensemble machine learning models
//! - Market microstructure analysis
//! - Regime detection and adaptation
//! - Risk management and position sizing
//! - Execution algorithms
//!
//! ## Architecture
//!
//! The library is structured around the following core modules:
//!
//! - `ensemble`: Strategy coordination and ensemble model management
//! - `models`: ML model interfaces and implementations
//! - `microstructure`: Market microstructure analysis and feature extraction
//! - `risk`: Risk management and position sizing algorithms
//! - `execution`: Trade execution algorithms and order management
//! - `regime`: Market regime detection and strategy adaptation
//! - `config`: Configuration management and parameter tuning
//!
//! ## Example Usage
//!
//! ```rust,no_run
//! use adaptive_strategy::{AdaptiveStrategy, load_strategy_config};
//! use adaptive_strategy::ensemble::EnsembleCoordinator;
//!
//! # async fn example() -> anyhow::Result<()> {
//! // Load configuration from database (preferred method)
//! let database_url = "postgresql://localhost/foxhunt";
//! let config = load_strategy_config(database_url, "default-production").await?;
//!
//! // Initialize the adaptive strategy
//! let strategy = AdaptiveStrategy::new(config).await?;
//!
//! // Start the strategy
//! strategy.start().await?;
//! # Ok(())
//! # }
//! ```
//!
//! ## Configuration Migration (Wave 64, Phase 3)
//!
//! **IMPORTANT**: Hardcoded `Default::default()` configurations are deprecated.
//! All configurations should now be loaded from the PostgreSQL database using
//! `DatabaseConfigLoader`.
//!
//! Available strategies from migration `016_adaptive_strategy_seed_data.sql`:
//! - `"default-production"`: Conservative production configuration (recommended)
//! - `"development"`: Permissive testing configuration
//! - `"aggressive"`: High-frequency HFT configuration (requires explicit activation)

pub mod config;
pub mod config_types; // PostgreSQL-backed configuration types
pub mod database_loader; // Database configuration loader with hot-reload
pub mod ensemble;
pub mod execution;
pub mod microstructure;
pub mod models;
pub mod regime;
pub mod risk;

// Silence unused crate dependencies warning for benchmark-only dependencies
#[cfg(test)]
use criterion as _;

// Import core types from common types crate

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{info, warn};

/// Core adaptive strategy framework
///
/// This is the main entry point for the adaptive strategy system. It coordinates
/// all subsystems including ensemble models, regime detection, risk management,
/// and execution algorithms.
#[derive(Debug)]
pub struct AdaptiveStrategy {
    /// Strategy configuration
    config: config::AdaptiveStrategyConfig,
    /// Ensemble coordinator managing multiple models
    ensemble: Arc<RwLock<ensemble::EnsembleCoordinator>>,
    /// Current strategy state
    state: Arc<RwLock<StrategyState>>,
}

/// Current state of the adaptive strategy
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StrategyState {
    /// Whether the strategy is currently active
    pub active: bool,
    /// Current market regime
    pub current_regime: String,
    /// Active model weights
    pub model_weights: std::collections::HashMap<String, f64>,
    /// Last update timestamp
    pub last_update: chrono::DateTime<chrono::Utc>,
    /// Performance metrics
    pub performance: PerformanceMetrics,
}

/// Performance tracking metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
    /// Sharpe ratio
    pub sharpe_ratio: f64,
    /// Maximum drawdown
    pub max_drawdown: f64,
    /// Total return
    pub total_return: f64,
    /// Win rate
    pub win_rate: f64,
    /// Number of trades executed
    pub trade_count: u64,
}

impl Default for PerformanceMetrics {
    fn default() -> Self {
        Self {
            sharpe_ratio: 0.0,
            max_drawdown: 0.0,
            total_return: 0.0,
            win_rate: 0.0,
            trade_count: 0,
        }
    }
}

impl AdaptiveStrategy {
    /// Create a new adaptive strategy instance
    ///
    /// # Arguments
    ///
    /// * `config` - Strategy configuration parameters
    ///
    /// # Returns
    ///
    /// A new `AdaptiveStrategy` instance ready for execution
    pub async fn new(config: config::AdaptiveStrategyConfig) -> Result<Self> {
        info!("Initializing adaptive strategy with config: {:?}", config);

        let ensemble = Arc::new(RwLock::new(
            ensemble::EnsembleCoordinator::new(&config).await?,
        ));

        let state = Arc::new(RwLock::new(StrategyState {
            active: false,
            current_regime: "unknown".to_string(),
            model_weights: std::collections::HashMap::new(),
            last_update: chrono::Utc::now(),
            performance: PerformanceMetrics::default(),
        }));

        Ok(Self {
            config,
            ensemble,
            state,
        })
    }

    /// Start the adaptive strategy
    ///
    /// This begins the main strategy loop, including:
    /// - Market data processing
    /// - Model predictions
    /// - Risk management
    /// - Trade execution
    pub async fn start(&self) -> Result<()> {
        info!("Starting adaptive strategy");

        {
            let mut state = self.state.write().await;
            state.active = true;
            state.last_update = chrono::Utc::now();
        }

        // Start the main strategy loop
        self.run_strategy_loop().await
    }

    /// Stop the adaptive strategy
    pub async fn stop(&self) -> Result<()> {
        info!("Stopping adaptive strategy");

        {
            let mut state = self.state.write().await;
            state.active = false;
            state.last_update = chrono::Utc::now();
        }

        Ok(())
    }

    /// Get current strategy state
    pub async fn get_state(&self) -> StrategyState {
        self.state.read().await.clone()
    }

    /// Update strategy configuration
    pub async fn update_config(
        &mut self,
        new_config: config::AdaptiveStrategyConfig,
    ) -> Result<()> {
        info!("Updating strategy configuration");

        self.config = new_config;

        // Reinitialize ensemble with new config
        let mut ensemble = self.ensemble.write().await;
        *ensemble = ensemble::EnsembleCoordinator::new(&self.config).await?;

        Ok(())
    }

    /// Main strategy execution loop
    async fn run_strategy_loop(&self) -> Result<()> {
        while self.state.read().await.active {
            match self.execute_strategy_cycle().await {
                Ok(_) => {
                    // Strategy cycle completed successfully
                    tokio::time::sleep(self.config.general.execution_interval).await;
                },
                Err(e) => {
                    warn!("Error in strategy cycle: {}", e);
                    // Continue running but with exponential backoff
                    tokio::time::sleep(self.config.general.error_backoff_duration).await;
                },
            }
        }

        info!("Strategy loop stopped");
        Ok(())
    }

    /// Execute a single strategy cycle
    async fn execute_strategy_cycle(&self) -> Result<()> {
        // 1. Update market regime
        // 2. Get ensemble predictions
        // 3. Calculate position sizes
        // 4. Execute trades
        // 5. Update performance metrics

        // Production implementation
        let mut state = self.state.write().await;
        state.last_update = chrono::Utc::now();

        Ok(())
    }
}

// ============================================================================
// HELPER FUNCTIONS FOR DATABASE CONFIGURATION
// ============================================================================

/// Load a strategy configuration from PostgreSQL database
///
/// This is the preferred method for loading strategy configurations.
/// It replaces hardcoded `Default::default()` configurations with
/// database-backed configuration that supports hot-reload.
///
/// # Arguments
/// * `database_url` - PostgreSQL connection URL
/// * `strategy_id` - Strategy identifier (e.g., "default-production")
///
/// # Returns
/// - `Ok(config)` - Successfully loaded configuration
/// - `Err(...)` - Database error or strategy not found
///
/// # Example
/// ```no_run
/// # use adaptive_strategy::load_strategy_config;
/// # async fn example() -> anyhow::Result<()> {
/// let config = load_strategy_config(
///     "postgresql://localhost/foxhunt",
///     "default-production"
/// ).await?;
/// # Ok(())
/// # }
/// ```
#[cfg(feature = "postgres")]
pub async fn load_strategy_config(
    database_url: &str,
    strategy_id: &str,
) -> Result<config::AdaptiveStrategyConfig> {
    use database_loader::DatabaseConfigLoader;

    let loader = DatabaseConfigLoader::new(database_url)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to connect to database: {}", e))?;

    let config = loader
        .load_config(strategy_id)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to load config: {}", e))?
        .ok_or_else(|| {
            anyhow::anyhow!(
                "Strategy '{}' not found. Available: 'default-production', 'development', 'aggressive'",
                strategy_id
            )
        })?;

    // Validate configuration before returning
    config
        .validate()
        .map_err(|e| anyhow::anyhow!("Configuration validation failed: {}", e))?;

    Ok(convert_config_types(config))
}

/// Convert config_types::AdaptiveStrategyConfig to config::AdaptiveStrategyConfig
///
/// This function bridges the gap between the database-loaded configuration
/// (from config_types module) and the internal configuration structure
/// (from config module).
#[cfg(feature = "postgres")]
fn convert_config_types(
    db_config: config_types::AdaptiveStrategyConfig,
) -> config::AdaptiveStrategyConfig {
    config::AdaptiveStrategyConfig {
        general: config::GeneralConfig {
            execution_interval: db_config.general.execution_interval,
            error_backoff_duration: db_config.general.error_backoff_duration,
            max_concurrent_operations: db_config.general.max_concurrent_operations,
            strategy_timeout: db_config.general.strategy_timeout,
        },
        ensemble: config::EnsembleConfig {
            max_parallel_models: db_config.ensemble.max_parallel_models,
            rebalancing_interval: db_config.ensemble.rebalancing_interval,
            min_model_weight: db_config.ensemble.min_model_weight,
            max_model_weight: db_config.ensemble.max_model_weight,
            models: db_config
                .models
                .into_iter()
                .map(|m| config::ModelConfig {
                    id: m.id,
                    name: m.name,
                    model_type: m.model_type,
                    parameters: m.parameters,
                    initial_weight: m.initial_weight,
                    enabled: m.enabled,
                })
                .collect(),
        },
        risk: config::RiskConfig {
            max_position_size: db_config.risk.max_position_size,
            max_leverage: db_config.risk.max_leverage,
            stop_loss_pct: db_config.risk.stop_loss_pct,
            position_sizing_method: convert_position_sizing_method(
                db_config.risk.position_sizing_method,
            ),
            max_portfolio_var: db_config.risk.max_portfolio_var,
            max_drawdown_threshold: db_config.risk.max_drawdown_threshold,
            kelly_fraction: db_config.risk.kelly_fraction,
        },
        microstructure: config::MicrostructureConfig {
            book_depth: db_config.microstructure.book_depth,
            vpin_window: db_config.microstructure.vpin_window,
            trade_classification_threshold: db_config.microstructure.trade_classification_threshold,
            trade_size_buckets: db_config.microstructure.trade_size_buckets,
            features: db_config.microstructure.features,
        },
        regime: config::RegimeConfig {
            detection_method: convert_regime_detection_method(db_config.regime.detection_method),
            lookback_window: db_config.regime.lookback_window,
            transition_threshold: db_config.regime.transition_threshold,
            features: db_config.regime.features,
        },
        execution: config::ExecutionConfig {
            algorithm: convert_execution_algorithm(db_config.execution.algorithm),
            max_order_size: db_config.execution.max_order_size,
            min_order_size: db_config.execution.min_order_size,
            order_timeout: db_config.execution.order_timeout,
            max_slippage_bps: db_config.execution.max_slippage_bps,
            smart_routing_enabled: db_config.execution.smart_routing_enabled,
            dark_pool_preference: db_config.execution.dark_pool_preference,
        },
    }
}

#[cfg(feature = "postgres")]
fn convert_position_sizing_method(
    method: config_types::PositionSizingMethod,
) -> config::PositionSizingMethod {
    match method {
        config_types::PositionSizingMethod::Kelly => config::PositionSizingMethod::Kelly,
        config_types::PositionSizingMethod::FixedFractional(f) => {
            config::PositionSizingMethod::FixedFractional(f)
        }
        config_types::PositionSizingMethod::FixedFraction => {
            config::PositionSizingMethod::FixedFraction
        }
        config_types::PositionSizingMethod::PPO => config::PositionSizingMethod::PPO,
        config_types::PositionSizingMethod::EqualWeight => {
            config::PositionSizingMethod::EqualWeight
        }
        config_types::PositionSizingMethod::RiskParity => {
            config::PositionSizingMethod::RiskParity
        }
        config_types::PositionSizingMethod::VolatilityTarget => {
            config::PositionSizingMethod::VolatilityTarget
        }
        config_types::PositionSizingMethod::Custom(s) => config::PositionSizingMethod::Custom(s),
    }
}

#[cfg(feature = "postgres")]
fn convert_regime_detection_method(
    method: config_types::RegimeDetectionMethod,
) -> config::RegimeDetectionMethod {
    match method {
        config_types::RegimeDetectionMethod::HMM => config::RegimeDetectionMethod::HMM,
        config_types::RegimeDetectionMethod::MarkovSwitching => {
            config::RegimeDetectionMethod::MarkovSwitching
        }
        config_types::RegimeDetectionMethod::Threshold => {
            config::RegimeDetectionMethod::Threshold
        }
        config_types::RegimeDetectionMethod::MLClassification => {
            config::RegimeDetectionMethod::MLClassification
        }
        config_types::RegimeDetectionMethod::GMM => config::RegimeDetectionMethod::GMM,
        config_types::RegimeDetectionMethod::MLClassifier => {
            config::RegimeDetectionMethod::MLClassifier
        }
    }
}

#[cfg(feature = "postgres")]
fn convert_execution_algorithm(
    algorithm: config_types::ExecutionAlgorithm,
) -> config::ExecutionAlgorithm {
    match algorithm {
        config_types::ExecutionAlgorithm::TWAP => config::ExecutionAlgorithm::TWAP,
        config_types::ExecutionAlgorithm::VWAP => config::ExecutionAlgorithm::VWAP,
        config_types::ExecutionAlgorithm::IS => config::ExecutionAlgorithm::IS,
        config_types::ExecutionAlgorithm::ImplementationShortfall => {
            config::ExecutionAlgorithm::ImplementationShortfall
        }
        config_types::ExecutionAlgorithm::ArrivalPrice => {
            config::ExecutionAlgorithm::ArrivalPrice
        }
        config_types::ExecutionAlgorithm::POV => config::ExecutionAlgorithm::POV,
    }
}

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

    #[tokio::test]
    async fn test_adaptive_strategy_creation() {
        let config = config::AdaptiveStrategyConfig::default();
        let result = AdaptiveStrategy::new(config).await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_strategy_state_management() {
        let config = config::AdaptiveStrategyConfig::default();
        let strategy = AdaptiveStrategy::new(config).await.unwrap();

        let initial_state = strategy.get_state().await;
        assert!(!initial_state.active);

        // Note: start() would run indefinitely, so we don't test it here
        // In a real test, we'd need to mock the strategy loop
    }
}