hyper_risk/

risk.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;
use std::time::Instant;

use crate::alerts::{alert_history_path, AlertHistoryEntry};
use hyper_ta::TechnicalIndicators;

// ---------------------------------------------------------------------------
// Risk Config types (existing)
// ---------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PositionLimits {
    pub enabled: bool,
    pub max_total_position: f64,
    pub max_per_symbol: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DailyLossLimits {
    pub enabled: bool,
    pub max_daily_loss: f64,
    pub max_daily_loss_percent: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AnomalyDetection {
    pub enabled: bool,
    pub max_order_size: f64,
    pub max_orders_per_minute: u32,
    pub block_duplicate_orders: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CircuitBreaker {
    pub enabled: bool,
    pub trigger_loss: f64,
    pub trigger_window_minutes: u32,
    pub action: String,
    pub cooldown_minutes: u32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RiskConfig {
    pub position_limits: PositionLimits,
    pub daily_loss_limits: DailyLossLimits,
    pub anomaly_detection: AnomalyDetection,
    pub circuit_breaker: CircuitBreaker,
}

impl Default for RiskConfig {
    fn default() -> Self {
        Self {
            position_limits: PositionLimits {
                enabled: true,
                max_total_position: 100_000.0,
                max_per_symbol: 25_000.0,
            },
            daily_loss_limits: DailyLossLimits {
                enabled: true,
                max_daily_loss: 5_000.0,
                max_daily_loss_percent: 5.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 50_000.0,
                max_orders_per_minute: 10,
                block_duplicate_orders: true,
            },
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 10_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
        }
    }
}

pub fn risk_config_path() -> PathBuf {
    let mut path = dirs::config_dir().unwrap_or_else(|| PathBuf::from("."));
    path.push("hyper-agent");
    let _ = fs::create_dir_all(&path);
    path.push("risk-config.json");
    path
}

/// Synchronous version for loading risk config at startup.
pub fn get_risk_config_sync() -> RiskConfig {
    let path = risk_config_path();
    if path.exists() {
        fs::read_to_string(&path)
            .ok()
            .and_then(|data| serde_json::from_str(&data).ok())
            .unwrap_or_default()
    } else {
        RiskConfig::default()
    }
}

pub fn save_risk_config_to_disk(config: &RiskConfig) -> Result<(), String> {
    let path = risk_config_path();
    let json = serde_json::to_string_pretty(config).map_err(|e| e.to_string())?;
    fs::write(&path, json).map_err(|e| e.to_string())?;
    Ok(())
}

// ---------------------------------------------------------------------------
// RiskGuard types
// ---------------------------------------------------------------------------

/// Represents an incoming order to be checked against risk rules.
#[derive(Debug, Clone)]
pub struct OrderRequest {
    /// Symbol/asset identifier (e.g. asset index as string).
    pub symbol: String,
    /// "buy" or "sell".
    pub side: String,
    /// Order size in USD notional value.
    pub size: f64,
    /// Order price.
    pub price: f64,
}

/// Snapshot of current account state used for risk evaluation.
#[derive(Debug, Clone)]
pub struct AccountState {
    /// Total position value across all symbols (in USD).
    pub total_position_value: f64,
    /// Per-symbol position values (in USD).
    pub position_by_symbol: HashMap<String, f64>,
    /// Realized loss for the current day (positive value = loss).
    pub daily_realized_loss: f64,
    /// Starting equity for the day (for percentage calculation).
    pub daily_starting_equity: f64,
    /// Losses within the circuit breaker window (positive = loss).
    pub windowed_loss: f64,
}

impl Default for AccountState {
    fn default() -> Self {
        Self {
            total_position_value: 0.0,
            position_by_symbol: HashMap::new(),
            daily_realized_loss: 0.0,
            daily_starting_equity: 100_000.0,
            windowed_loss: 0.0,
        }
    }
}

/// Describes a risk violation that blocks order execution.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RiskViolation {
    pub rule: String,
    pub message: String,
}

impl std::fmt::Display for RiskViolation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[{}] {}", self.rule, self.message)
    }
}

/// Tracks recent order timestamps and signatures for anomaly detection.
#[derive(Debug, Clone)]
struct RecentOrder {
    symbol: String,
    side: String,
    size: f64,
    timestamp: Instant,
}

// ---------------------------------------------------------------------------
// TA-based risk rules
// ---------------------------------------------------------------------------

/// Technical-analysis-based risk rule definitions.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum TaRiskRule {
    /// Block opening new positions when RSI is outside the safe range.
    RsiExtreme {
        /// RSI below this value is considered oversold extreme (default 20).
        lower: f64,
        /// RSI above this value is considered overbought extreme (default 80).
        upper: f64,
    },
    /// Warn / reduce position when ATR as a percentage of price exceeds threshold.
    AtrSurge {
        /// ATR / price * 100 threshold (e.g. 5.0 means 5%).
        threshold_pct: f64,
    },
    /// Block trading when price is outside Bollinger Bands by the given sigma multiplier.
    BollingerBreakout {
        /// Number of standard deviations (e.g. 3.0 for 3σ bands).
        sigma_multiplier: f64,
    },
}

/// Check a set of TA-based risk rules against current indicators and price.
///
/// Returns a list of violations (empty if all rules pass).
pub fn check_ta_risk(
    indicators: &TechnicalIndicators,
    price: f64,
    rules: &[TaRiskRule],
) -> Vec<RiskViolation> {
    let mut violations = Vec::new();

    for rule in rules {
        match rule {
            TaRiskRule::RsiExtreme { lower, upper } => {
                if let Some(rsi) = indicators.rsi_14 {
                    if rsi < *lower {
                        violations.push(RiskViolation {
                            rule: "RsiExtreme".to_string(),
                            message: format!(
                                "RSI ({:.2}) is below the lower extreme threshold ({:.2}). Opening new positions is restricted.",
                                rsi, lower,
                            ),
                        });
                    } else if rsi > *upper {
                        violations.push(RiskViolation {
                            rule: "RsiExtreme".to_string(),
                            message: format!(
                                "RSI ({:.2}) is above the upper extreme threshold ({:.2}). Opening new positions is restricted.",
                                rsi, upper,
                            ),
                        });
                    }
                }
            }
            TaRiskRule::AtrSurge { threshold_pct } => {
                if let Some(atr) = indicators.atr_14 {
                    if price > 0.0 {
                        let atr_pct = (atr / price) * 100.0;
                        if atr_pct > *threshold_pct {
                            violations.push(RiskViolation {
                                rule: "AtrSurge".to_string(),
                                message: format!(
                                    "ATR as percentage of price ({:.2}%) exceeds threshold ({:.2}%). Consider reducing position size.",
                                    atr_pct, threshold_pct,
                                ),
                            });
                        }
                    }
                }
            }
            TaRiskRule::BollingerBreakout { sigma_multiplier } => {
                // Use bb_middle and bb_upper/bb_lower to derive the standard deviation,
                // then compute custom bands at the requested sigma multiplier.
                if let (Some(bb_middle), Some(bb_upper)) =
                    (indicators.bb_middle, indicators.bb_upper)
                {
                    // Default BB uses 2σ, so σ = (bb_upper - bb_middle) / 2
                    let default_sigma = 2.0_f64;
                    let std_dev = (bb_upper - bb_middle) / default_sigma;
                    if std_dev > 0.0 {
                        let custom_upper = bb_middle + sigma_multiplier * std_dev;
                        let custom_lower = bb_middle - sigma_multiplier * std_dev;
                        if price > custom_upper {
                            violations.push(RiskViolation {
                                rule: "BollingerBreakout".to_string(),
                                message: format!(
                                    "Price ({:.2}) is above the {:.1}σ Bollinger upper band ({:.2}). Trading is paused.",
                                    price, sigma_multiplier, custom_upper,
                                ),
                            });
                        } else if price < custom_lower {
                            violations.push(RiskViolation {
                                rule: "BollingerBreakout".to_string(),
                                message: format!(
                                    "Price ({:.2}) is below the {:.1}σ Bollinger lower band ({:.2}). Trading is paused.",
                                    price, sigma_multiplier, custom_lower,
                                ),
                            });
                        }
                    }
                }
            }
        }
    }

    violations
}

// ---------------------------------------------------------------------------
// RiskGuard
// ---------------------------------------------------------------------------

pub struct RiskGuard {
    config: RiskConfig,
    /// TA-based risk rules evaluated against technical indicators.
    ta_rules: Vec<TaRiskRule>,
    /// Circuit breaker tripped flag. When true, all orders are blocked.
    circuit_breaker_tripped: Mutex<bool>,
    /// Timestamp when the circuit breaker was tripped.
    circuit_breaker_tripped_at: Mutex<Option<Instant>>,
    /// Recent orders for anomaly detection (orders per minute, duplicate detection).
    recent_orders: Mutex<Vec<RecentOrder>>,
}

impl RiskGuard {
    pub fn new(config: RiskConfig) -> Self {
        Self {
            config,
            ta_rules: Vec::new(),
            circuit_breaker_tripped: Mutex::new(false),
            circuit_breaker_tripped_at: Mutex::new(None),
            recent_orders: Mutex::new(Vec::new()),
        }
    }

    /// Create a RiskGuard with both standard config and TA-based risk rules.
    pub fn with_ta_rules(config: RiskConfig, ta_rules: Vec<TaRiskRule>) -> Self {
        Self {
            config,
            ta_rules,
            circuit_breaker_tripped: Mutex::new(false),
            circuit_breaker_tripped_at: Mutex::new(None),
            recent_orders: Mutex::new(Vec::new()),
        }
    }

    /// Replace the current TA risk rules.
    pub fn set_ta_rules(&mut self, rules: Vec<TaRiskRule>) {
        self.ta_rules = rules;
    }

    /// Update the risk config (e.g. when user saves new settings).
    #[allow(dead_code)]
    pub fn update_config(&mut self, config: RiskConfig) {
        self.config = config;
    }

    /// Check an order against all enabled risk rules **including** TA-based rules.
    ///
    /// Returns `Ok(())` if the order is allowed, or `Err` with the first
    /// blocking violation.  If you only want TA violations without blocking
    /// the order, call [`check_ta_risk`] directly.
    pub fn check_order_with_ta(
        &self,
        order: &OrderRequest,
        current_state: &AccountState,
        indicators: &TechnicalIndicators,
    ) -> Result<(), RiskViolation> {
        // Run standard checks first
        self.check_order(order, current_state)?;

        // Then check TA rules — return the highest-severity violation
        // (critical > warning) so that e.g. a BollingerBreakout is not masked
        // by an AtrSurge that happens to appear first in the rules list.
        if !self.ta_rules.is_empty() {
            let ta_violations = check_ta_risk(indicators, order.price, &self.ta_rules);
            if !ta_violations.is_empty() {
                // Pick the highest-severity violation.
                // Severity: critical > warning (same mapping as record_risk_alert).
                let highest = ta_violations
                    .into_iter()
                    .max_by_key(|v| match v.rule.as_str() {
                        "BollingerBreakout" | "CircuitBreaker" | "DailyLossGuard" => 2,
                        _ => 1, // warning-level: RsiExtreme, AtrSurge, etc.
                    })
                    .unwrap(); // safe: we checked !is_empty()
                return Err(highest);
            }
        }

        Ok(())
    }

    /// Check an order against all enabled risk rules.
    /// Returns Ok(()) if the order is allowed, Err(RiskViolation) if blocked.
    pub fn check_order(
        &self,
        order: &OrderRequest,
        current_state: &AccountState,
    ) -> Result<(), RiskViolation> {
        // Check circuit breaker first (blocks everything when tripped)
        self.check_circuit_breaker(current_state)?;

        // Check position limits
        self.check_position_limits(order, current_state)?;

        // Check daily loss limits
        self.check_daily_loss(current_state)?;

        // Check anomaly detection
        self.check_anomaly(order)?;

        // Order passed all checks - record it for future anomaly detection
        self.record_order(order);

        Ok(())
    }

    /// Check if circuit breaker is active and should block orders.
    fn check_circuit_breaker(&self, current_state: &AccountState) -> Result<(), RiskViolation> {
        if !self.config.circuit_breaker.enabled {
            return Ok(());
        }

        // Check if cooldown has expired
        {
            let mut tripped = self.circuit_breaker_tripped.lock().unwrap();
            let tripped_at = self.circuit_breaker_tripped_at.lock().unwrap();
            if *tripped {
                if let Some(at) = *tripped_at {
                    let cooldown = std::time::Duration::from_secs(
                        self.config.circuit_breaker.cooldown_minutes as u64 * 60,
                    );
                    if at.elapsed() >= cooldown {
                        // Cooldown expired, reset circuit breaker
                        *tripped = false;
                    }
                }
            }

            if *tripped {
                return Err(RiskViolation {
                    rule: "CircuitBreaker".to_string(),
                    message: format!(
                        "Circuit breaker is active. All trading is paused for {} minutes.",
                        self.config.circuit_breaker.cooldown_minutes
                    ),
                });
            }
        }

        // Check if windowed loss exceeds trigger threshold
        if current_state.windowed_loss >= self.config.circuit_breaker.trigger_loss {
            self.trip_circuit_breaker();
            return Err(RiskViolation {
                rule: "CircuitBreaker".to_string(),
                message: format!(
                    "Circuit breaker triggered: loss ${:.2} in the last {} minutes exceeds threshold ${:.2}. All trading paused.",
                    current_state.windowed_loss,
                    self.config.circuit_breaker.trigger_window_minutes,
                    self.config.circuit_breaker.trigger_loss,
                ),
            });
        }

        Ok(())
    }

    /// Trip the circuit breaker, blocking all subsequent orders.
    fn trip_circuit_breaker(&self) {
        let mut tripped = self.circuit_breaker_tripped.lock().unwrap();
        let mut tripped_at = self.circuit_breaker_tripped_at.lock().unwrap();
        *tripped = true;
        *tripped_at = Some(Instant::now());
    }

    /// Returns whether the circuit breaker is currently tripped.
    pub fn is_circuit_breaker_tripped(&self) -> bool {
        *self.circuit_breaker_tripped.lock().unwrap()
    }

    /// Check position limits (total and per-symbol).
    fn check_position_limits(
        &self,
        order: &OrderRequest,
        current_state: &AccountState,
    ) -> Result<(), RiskViolation> {
        if !self.config.position_limits.enabled {
            return Ok(());
        }

        let order_notional = order.size * order.price;

        // Check total position limit
        let new_total = current_state.total_position_value + order_notional;
        if new_total > self.config.position_limits.max_total_position {
            return Err(RiskViolation {
                rule: "MaxPositionGuard".to_string(),
                message: format!(
                    "Order would exceed total position limit. Current: ${:.2}, Order: ${:.2}, Limit: ${:.2}",
                    current_state.total_position_value,
                    order_notional,
                    self.config.position_limits.max_total_position,
                ),
            });
        }

        // Check per-symbol position limit
        let current_symbol_pos = current_state
            .position_by_symbol
            .get(&order.symbol)
            .copied()
            .unwrap_or(0.0);
        let new_symbol_pos = current_symbol_pos + order_notional;
        if new_symbol_pos > self.config.position_limits.max_per_symbol {
            return Err(RiskViolation {
                rule: "MaxPositionGuard".to_string(),
                message: format!(
                    "Order would exceed per-symbol position limit for '{}'. Current: ${:.2}, Order: ${:.2}, Limit: ${:.2}",
                    order.symbol,
                    current_symbol_pos,
                    order_notional,
                    self.config.position_limits.max_per_symbol,
                ),
            });
        }

        Ok(())
    }

    /// Check daily loss limits.
    fn check_daily_loss(&self, current_state: &AccountState) -> Result<(), RiskViolation> {
        if !self.config.daily_loss_limits.enabled {
            return Ok(());
        }

        // Check absolute daily loss
        if current_state.daily_realized_loss >= self.config.daily_loss_limits.max_daily_loss {
            return Err(RiskViolation {
                rule: "DailyLossGuard".to_string(),
                message: format!(
                    "Daily loss limit reached. Loss today: ${:.2}, Limit: ${:.2}",
                    current_state.daily_realized_loss, self.config.daily_loss_limits.max_daily_loss,
                ),
            });
        }

        // Check percentage daily loss
        if current_state.daily_starting_equity > 0.0 {
            let loss_pct =
                (current_state.daily_realized_loss / current_state.daily_starting_equity) * 100.0;
            if loss_pct >= self.config.daily_loss_limits.max_daily_loss_percent {
                return Err(RiskViolation {
                    rule: "DailyLossGuard".to_string(),
                    message: format!(
                        "Daily loss percentage limit reached. Loss: {:.2}%, Limit: {:.2}%",
                        loss_pct, self.config.daily_loss_limits.max_daily_loss_percent,
                    ),
                });
            }
        }

        Ok(())
    }

    /// Check anomaly detection rules (order size, rate, duplicates).
    fn check_anomaly(&self, order: &OrderRequest) -> Result<(), RiskViolation> {
        if !self.config.anomaly_detection.enabled {
            return Ok(());
        }

        let order_notional = order.size * order.price;

        // 1. Max order size check
        if order_notional > self.config.anomaly_detection.max_order_size {
            return Err(RiskViolation {
                rule: "AnomalyDetection".to_string(),
                message: format!(
                    "Order size ${:.2} exceeds maximum allowed order size ${:.2}",
                    order_notional, self.config.anomaly_detection.max_order_size,
                ),
            });
        }

        let mut recent = self.recent_orders.lock().unwrap();

        // Prune orders older than 1 minute
        let one_minute_ago = Instant::now() - std::time::Duration::from_secs(60);
        recent.retain(|o| o.timestamp > one_minute_ago);

        // 2. Orders per minute check
        if recent.len() >= self.config.anomaly_detection.max_orders_per_minute as usize {
            return Err(RiskViolation {
                rule: "AnomalyDetection".to_string(),
                message: format!(
                    "Rate limit exceeded: {} orders in the last minute (limit: {})",
                    recent.len(),
                    self.config.anomaly_detection.max_orders_per_minute,
                ),
            });
        }

        // 3. Duplicate order detection
        if self.config.anomaly_detection.block_duplicate_orders {
            let is_duplicate = recent.iter().any(|o| {
                o.symbol == order.symbol
                    && o.side == order.side
                    && (o.size - order.size).abs() < f64::EPSILON
            });
            if is_duplicate {
                return Err(RiskViolation {
                    rule: "AnomalyDetection".to_string(),
                    message: format!(
                        "Duplicate order detected: {} {} {:.4} on symbol '{}'",
                        order.side, order.size, order.price, order.symbol,
                    ),
                });
            }
        }

        Ok(())
    }

    /// Record an order for future anomaly detection checks.
    fn record_order(&self, order: &OrderRequest) {
        let mut recent = self.recent_orders.lock().unwrap();
        recent.push(RecentOrder {
            symbol: order.symbol.clone(),
            side: order.side.clone(),
            size: order.size,
            timestamp: Instant::now(),
        });
    }
}

// ---------------------------------------------------------------------------
// Alert integration helper
// ---------------------------------------------------------------------------

/// Record a risk violation as an alert history entry.
pub fn record_risk_alert(violation: &RiskViolation) {
    let entry = AlertHistoryEntry {
        id: uuid::Uuid::new_v4().to_string(),
        timestamp: chrono::Utc::now().to_rfc3339(),
        severity: match violation.rule.as_str() {
            "CircuitBreaker" | "DailyLossGuard" | "BollingerBreakout" => "critical".to_string(),
            "RsiExtreme" | "AtrSurge" => "warning".to_string(),
            _ => "warning".to_string(),
        },
        message: violation.to_string(),
        channel: "risk_guard".to_string(),
        status: "fired".to_string(),
    };

    let path = alert_history_path();
    let mut history: Vec<AlertHistoryEntry> = if path.exists() {
        fs::read_to_string(&path)
            .ok()
            .and_then(|data| serde_json::from_str(&data).ok())
            .unwrap_or_default()
    } else {
        Vec::new()
    };

    history.push(entry);

    if let Ok(json) = serde_json::to_string_pretty(&history) {
        let _ = fs::write(&path, json);
    }
}

// ---------------------------------------------------------------------------
// Convenience free function for pre-trade risk checks
// ---------------------------------------------------------------------------

/// Perform a pre-trade risk check using the on-disk risk config.
///
/// Loads the current `RiskConfig` from disk (or defaults), constructs a
/// temporary `RiskGuard`, and validates the order against all enabled rules.
///
/// Returns `Ok(())` if the order passes all checks, or `Err(String)` with a
/// descriptive message if any risk rule blocks the order. Violations are
/// automatically recorded to the alert history.
///
/// This is a convenience wrapper around `RiskGuard::check_order` for callers
/// that do not hold a long-lived `RiskGuard` instance.
pub fn check_risk(order: &OrderRequest, account_state: &AccountState) -> Result<(), String> {
    let config = get_risk_config_sync();
    let guard = RiskGuard::new(config);
    match guard.check_order(order, account_state) {
        Ok(()) => Ok(()),
        Err(violation) => {
            record_risk_alert(&violation);
            Err(format!("Risk violation: {}", violation))
        }
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

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

    fn default_guard() -> RiskGuard {
        RiskGuard::new(RiskConfig::default())
    }

    fn default_state() -> AccountState {
        AccountState::default()
    }

    fn make_order(symbol: &str, side: &str, size: f64, price: f64) -> OrderRequest {
        OrderRequest {
            symbol: symbol.to_string(),
            side: side.to_string(),
            size,
            price,
        }
    }

    // ---- Position limits ----

    #[test]
    fn test_order_within_position_limits_passes() {
        let guard = default_guard();
        let state = default_state();
        let order = make_order("BTC", "buy", 0.1, 30_000.0); // $3,000
        assert!(guard.check_order(&order, &state).is_ok());
    }

    #[test]
    fn test_order_exceeds_total_position_limit() {
        let guard = default_guard();
        let state = AccountState {
            total_position_value: 99_000.0,
            ..default_state()
        };
        // $99,000 existing + $2,000 new = $101,000 > $100,000 limit
        let order = make_order("BTC", "buy", 1.0, 2_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "MaxPositionGuard");
        assert!(violation.message.contains("total position limit"));
    }

    #[test]
    fn test_order_exceeds_per_symbol_position_limit() {
        let guard = default_guard();
        let mut position_by_symbol = HashMap::new();
        position_by_symbol.insert("BTC".to_string(), 24_000.0);
        let state = AccountState {
            total_position_value: 24_000.0,
            position_by_symbol,
            ..default_state()
        };
        // $24,000 existing + $2,000 new = $26,000 > $25,000 per-symbol limit
        let order = make_order("BTC", "buy", 1.0, 2_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "MaxPositionGuard");
        assert!(violation.message.contains("per-symbol"));
    }

    #[test]
    fn test_position_limits_disabled() {
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: false,
                max_total_position: 1.0,
                max_per_symbol: 1.0,
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 1_000_000.0, // high enough to not trigger
                max_orders_per_minute: 10,
                block_duplicate_orders: false,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);
        let state = AccountState {
            total_position_value: 999_999.0,
            ..default_state()
        };
        let order = make_order("BTC", "buy", 1.0, 100_000.0);
        assert!(guard.check_order(&order, &state).is_ok());
    }

    // ---- Daily loss limits ----

    #[test]
    fn test_daily_loss_limit_absolute() {
        let guard = default_guard();
        let state = AccountState {
            daily_realized_loss: 5_000.0, // equals limit
            ..default_state()
        };
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "DailyLossGuard");
    }

    #[test]
    fn test_daily_loss_limit_percentage() {
        let guard = default_guard();
        let state = AccountState {
            daily_realized_loss: 5_500.0,
            daily_starting_equity: 100_000.0, // 5.5% > 5%
            ..default_state()
        };
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "DailyLossGuard");
    }

    #[test]
    fn test_daily_loss_below_limit_passes() {
        let guard = default_guard();
        let state = AccountState {
            daily_realized_loss: 1_000.0,
            daily_starting_equity: 100_000.0,
            ..default_state()
        };
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        assert!(guard.check_order(&order, &state).is_ok());
    }

    // ---- Anomaly detection ----

    #[test]
    fn test_max_order_size_exceeded() {
        // Use a config with high position limits so only anomaly detection triggers
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: false,
                ..RiskConfig::default().position_limits
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 50_000.0,
                max_orders_per_minute: 10,
                block_duplicate_orders: true,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);
        let state = default_state();
        // $60,000 > $50,000 max order size
        let order = make_order("BTC", "buy", 2.0, 30_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "AnomalyDetection");
        assert!(violation.message.contains("maximum allowed order size"));
    }

    #[test]
    fn test_orders_per_minute_exceeded() {
        let config = RiskConfig {
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 1_000_000.0,
                max_orders_per_minute: 3,
                block_duplicate_orders: false,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);
        let state = default_state();

        // Place 3 orders (at limit)
        for i in 0..3 {
            let order = make_order("BTC", "buy", 0.01 * (i as f64 + 1.0), 30_000.0);
            assert!(guard.check_order(&order, &state).is_ok());
        }

        // 4th order should be rate limited
        let order = make_order("ETH", "buy", 0.1, 2_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "AnomalyDetection");
        assert!(violation.message.contains("Rate limit"));
    }

    #[test]
    fn test_duplicate_order_detection() {
        let guard = default_guard();
        let state = default_state();

        let order = make_order("BTC", "buy", 0.1, 30_000.0);
        assert!(guard.check_order(&order, &state).is_ok());

        // Same symbol + side + size = duplicate
        let duplicate = make_order("BTC", "buy", 0.1, 31_000.0);
        let result = guard.check_order(&duplicate, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "AnomalyDetection");
        assert!(violation.message.contains("Duplicate"));
    }

    #[test]
    fn test_non_duplicate_different_side_passes() {
        let guard = default_guard();
        let state = default_state();

        let order1 = make_order("BTC", "buy", 0.1, 30_000.0);
        assert!(guard.check_order(&order1, &state).is_ok());

        // Different side = not a duplicate
        let order2 = make_order("BTC", "sell", 0.1, 30_000.0);
        assert!(guard.check_order(&order2, &state).is_ok());
    }

    // ---- Circuit breaker ----

    #[test]
    fn test_circuit_breaker_triggers_on_windowed_loss() {
        let config = RiskConfig {
            circuit_breaker: CircuitBreaker {
                enabled: true,
                trigger_loss: 10_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);
        let state = AccountState {
            windowed_loss: 10_000.0, // equals trigger
            ..default_state()
        };

        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let result = guard.check_order(&order, &state);
        assert!(result.is_err());
        let violation = result.unwrap_err();
        assert_eq!(violation.rule, "CircuitBreaker");
        assert!(guard.is_circuit_breaker_tripped());
    }

    #[test]
    fn test_circuit_breaker_blocks_subsequent_orders() {
        let config = RiskConfig {
            circuit_breaker: CircuitBreaker {
                enabled: true,
                trigger_loss: 10_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);

        // Trip the circuit breaker
        let bad_state = AccountState {
            windowed_loss: 15_000.0,
            ..default_state()
        };
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let _ = guard.check_order(&order, &bad_state);

        // Now try with a clean state - should still be blocked
        let clean_state = default_state();
        let result = guard.check_order(&order, &clean_state);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err().rule, "CircuitBreaker");
    }

    #[test]
    fn test_circuit_breaker_disabled() {
        let config = RiskConfig {
            circuit_breaker: CircuitBreaker {
                enabled: false,
                trigger_loss: 1.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
            ..RiskConfig::default()
        };
        let guard = RiskGuard::new(config);
        let state = AccountState {
            windowed_loss: 999_999.0,
            ..default_state()
        };
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        assert!(guard.check_order(&order, &state).is_ok());
    }

    // ---- Integration: all rules pass ----

    #[test]
    fn test_all_rules_pass_for_small_order() {
        let guard = default_guard();
        let state = default_state();
        let order = make_order("BTC", "buy", 0.01, 30_000.0); // $300
        assert!(guard.check_order(&order, &state).is_ok());
    }

    // ---- RiskViolation display ----

    #[test]
    fn test_risk_violation_display() {
        let v = RiskViolation {
            rule: "TestRule".to_string(),
            message: "something went wrong".to_string(),
        };
        assert_eq!(format!("{}", v), "[TestRule] something went wrong");
    }

    // ---- Config update ----

    #[test]
    fn test_update_config() {
        // Start with a config that blocks via anomaly detection (position limits disabled)
        let config = RiskConfig {
            position_limits: PositionLimits {
                enabled: false,
                ..RiskConfig::default().position_limits
            },
            anomaly_detection: AnomalyDetection {
                enabled: true,
                max_order_size: 50_000.0,
                max_orders_per_minute: 10,
                block_duplicate_orders: false,
            },
            ..RiskConfig::default()
        };
        let mut guard = RiskGuard::new(config);
        let state = default_state();
        let big_order = make_order("BTC", "buy", 2.0, 30_000.0); // $60k

        // Should fail with max_order_size = $50k
        assert!(guard.check_order(&big_order, &state).is_err());

        // Update config to allow larger orders
        let mut new_config = RiskConfig::default();
        new_config.position_limits.enabled = false;
        new_config.anomaly_detection.max_order_size = 100_000.0;
        new_config.anomaly_detection.block_duplicate_orders = false;
        guard.update_config(new_config);

        assert!(guard.check_order(&big_order, &state).is_ok());
    }

    // ---- TA risk rules ----

    fn make_indicators(
        rsi: Option<f64>,
        atr: Option<f64>,
        bb: Option<(f64, f64, f64)>,
    ) -> TechnicalIndicators {
        let mut ind = TechnicalIndicators::empty();
        ind.rsi_14 = rsi;
        ind.atr_14 = atr;
        if let Some((upper, middle, lower)) = bb {
            ind.bb_upper = Some(upper);
            ind.bb_middle = Some(middle);
            ind.bb_lower = Some(lower);
        }
        ind
    }

    // -- RSI extreme tests --

    #[test]
    fn test_rsi_extreme_below_lower() {
        let rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        let ind = make_indicators(Some(15.0), None, None);
        let violations = check_ta_risk(&ind, 100.0, &rules);
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule, "RsiExtreme");
        assert!(violations[0].message.contains("below"));
    }

    #[test]
    fn test_rsi_extreme_above_upper() {
        let rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        let ind = make_indicators(Some(85.0), None, None);
        let violations = check_ta_risk(&ind, 100.0, &rules);
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule, "RsiExtreme");
        assert!(violations[0].message.contains("above"));
    }

    #[test]
    fn test_rsi_within_range_passes() {
        let rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        let ind = make_indicators(Some(50.0), None, None);
        let violations = check_ta_risk(&ind, 100.0, &rules);
        assert!(violations.is_empty());
    }

    #[test]
    fn test_rsi_at_boundary_passes() {
        let rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        // Exactly at boundary should NOT trigger (only < lower or > upper)
        let ind_lower = make_indicators(Some(20.0), None, None);
        assert!(check_ta_risk(&ind_lower, 100.0, &rules).is_empty());
        let ind_upper = make_indicators(Some(80.0), None, None);
        assert!(check_ta_risk(&ind_upper, 100.0, &rules).is_empty());
    }

    #[test]
    fn test_rsi_none_skips_check() {
        let rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        let ind = make_indicators(None, None, None);
        assert!(check_ta_risk(&ind, 100.0, &rules).is_empty());
    }

    // -- ATR surge tests --

    #[test]
    fn test_atr_surge_exceeds_threshold() {
        let rules = vec![TaRiskRule::AtrSurge { threshold_pct: 5.0 }];
        // ATR = 60, price = 1000 → 6% > 5%
        let ind = make_indicators(None, Some(60.0), None);
        let violations = check_ta_risk(&ind, 1000.0, &rules);
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule, "AtrSurge");
        assert!(violations[0].message.contains("6.00%"));
    }

    #[test]
    fn test_atr_surge_below_threshold_passes() {
        let rules = vec![TaRiskRule::AtrSurge { threshold_pct: 5.0 }];
        // ATR = 40, price = 1000 → 4% < 5%
        let ind = make_indicators(None, Some(40.0), None);
        assert!(check_ta_risk(&ind, 1000.0, &rules).is_empty());
    }

    #[test]
    fn test_atr_surge_at_threshold_passes() {
        let rules = vec![TaRiskRule::AtrSurge { threshold_pct: 5.0 }];
        // ATR = 50, price = 1000 → exactly 5%, not > 5%
        let ind = make_indicators(None, Some(50.0), None);
        assert!(check_ta_risk(&ind, 1000.0, &rules).is_empty());
    }

    #[test]
    fn test_atr_surge_zero_price_skips() {
        let rules = vec![TaRiskRule::AtrSurge { threshold_pct: 5.0 }];
        let ind = make_indicators(None, Some(60.0), None);
        assert!(check_ta_risk(&ind, 0.0, &rules).is_empty());
    }

    #[test]
    fn test_atr_none_skips_check() {
        let rules = vec![TaRiskRule::AtrSurge { threshold_pct: 5.0 }];
        let ind = make_indicators(None, None, None);
        assert!(check_ta_risk(&ind, 1000.0, &rules).is_empty());
    }

    // -- Bollinger breakout tests --

    #[test]
    fn test_bollinger_breakout_above_upper() {
        // Default BB uses 2σ. bb_middle=100, bb_upper=110 → σ=5
        // 3σ upper = 100 + 15 = 115. Price 120 > 115 → violation
        let rules = vec![TaRiskRule::BollingerBreakout {
            sigma_multiplier: 3.0,
        }];
        let ind = make_indicators(None, None, Some((110.0, 100.0, 90.0)));
        let violations = check_ta_risk(&ind, 120.0, &rules);
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule, "BollingerBreakout");
        assert!(violations[0].message.contains("above"));
    }

    #[test]
    fn test_bollinger_breakout_below_lower() {
        // σ=5, 3σ lower = 100 - 15 = 85. Price 80 < 85 → violation
        let rules = vec![TaRiskRule::BollingerBreakout {
            sigma_multiplier: 3.0,
        }];
        let ind = make_indicators(None, None, Some((110.0, 100.0, 90.0)));
        let violations = check_ta_risk(&ind, 80.0, &rules);
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule, "BollingerBreakout");
        assert!(violations[0].message.contains("below"));
    }

    #[test]
    fn test_bollinger_within_bands_passes() {
        // σ=5, 3σ range = [85, 115]. Price 100 → OK
        let rules = vec![TaRiskRule::BollingerBreakout {
            sigma_multiplier: 3.0,
        }];
        let ind = make_indicators(None, None, Some((110.0, 100.0, 90.0)));
        assert!(check_ta_risk(&ind, 100.0, &rules).is_empty());
    }

    #[test]
    fn test_bollinger_none_skips_check() {
        let rules = vec![TaRiskRule::BollingerBreakout {
            sigma_multiplier: 3.0,
        }];
        let ind = make_indicators(None, None, None);
        assert!(check_ta_risk(&ind, 120.0, &rules).is_empty());
    }

    // -- Multiple rules at once --

    #[test]
    fn test_multiple_rules_all_triggered() {
        let rules = vec![
            TaRiskRule::RsiExtreme {
                lower: 20.0,
                upper: 80.0,
            },
            TaRiskRule::AtrSurge { threshold_pct: 5.0 },
            TaRiskRule::BollingerBreakout {
                sigma_multiplier: 3.0,
            },
        ];
        // RSI=90 (above 80), ATR=60 on price 1000 (6%), BB: σ=5, 3σ upper=115, price=120
        let mut ind = TechnicalIndicators::empty();
        ind.rsi_14 = Some(90.0);
        ind.atr_14 = Some(60.0);
        ind.bb_upper = Some(110.0);
        ind.bb_middle = Some(100.0);
        ind.bb_lower = Some(90.0);
        // Note: for ATR we use price=1000 but for BB we'd need price=120.
        // Use price=120 to trigger BB; ATR 60/120*100 = 50% > 5% also triggers.
        let violations = check_ta_risk(&ind, 120.0, &rules);
        assert_eq!(violations.len(), 3);
        let rule_names: Vec<&str> = violations.iter().map(|v| v.rule.as_str()).collect();
        assert!(rule_names.contains(&"RsiExtreme"));
        assert!(rule_names.contains(&"AtrSurge"));
        assert!(rule_names.contains(&"BollingerBreakout"));
    }

    #[test]
    fn test_empty_rules_no_violations() {
        let rules: Vec<TaRiskRule> = vec![];
        let ind = make_indicators(Some(10.0), Some(100.0), Some((110.0, 100.0, 90.0)));
        assert!(check_ta_risk(&ind, 120.0, &rules).is_empty());
    }

    // -- Integration: check_order_with_ta --

    #[test]
    fn test_check_order_with_ta_blocks_on_rsi() {
        let ta_rules = vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }];
        let guard = RiskGuard::with_ta_rules(RiskConfig::default(), ta_rules);
        let state = default_state();
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let ind = make_indicators(Some(85.0), None, None);
        let result = guard.check_order_with_ta(&order, &state, &ind);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err().rule, "RsiExtreme");
    }

    #[test]
    fn test_check_order_with_ta_passes_when_clean() {
        let ta_rules = vec![
            TaRiskRule::RsiExtreme {
                lower: 20.0,
                upper: 80.0,
            },
            TaRiskRule::AtrSurge { threshold_pct: 5.0 },
        ];
        let guard = RiskGuard::with_ta_rules(RiskConfig::default(), ta_rules);
        let state = default_state();
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let ind = make_indicators(Some(50.0), Some(100.0), None); // ATR 100/30000 = 0.33%
        assert!(guard.check_order_with_ta(&order, &state, &ind).is_ok());
    }

    #[test]
    fn test_set_ta_rules() {
        let mut guard = default_guard();
        let state = default_state();
        let order1 = make_order("BTC", "buy", 0.01, 30_000.0);
        let ind = make_indicators(Some(85.0), None, None);

        // No TA rules yet — should pass
        assert!(guard.check_order_with_ta(&order1, &state, &ind).is_ok());

        // Add RSI rule — use a different order to avoid duplicate detection
        guard.set_ta_rules(vec![TaRiskRule::RsiExtreme {
            lower: 20.0,
            upper: 80.0,
        }]);
        let order2 = make_order("BTC", "buy", 0.02, 30_000.0);
        let result = guard.check_order_with_ta(&order2, &state, &ind);
        assert!(result.is_err());
        assert_eq!(result.unwrap_err().rule, "RsiExtreme");
    }

    #[test]
    fn test_check_order_with_ta_returns_highest_severity_violation() {
        // AtrSurge (warning) comes first in the rules list, but
        // BollingerBreakout (critical) should be the one returned.
        let ta_rules = vec![
            TaRiskRule::AtrSurge { threshold_pct: 5.0 },
            TaRiskRule::BollingerBreakout {
                sigma_multiplier: 3.0,
            },
        ];
        let guard = RiskGuard::with_ta_rules(RiskConfig::default(), ta_rules);
        let state = default_state();
        // Price 120, ATR=60 → 60/120*100=50% > 5% (AtrSurge triggers)
        // BB: σ=5, 3σ upper=115, price 120 > 115 (BollingerBreakout triggers)
        let mut ind = TechnicalIndicators::empty();
        ind.atr_14 = Some(60.0);
        ind.bb_upper = Some(110.0);
        ind.bb_middle = Some(100.0);
        ind.bb_lower = Some(90.0);
        let order = make_order("BTC", "buy", 0.01, 120.0);
        let result = guard.check_order_with_ta(&order, &state, &ind);
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err().rule,
            "BollingerBreakout",
            "should return the critical-level violation, not the warning-level one"
        );
    }

    #[test]
    fn test_check_order_with_ta_circuit_breaker_tripped_ta_clean() {
        // Backward compat: standard check (circuit breaker) fails even
        // though TA indicators are perfectly clean.
        let config = RiskConfig {
            circuit_breaker: CircuitBreaker {
                enabled: true,
                trigger_loss: 10_000.0,
                trigger_window_minutes: 60,
                action: "pause_all".to_string(),
                cooldown_minutes: 30,
            },
            ..RiskConfig::default()
        };
        let ta_rules = vec![
            TaRiskRule::RsiExtreme {
                lower: 20.0,
                upper: 80.0,
            },
            TaRiskRule::AtrSurge { threshold_pct: 5.0 },
        ];
        let guard = RiskGuard::with_ta_rules(config, ta_rules);
        let state = AccountState {
            windowed_loss: 15_000.0, // trips the circuit breaker
            ..default_state()
        };
        // TA indicators are clean (RSI=50, ATR low)
        let ind = make_indicators(Some(50.0), Some(10.0), None);
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let result = guard.check_order_with_ta(&order, &state, &ind);
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err().rule,
            "CircuitBreaker",
            "standard circuit breaker should still block even when TA is clean"
        );
    }

    #[test]
    fn test_bollinger_partial_data_skips_check() {
        // bb_middle is present but bb_upper is None → should safely skip
        let rules = vec![TaRiskRule::BollingerBreakout {
            sigma_multiplier: 3.0,
        }];
        let mut ind = TechnicalIndicators::empty();
        ind.bb_middle = Some(100.0);
        // bb_upper and bb_lower intentionally left as None
        let violations = check_ta_risk(&ind, 120.0, &rules);
        assert!(
            violations.is_empty(),
            "partial Bollinger data (bb_upper=None) should skip the check, not panic"
        );
    }

    // ---- check_risk free function ----

    #[test]
    fn test_check_risk_passes_small_order() {
        let order = make_order("BTC", "buy", 0.01, 30_000.0); // $300
        let state = default_state();
        assert!(check_risk(&order, &state).is_ok());
    }

    #[test]
    fn test_check_risk_blocks_on_daily_loss() {
        let order = make_order("BTC", "buy", 0.01, 30_000.0);
        let state = AccountState {
            daily_realized_loss: 10_000.0, // exceeds default $5,000 limit
            ..default_state()
        };
        let result = check_risk(&order, &state);
        assert!(result.is_err());
        let err_msg = result.unwrap_err();
        assert!(err_msg.contains("Risk violation"), "Error: {}", err_msg);
    }
}