foxhunt/ml/src/regime_detection.rs

//! Regime Detection Models for Market State Identification
//!
//! Implements advanced regime detection algorithms to identify different market states
//! and adapt ML models accordingly. Uses fixed-point arithmetic for sub-100μs performance.

use serde::{Deserialize, Serialize};

use crate::MLError;

/// Configuration for regime detection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegimeDetectionConfig {
    pub window_size: usize,
    pub min_regime_duration: usize,
    pub threshold: f64,
}

impl Default for RegimeDetectionConfig {
    fn default() -> Self {
        Self {
            window_size: 100,
            min_regime_duration: 10,
            threshold: 0.05,
        }
    }
}

/// Regime detection engine
#[derive(Debug)]
pub struct RegimeDetectionEngine {
    pub total_updates: u64,
    pub feature_data: Vec<f64>,
    config: RegimeDetectionConfig,
}

impl RegimeDetectionEngine {
    pub fn new(config: RegimeDetectionConfig) -> Result<Self, MLError> {
        Ok(Self {
            total_updates: 0,
            feature_data: Vec::new(),
            config,
        })
    }

    pub fn update_features(&mut self, features: &[f64]) -> Result<(), MLError> {
        self.feature_data.extend_from_slice(features);
        self.total_updates += 1;
        Ok(())
    }

    pub fn detect_regime(&self) -> Result<String, MLError> {
        Ok("normal".to_string())
    }
}

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

    #[tokio::test]
    async fn test_regime_detection_engine_creation() -> Result<(), Box<dyn std::error::Error>> {
        let config = RegimeDetectionConfig::default();
        let engine = RegimeDetectionEngine::new(config)?;

        assert_eq!(engine.total_updates, 0);
        assert!(engine.feature_data.is_empty());

        Ok(())
    }

    #[tokio::test]
    async fn test_feature_data_update() -> Result<(), Box<dyn std::error::Error>> {
        let mut engine = RegimeDetectionEngine::new(RegimeDetectionConfig::default())?;

        let features = vec![0.1, 0.01];
        let result = engine.update_features(&features);

        assert!(result.is_ok());
        assert_eq!(engine.total_updates, 1);
        assert_eq!(engine.feature_data.len(), 2);

        Ok(())
    }

    #[tokio::test]
    async fn test_regime_detection() -> Result<(), Box<dyn std::error::Error>> {
        let engine = RegimeDetectionEngine::new(RegimeDetectionConfig::default())?;

        let regime = engine.detect_regime()?;
        assert_eq!(regime, "normal");

        Ok(())
    }

    #[test]
    fn test_config_defaults() {
        let config = RegimeDetectionConfig::default();

        assert_eq!(config.window_size, 100);
        assert_eq!(config.min_regime_duration, 10);
        assert_eq!(config.threshold, 0.05);
    }

    #[test]
    fn test_config_serialization() {
        let config = RegimeDetectionConfig::default();

        // Test that config can be serialized/deserialized
        let serialized = serde_json::to_string(&config).expect("Failed to serialize config");
        let deserialized: RegimeDetectionConfig =
            serde_json::from_str(&serialized).expect("Failed to deserialize config");

        assert_eq!(config.window_size, deserialized.window_size);
        assert_eq!(config.min_regime_duration, deserialized.min_regime_duration);
        assert!(config.threshold - deserialized.threshold < f64::EPSILON);
    }
}