foxhunt/common/src/ml_strategy_backup.rs

//! Shared ML Strategy for Foxhunt Trading System - FIXED VERSION WITH MOMENTUM INDICATORS
//!
//! This module provides a unified ML strategy implementation with advanced momentum and trend indicators.

use anyhow::Result;
use chrono::{DateTime, Datelike, Utc, Timelike};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

/// ML prediction result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MLPrediction {
    /// Model identifier
    pub model_id: String,
    /// Prediction value (0.0-1.0)
    pub prediction_value: f64,
    /// Confidence score (0.0-1.0)
    pub confidence: f64,
    /// Features used for prediction
    pub features: Vec<f64>,
    /// Prediction timestamp
    pub timestamp: DateTime<Utc>,
    /// Inference latency in microseconds
    pub inference_latency_us: u64,
}

/// ML model performance metrics
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MLModelPerformance {
    /// Model identifier
    pub model_id: String,
    /// Total predictions made
    pub total_predictions: u64,
    /// Correct predictions
    pub correct_predictions: u64,
    /// Average inference latency
    pub avg_latency_us: f64,
    /// Average confidence score
    pub avg_confidence: f64,
    /// Model accuracy percentage
    pub accuracy_percentage: f64,
    /// Returns generated
    pub returns: Vec<f64>,
    /// Sharpe ratio
    pub sharpe_ratio: f64,
    /// Maximum drawdown
    pub max_drawdown: f64,
}

/// Feature extraction for ML models
#[derive(Debug, Clone)]
pub struct MLFeatureExtractor {
    /// Lookback window for features
    pub lookback_periods: usize,
    /// Price history buffer
    price_history: Vec<f64>,
    /// Volume history buffer
    volume_history: Vec<f64>,
    /// High price history (for ADX, Stochastic, ATR)
    high_history: Vec<f64>,
    /// Low price history (for ADX, Stochastic, ATR)
    low_history: Vec<f64>,
    /// Typical price history (for CCI)
    typical_price_history: Vec<f64>,
    /// High/low price history for oscillators
    high_low_history: Vec<(f64, f64)>,
    /// On-Balance Volume (OBV) cumulative value
    obv: f64,
    /// VWAP cumulative values (price * volume sum, volume sum)
    vwap_pv_sum: f64,
    vwap_volume_sum: f64,
    /// EMA-9 state
    ema_9: Option<f64>,
    /// EMA-21 state
    ema_21: Option<f64>,
    /// EMA-50 state
    ema_50: Option<f64>,
}

impl MLFeatureExtractor {
    /// Create new feature extractor
    pub fn new(lookback_periods: usize) -> Self {
        Self {
            lookback_periods,
            price_history: Vec::with_capacity(lookback_periods + 1),
            volume_history: Vec::with_capacity(lookback_periods + 1),
            high_history: Vec::with_capacity(lookback_periods + 1),
            low_history: Vec::with_capacity(lookback_periods + 1),
            typical_price_history: Vec::with_capacity(lookback_periods + 1),
            high_low_history: Vec::with_capacity(lookback_periods + 1),
            obv: 0.0,
            vwap_pv_sum: 0.0,
            vwap_volume_sum: 0.0,
            ema_9: None,
            ema_21: None,
            ema_50: None,
        }
    }

    /// Calculate RSI (Relative Strength Index)
    fn calculate_rsi(&self, period: usize) -> f64 {
        if self.price_history.len() < period + 1 {
            return 0.0;
        }

        let mut gains = Vec::new();
        let mut losses = Vec::new();

        for i in 1..=period {
            let idx = self.price_history.len() - period - 1 + i;
            let change = self.price_history[idx] - self.price_history[idx - 1];
            if change > 0.0 {
                gains.push(change);
                losses.push(0.0);
            } else {
                gains.push(0.0);
                losses.push(-change);
            }
        }

        let avg_gain = gains.iter().sum::<f64>() / period as f64;
        let avg_loss = losses.iter().sum::<f64>() / period as f64;

        if avg_loss == 0.0 {
            return 1.0; // Max RSI when no losses
        }

        let rs = avg_gain / avg_loss;
        let rsi = 1.0 - (1.0 / (1.0 + rs));

        // RSI in [0, 1], normalize to [-1, 1]
        (rsi - 0.5) * 2.0
    }

    /// Calculate MACD (Moving Average Convergence Divergence)
    fn calculate_macd(&self) -> (f64, f64) {
        if self.price_history.len() < 26 {
            return (0.0, 0.0);
        }

        // EMA-12 and EMA-26
        let ema_12 = self.calculate_ema(12);
        let ema_26 = self.calculate_ema(26);

        let macd_line = ema_12 - ema_26;
        
        // Signal line is EMA-9 of MACD line (simplified: use MACD line itself)
        let macd_signal = macd_line * 0.5; // Simplified approximation

        // Normalize to [-1, 1]
        let current_price = self.price_history.last().copied().unwrap_or(1.0);
        let macd_norm = (macd_line / current_price).tanh();
        let signal_norm = (macd_signal / current_price).tanh();

        (macd_norm, signal_norm)
    }

    /// Calculate EMA for a given period
    fn calculate_ema(&self, period: usize) -> f64 {
        if self.price_history.len() < period {
            return self.price_history.last().copied().unwrap_or(0.0);
        }

        let alpha = 2.0 / (period as f64 + 1.0);
        let mut ema = self.price_history[self.price_history.len() - period];

        for i in (self.price_history.len() - period + 1)..self.price_history.len() {
            ema = alpha * self.price_history[i] + (1.0 - alpha) * ema;
        }

        ema
    }

    /// Calculate ADX (Average Directional Index) for trend strength
    /// ADX measures trend strength on a scale of 0-100, not direction
    /// Returns normalized ADX in range [0, 1]
    fn calculate_adx(&self, period: usize) -> f64 {
        if self.high_history.len() < period + 1 || self.low_history.len() < period + 1 || self.price_history.len() < period + 1 {
            return 0.0;
        }

        // Calculate True Range (TR) and Directional Movements (+DM, -DM)
        let mut tr_values = Vec::new();
        let mut plus_dm_values = Vec::new();
        let mut minus_dm_values = Vec::new();

        for i in 1..self.high_history.len() {
            let high = self.high_history[i];
            let low = self.low_history[i];
            let prev_close = self.price_history[i - 1];

            // True Range: max(high-low, |high-prev_close|, |low-prev_close|)
            let tr = (high - low)
                .max((high - prev_close).abs())
                .max((low - prev_close).abs());
            tr_values.push(tr);

            // Directional Movements
            let prev_high = self.high_history[i - 1];
            let prev_low = self.low_history[i - 1];

            let up_move = high - prev_high;
            let down_move = prev_low - low;

            let plus_dm = if up_move > down_move && up_move > 0.0 { up_move } else { 0.0 };
            let minus_dm = if down_move > up_move && down_move > 0.0 { down_move } else { 0.0 };

            plus_dm_values.push(plus_dm);
            minus_dm_values.push(minus_dm);
        }

        if tr_values.len() < period {
            return 0.0;
        }

        // Calculate smoothed TR, +DM, -DM (using Wilder's smoothing)
        let smooth_tr = self.wilder_smoothing(&tr_values, period);
        let smooth_plus_dm = self.wilder_smoothing(&plus_dm_values, period);
        let smooth_minus_dm = self.wilder_smoothing(&minus_dm_values, period);

        if smooth_tr == 0.0 {
            return 0.0;
        }

        // Calculate Directional Indicators (+DI, -DI)
        let plus_di = 100.0 * smooth_plus_dm / smooth_tr;
        let minus_di = 100.0 * smooth_minus_dm / smooth_tr;

        // Calculate DX (Directional Index)
        let di_sum = plus_di + minus_di;
        let dx = if di_sum > 0.0 {
            100.0 * (plus_di - minus_di).abs() / di_sum
        } else {
            0.0
        };

        // ADX is the smoothed average of DX
        // For simplicity, return DX as ADX proxy (full ADX needs DX history smoothing)
        dx / 100.0 // Normalize to [0, 1]
    }

    /// Wilder's smoothing method for ADX calculation
    fn wilder_smoothing(&self, values: &[f64], period: usize) -> f64 {
        if values.len() < period {
            return 0.0;
        }

        // First smoothed value is simple average
        let first_smooth: f64 = values.iter().take(period).sum::<f64>() / period as f64;

        // Apply Wilder's smoothing for remaining values
        let mut smoothed = first_smooth;
        for &value in values.iter().skip(period) {
            smoothed = (smoothed * (period as f64 - 1.0) + value) / period as f64;
        }

        smoothed
    }

    /// Calculate Stochastic Oscillator (%K and %D)
    /// %K = (current_close - lowest_low) / (highest_high - lowest_low) * 100
    /// %D = SMA of %K over d_period
    /// Returns normalized values in range [-1, 1]
    fn calculate_stochastic(&self, k_period: usize, _k_slowing: usize, _d_period: usize) -> (f64, f64) {
        if self.high_history.len() < k_period || self.low_history.len() < k_period || self.price_history.len() < k_period {
            return (0.0, 0.0);
        }

        // Calculate raw %K
        let recent_highs = &self.high_history[self.high_history.len().saturating_sub(k_period)..];
        let recent_lows = &self.low_history[self.low_history.len().saturating_sub(k_period)..];
        let current_close = self.price_history.last().copied().unwrap_or(0.0);

        let highest_high = recent_highs.iter().copied().fold(f64::NEG_INFINITY, f64::max);
        let lowest_low = recent_lows.iter().copied().fold(f64::INFINITY, f64::min);

        let raw_k = if highest_high != lowest_low {
            100.0 * (current_close - lowest_low) / (highest_high - lowest_low)
        } else {
            50.0 // Neutral when no price movement
        };

        // Apply %K slowing (SMA of raw %K) - simplified as single value here
        let stoch_k = raw_k;

        // Calculate %D (SMA of %K) - simplified as %K itself since we don't have %K history
        let stoch_d = stoch_k;

        // Normalize to [-1, 1] range: (value/100)*2 - 1
        let norm_k = (stoch_k / 100.0) * 2.0 - 1.0;
        let norm_d = (stoch_d / 100.0) * 2.0 - 1.0;

        (norm_k, norm_d)
    }

    /// Calculate CCI (Commodity Channel Index)
    /// CCI = (typical_price - SMA) / (0.015 * mean_deviation)
    /// Returns normalized CCI using tanh (unbounded indicator)
    fn calculate_cci(&self, period: usize) -> f64 {
        if self.typical_price_history.len() < period {
            return 0.0;
        }

        let recent_typical = &self.typical_price_history[self.typical_price_history.len() - period..];
        
        // Calculate SMA of typical price
        let sma: f64 = recent_typical.iter().sum::<f64>() / period as f64;
        
        // Calculate mean deviation
        let mean_deviation: f64 = recent_typical.iter()
            .map(|&tp| (tp - sma).abs())
            .sum::<f64>() / period as f64;

        let current_typical = self.typical_price_history.last().copied().unwrap_or(0.0);
        
        // CCI formula
        let cci = if mean_deviation > 0.0 {
            (current_typical - sma) / (0.015 * mean_deviation)
        } else {
            0.0
        };

        // CCI is unbounded, normalize with tanh will be applied later
        cci / 100.0 // Scale down for better tanh normalization
    }

    /// Extract features from market data
    pub fn extract_features(&mut self, price: f64, volume: f64, timestamp: DateTime<Utc>) -> Vec<f64> {
        // Update price and volume history
        self.price_history.push(price);
        self.volume_history.push(volume);
        
        // Simulate high/low from price (0.1% spread)
        let high_price = price * 1.001;
        let low_price = price * 0.999;
        self.high_history.push(high_price);
        self.low_history.push(low_price);
        self.high_low_history.push((high_price, low_price));
        
        // Calculate typical price: (high + low + close) / 3
        let typical_price = (high_price + low_price + price) / 3.0;
        self.typical_price_history.push(typical_price);

        // Keep only the required lookback periods
        if self.price_history.len() > self.lookback_periods {
            self.price_history.remove(0);
        }
        if self.volume_history.len() > self.lookback_periods {
            self.volume_history.remove(0);
        }
        if self.high_history.len() > self.lookback_periods {
            self.high_history.remove(0);
        }
        if self.low_history.len() > self.lookback_periods {
            self.low_history.remove(0);
        }
        if self.typical_price_history.len() > self.lookback_periods {
            self.typical_price_history.remove(0);
        }
        if self.high_low_history.len() > self.lookback_periods {
            self.high_low_history.remove(0);
        }

        // Calculate EMAs with exponential smoothing
        let alpha_9 = 2.0 / (9.0 + 1.0);
        let alpha_21 = 2.0 / (21.0 + 1.0);
        let alpha_50 = 2.0 / (50.0 + 1.0);
        
        self.ema_9 = Some(match self.ema_9 {
            Some(prev_ema) => price * alpha_9 + prev_ema * (1.0 - alpha_9),
            None => price,
        });
        
        self.ema_21 = Some(match self.ema_21 {
            Some(prev_ema) => price * alpha_21 + prev_ema * (1.0 - alpha_21),
            None => price,
        });
        
        self.ema_50 = Some(match self.ema_50 {
            Some(prev_ema) => price * alpha_50 + prev_ema * (1.0 - alpha_50),
            None => price,
        });
        
        let ema_9_val = self.ema_9.unwrap_or(price);
        let ema_21_val = self.ema_21.unwrap_or(price);
        let ema_50_val = self.ema_50.unwrap_or(price);

        // Extract technical features
        let mut features = Vec::new();

        if self.price_history.len() >= 2 {
            // Price momentum (returns)
            let current_price = self.price_history.last().copied().unwrap_or(0.0);
            let prev_price = self.price_history.get(self.price_history.len() - 2).copied().unwrap_or(current_price);
            let price_return = if prev_price != 0.0 {
                (current_price - prev_price) / prev_price
            } else {
                0.0
            };
            features.push(price_return);

            // Short-term moving average
            if self.price_history.len() >= 5 {
                let short_ma: f64 = self.price_history.iter().rev().take(5).sum::<f64>() / 5.0;
                let ma_ratio = if short_ma != 0.0 { current_price / short_ma - 1.0 } else { 0.0 };
                features.push(ma_ratio);
            } else {
                features.push(0.0);
            }

            // Price volatility (rolling standard deviation)
            if self.price_history.len() >= 10 {
                let recent_returns: Vec<f64> = self.price_history
                    .windows(2)
                    .rev()
                    .take(9)
                    .map(|w| (w[1] - w[0]) / w[0])
                    .collect();

                let mean_return = recent_returns.iter().sum::<f64>() / recent_returns.len() as f64;
                let variance = recent_returns.iter()
                    .map(|&r| (r - mean_return).powi(2))
                    .sum::<f64>() / recent_returns.len() as f64;
                let volatility = variance.sqrt();
                features.push(volatility);
            } else {
                features.push(0.0);
            }
        } else {
            features.extend_from_slice(&[0.0, 0.0, 0.0]);
        }

        // Volume features
        if self.volume_history.len() >= 2 {
            let current_volume = self.volume_history.last().copied().unwrap_or(0.0);
            let prev_volume = self.volume_history.get(self.volume_history.len() - 2).copied().unwrap_or(current_volume);
            let volume_ratio = if prev_volume != 0.0 {
                current_volume / prev_volume - 1.0
            } else {
                0.0
            };
            features.push(volume_ratio);

            // Volume moving average
            if self.volume_history.len() >= 5 {
                let volume_ma = self.volume_history.iter().rev().take(5).sum::<f64>() / 5.0;
                let volume_ma_ratio = if volume_ma != 0.0 { current_volume / volume_ma - 1.0 } else { 0.0 };
                features.push(volume_ma_ratio);
            } else {
                features.push(0.0);
            }
        } else {
            features.extend_from_slice(&[0.0, 0.0]);
        }

        // Add time-based features
        let hour = timestamp.hour() as f64 / 24.0;
        let day_of_week = timestamp.weekday().num_days_from_monday() as f64 / 6.0;
        features.push(hour);
        features.push(day_of_week);

        // === MOMENTUM & TREND INDICATORS (Wave 17) ===
        
        // 1. ADX (Average Directional Index) - Trend strength indicator
        if self.high_history.len() >= 14 && self.low_history.len() >= 14 && self.price_history.len() >= 14 {
            let adx = self.calculate_adx(14);
            features.push(adx);
        } else {
            features.push(0.0);
        }

        // 2. Stochastic Oscillator - Overbought/oversold indicator
        if self.high_history.len() >= 14 && self.low_history.len() >= 14 && self.price_history.len() >= 14 {
            let (stoch_k, stoch_d) = self.calculate_stochastic(14, 3, 3);
            features.push(stoch_k);
            features.push(stoch_d);
        } else {
            features.push(0.0);
            features.push(0.0);
        }

        // 3. CCI (Commodity Channel Index) - Cyclical trend detection
        if self.typical_price_history.len() >= 20 {
            let cci = self.calculate_cci(20);
            features.push(cci);
        } else {
            features.push(0.0);
        }

        // Add RSI feature (14-period)
        let rsi = self.calculate_rsi(14);
        features.push(rsi);

        // Add MACD features (12, 26, 9)
        let (macd_line, macd_signal) = self.calculate_macd();
        features.push(macd_line);
        features.push(macd_signal);

        // Add EMA features (normalized to [-1, 1])
        let ema_9_norm = if ema_9_val != 0.0 {
            (price / ema_9_val - 1.0).tanh()
        } else {
            0.0
        };
        let ema_21_norm = if ema_21_val != 0.0 {
            (price / ema_21_val - 1.0).tanh()
        } else {
            0.0
        };
        let ema_50_norm = if ema_50_val != 0.0 {
            (price / ema_50_val - 1.0).tanh()
        } else {
            0.0
        };
        
        let ema_9_21_cross = if ema_9_val > ema_21_val { 1.0 } else { -1.0 };
        let ema_21_50_cross = if ema_21_val > ema_50_val { 1.0 } else { -1.0 };
        
        features.extend_from_slice(&[ema_9_norm, ema_21_norm, ema_50_norm, ema_9_21_cross, ema_21_50_cross]);

        // Normalize all features to [-1, 1] range using tanh
        features.iter().map(|&f| if f.abs() <= 1.0 { f } else { f.tanh() }).collect()
    }
}