foxhunt/risk/src/error_consolidated.rs

//! Consolidated error handling for the Risk module using CommonError
//!
//! This module demonstrates the consolidated error handling pattern
//! using the common error system across all Foxhunt Risk services.

// ELIMINATED: Re-exports removed to force explicit imports

/// Result type for risk operations using CommonError
pub type RiskResult<T> = CommonResult<T>;

/// Risk module specific error extensions
/// For cases where we need domain-specific error information beyond CommonError
#[derive(Debug, thiserror::Error)]
pub enum RiskServiceError {
    /// Common error with context
    #[error("Risk service error: {0}")]
    Common(#[from] CommonError),

    /// Position limit violation with specific context
    #[error("Position limit exceeded: {instrument} position {current} exceeds limit {limit}")]
    PositionLimitExceeded {
        instrument: String,
        current: f64,
        limit: f64,
    },

    /// VaR limit violation with risk metrics
    #[error("VaR limit exceeded: {var_value} exceeds limit {limit} (confidence: {confidence}%)")]
    VarLimitExceeded {
        var_value: f64,
        limit: f64,
        confidence: f64,
    },

    /// Drawdown limit violation
    #[error("Drawdown limit exceeded: {drawdown}% exceeds limit {limit}%")]
    DrawdownLimitExceeded {
        drawdown: f64,
        limit: f64,
    },

    /// Circuit breaker activation
    #[error("Circuit breaker activated: {instrument} - {reason}")]
    CircuitBreakerActive {
        instrument: String,
        reason: String,
    },

    /// Kill switch activation with scope
    #[error("Kill switch activated: {scope} - {reason}")]
    KillSwitchActive {
        scope: String,
        reason: String,
    },

    /// Market data unavailable for risk calculation
    #[error("Market data unavailable: {instrument} required for risk calculation")]
    MarketDataUnavailable {
        instrument: String,
    },

    /// Compliance violation
    #[error("Compliance violation: {rule} - {message}")]
    ComplianceViolation {
        rule: String,
        message: String,
    },

    /// Risk calculation failure
    #[error("Risk calculation failed: {calculation} - {message}")]
    CalculationFailed {
        calculation: String,
        message: String,
    },

    /// Stress test failure
    #[error("Stress test failed: {scenario} - {message}")]
    StressTestFailed {
        scenario: String,
        message: String,
    },

    /// Performance violation
    #[error("Performance violation: {metric} value {actual} exceeds threshold {threshold}")]
    PerformanceViolation {
        metric: String,
        actual: f64,
        threshold: f64,
    },
}

impl RiskServiceError {
    /// Convert to CommonError for metrics and monitoring
    pub fn to_common_error(self) -> CommonError {
        match self {
            RiskServiceError::Common(err) => err,
            RiskServiceError::PositionLimitExceeded { instrument, current, limit } => {
                CommonError::risk(
                    "position_limit",
                    format!("{} position {} exceeds limit {}", instrument, current, limit)
                )
            }
            RiskServiceError::VarLimitExceeded { var_value, limit, confidence } => {
                CommonError::risk(
                    "var_limit",
                    format!("VaR {} exceeds limit {} ({}% confidence)", var_value, limit, confidence)
                )
            }
            RiskServiceError::DrawdownLimitExceeded { drawdown, limit } => {
                CommonError::risk(
                    "drawdown_limit",
                    format!("Drawdown {}% exceeds limit {}%", drawdown, limit)
                )
            }
            RiskServiceError::CircuitBreakerActive { instrument, reason } => {
                CommonError::risk(
                    "circuit_breaker",
                    format!("Circuit breaker active for {}: {}", instrument, reason)
                )
            }
            RiskServiceError::KillSwitchActive { scope, reason } => {
                CommonError::risk(
                    "kill_switch",
                    format!("Kill switch active for {}: {}", scope, reason)
                )
            }
            RiskServiceError::MarketDataUnavailable { instrument } => {
                CommonError::service(
                    ErrorCategory::MarketData,
                    format!("Market data unavailable for {}", instrument)
                )
            }
            RiskServiceError::ComplianceViolation { rule, message } => {
                CommonError::risk(
                    "compliance",
                    format!("Rule {} violated: {}", rule, message)
                )
            }
            RiskServiceError::CalculationFailed { calculation, message } => {
                CommonError::risk(
                    "calculation",
                    format!("Calculation {} failed: {}", calculation, message)
                )
            }
            RiskServiceError::StressTestFailed { scenario, message } => {
                CommonError::risk(
                    "stress_test",
                    format!("Stress test {} failed: {}", scenario, message)
                )
            }
            RiskServiceError::PerformanceViolation { metric, actual, threshold } => {
                CommonError::risk(
                    "performance",
                    format!("Metric {} value {} exceeds threshold {}", metric, actual, threshold)
                )
            }
        }
    }

    /// Get error category for metrics
    pub fn category(&self) -> ErrorCategory {
        match self {
            RiskServiceError::Common(_) => self.to_common_error().category(),
            RiskServiceError::MarketDataUnavailable { .. } => ErrorCategory::MarketData,
            _ => ErrorCategory::Risk,
        }
    }

    /// Get error severity - Risk errors are generally critical
    pub fn severity(&self) -> ErrorSeverity {
        match self {
            RiskServiceError::KillSwitchActive { .. } => ErrorSeverity::Critical,
            RiskServiceError::DrawdownLimitExceeded { .. } => ErrorSeverity::Critical,
            RiskServiceError::ComplianceViolation { .. } => ErrorSeverity::Critical,
            RiskServiceError::PositionLimitExceeded { .. } => ErrorSeverity::Error,
            RiskServiceError::VarLimitExceeded { .. } => ErrorSeverity::Error,
            RiskServiceError::CircuitBreakerActive { .. } => ErrorSeverity::Error,
            RiskServiceError::CalculationFailed { .. } => ErrorSeverity::Error,
            RiskServiceError::StressTestFailed { .. } => ErrorSeverity::Warn,
            RiskServiceError::PerformanceViolation { .. } => ErrorSeverity::Warn,
            RiskServiceError::MarketDataUnavailable { .. } => ErrorSeverity::Warn,
            RiskServiceError::Common(_) => self.to_common_error().severity(),
        }
    }

    /// Get retry strategy - Risk errors generally should not be retried
    pub fn retry_strategy(&self) -> RetryStrategy {
        match self {
            // Critical risk violations should NEVER be retried
            RiskServiceError::KillSwitchActive { .. } => RetryStrategy::NoRetry,
            RiskServiceError::DrawdownLimitExceeded { .. } => RetryStrategy::NoRetry,
            RiskServiceError::PositionLimitExceeded { .. } => RetryStrategy::NoRetry,
            RiskServiceError::VarLimitExceeded { .. } => RetryStrategy::NoRetry,
            RiskServiceError::ComplianceViolation { .. } => RetryStrategy::NoRetry,
            
            // System issues can be retried
            RiskServiceError::MarketDataUnavailable { .. } => RetryStrategy::Exponential {
                base_delay_ms: 1000,
                max_delay_ms: 10000,
            },
            RiskServiceError::CalculationFailed { .. } => RetryStrategy::Linear {
                base_delay_ms: 500,
            },
            
            // Other errors use default logic
            RiskServiceError::CircuitBreakerActive { .. } => RetryStrategy::CircuitBreaker,
            RiskServiceError::StressTestFailed { .. } => RetryStrategy::Linear {
                base_delay_ms: 2000,
            },
            RiskServiceError::PerformanceViolation { .. } => RetryStrategy::NoRetry,
            RiskServiceError::Common(_) => self.to_common_error().retry_strategy(),
        }
    }

    /// Check if error is retryable
    pub fn is_retryable(&self) -> bool {
        !matches!(self.retry_strategy(), RetryStrategy::NoRetry)
    }

    /// Get error code for monitoring
    pub fn error_code(&self) -> &'static str {
        match self {
            RiskServiceError::Common(_) => "RISK_COMMON_ERROR",
            RiskServiceError::PositionLimitExceeded { .. } => "RISK_POSITION_LIMIT_EXCEEDED",
            RiskServiceError::VarLimitExceeded { .. } => "RISK_VAR_LIMIT_EXCEEDED",
            RiskServiceError::DrawdownLimitExceeded { .. } => "RISK_DRAWDOWN_LIMIT_EXCEEDED",
            RiskServiceError::CircuitBreakerActive { .. } => "RISK_CIRCUIT_BREAKER_ACTIVE",
            RiskServiceError::KillSwitchActive { .. } => "RISK_KILL_SWITCH_ACTIVE",
            RiskServiceError::MarketDataUnavailable { .. } => "RISK_MARKET_DATA_UNAVAILABLE",
            RiskServiceError::ComplianceViolation { .. } => "RISK_COMPLIANCE_VIOLATION",
            RiskServiceError::CalculationFailed { .. } => "RISK_CALCULATION_FAILED",
            RiskServiceError::StressTestFailed { .. } => "RISK_STRESS_TEST_FAILED",
            RiskServiceError::PerformanceViolation { .. } => "RISK_PERFORMANCE_VIOLATION",
        }
    }

    /// Check if this error should trigger a kill switch
    pub fn should_trigger_kill_switch(&self) -> bool {
        matches!(
            self,
            RiskServiceError::DrawdownLimitExceeded { .. } | RiskServiceError::ComplianceViolation { .. }
        )
    }

    /// Check if this error should trigger a circuit breaker
    pub fn should_trigger_circuit_breaker(&self) -> bool {
        matches!(
            self,
            RiskServiceError::PositionLimitExceeded { .. } | RiskServiceError::VarLimitExceeded { .. }
        )
    }
}

/// Convert standard errors to CommonError for consistent handling
impl From<std::io::Error> for RiskServiceError {
    fn from(err: std::io::Error) -> Self {
        RiskServiceError::Common(CommonError::network(format!("IO error: {}", err)))
    }
}

impl From<serde_json::Error> for RiskServiceError {
    fn from(err: serde_json::Error) -> Self {
        RiskServiceError::Common(CommonError::serialization(format!("JSON error: {}", err)))
    }
}

impl From<anyhow::Error> for RiskServiceError {
    fn from(err: anyhow::Error) -> Self {
        RiskServiceError::Common(CommonError::internal(format!("Anyhow error: {}", err)))
    }
}

impl From<tokio::time::error::Elapsed> for RiskServiceError {
    fn from(_: tokio::time::error::Elapsed) -> Self {
        RiskServiceError::Common(CommonError::timeout(5000, 2000))
    }
}

/// Convenience functions for creating risk service errors
impl RiskServiceError {
    /// Create position limit exceeded error
    pub fn position_limit_exceeded<I: Into<String>>(instrument: I, current: f64, limit: f64) -> Self {
        Self::PositionLimitExceeded {
            instrument: instrument.into(),
            current,
            limit,
        }
    }

    /// Create VaR limit exceeded error
    pub fn var_limit_exceeded(var_value: f64, limit: f64, confidence: f64) -> Self {
        Self::VarLimitExceeded {
            var_value,
            limit,
            confidence,
        }
    }

    /// Create drawdown limit exceeded error
    pub fn drawdown_limit_exceeded(drawdown: f64, limit: f64) -> Self {
        Self::DrawdownLimitExceeded { drawdown, limit }
    }

    /// Create circuit breaker active error
    pub fn circuit_breaker_active<I: Into<String>, R: Into<String>>(instrument: I, reason: R) -> Self {
        Self::CircuitBreakerActive {
            instrument: instrument.into(),
            reason: reason.into(),
        }
    }

    /// Create kill switch active error
    pub fn kill_switch_active<S: Into<String>, R: Into<String>>(scope: S, reason: R) -> Self {
        Self::KillSwitchActive {
            scope: scope.into(),
            reason: reason.into(),
        }
    }

    /// Create market data unavailable error
    pub fn market_data_unavailable<I: Into<String>>(instrument: I) -> Self {
        Self::MarketDataUnavailable {
            instrument: instrument.into(),
        }
    }

    /// Create compliance violation error
    pub fn compliance_violation<R: Into<String>, M: Into<String>>(rule: R, message: M) -> Self {
        Self::ComplianceViolation {
            rule: rule.into(),
            message: message.into(),
        }
    }

    /// Create calculation failed error
    pub fn calculation_failed<C: Into<String>, M: Into<String>>(calculation: C, message: M) -> Self {
        Self::CalculationFailed {
            calculation: calculation.into(),
            message: message.into(),
        }
    }

    /// Create stress test failed error
    pub fn stress_test_failed<S: Into<String>, M: Into<String>>(scenario: S, message: M) -> Self {
        Self::StressTestFailed {
            scenario: scenario.into(),
            message: message.into(),
        }
    }

    /// Create performance violation error
    pub fn performance_violation<M: Into<String>>(metric: M, actual: f64, threshold: f64) -> Self {
        Self::PerformanceViolation {
            metric: metric.into(),
            actual,
            threshold,
        }
    }

    /// Create configuration error using CommonError
    pub fn configuration<M: Into<String>>(message: M) -> Self {
        Self::Common(CommonError::config(message))
    }

    /// Create validation error using CommonError
    pub fn validation<F: Into<String>, M: Into<String>>(field: F, message: M) -> Self {
        Self::Common(CommonError::validation(field, message))
    }

    /// Create internal error using CommonError
    pub fn internal<M: Into<String>>(message: M) -> Self {
        Self::Common(CommonError::internal(message))
    }
}

/// Convert to CommonError automatically for interop
impl From<RiskServiceError> for CommonError {
    fn from(err: RiskServiceError) -> Self {
        err.to_common_error()
    }
}

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

    #[test]
    fn test_risk_service_error_categorization() {
        let position_error = RiskServiceError::position_limit_exceeded("AAPL", 1000.0, 500.0);
        assert_eq!(position_error.category(), ErrorCategory::Risk);
        assert_eq!(position_error.error_code(), "RISK_POSITION_LIMIT_EXCEEDED");
        assert_eq!(position_error.severity(), ErrorSeverity::Error);
        assert!(!position_error.is_retryable()); // Position limits should not be retried

        let market_data_error = RiskServiceError::market_data_unavailable("TSLA");
        assert_eq!(market_data_error.category(), ErrorCategory::MarketData);
        assert!(market_data_error.is_retryable());
    }

    #[test]
    fn test_critical_risk_errors() {
        let kill_switch_error = RiskServiceError::kill_switch_active("GLOBAL", "Emergency stop");
        assert_eq!(kill_switch_error.severity(), ErrorSeverity::Critical);
        assert!(!kill_switch_error.is_retryable());
        assert!(kill_switch_error.should_trigger_kill_switch());

        let compliance_error = RiskServiceError::compliance_violation("MiFID_II", "Best execution failed");
        assert_eq!(compliance_error.severity(), ErrorSeverity::Critical);
        assert!(compliance_error.should_trigger_kill_switch());
    }

    #[test]
    fn test_retry_strategies() {
        let var_error = RiskServiceError::var_limit_exceeded(1000.0, 500.0, 95.0);
        assert!(!var_error.is_retryable());
        assert_eq!(var_error.retry_strategy(), RetryStrategy::NoRetry);

        let data_error = RiskServiceError::market_data_unavailable("SPY");
        assert!(data_error.is_retryable());
        match data_error.retry_strategy() {
            RetryStrategy::Exponential { base_delay_ms, max_delay_ms } => {
                assert_eq!(base_delay_ms, 1000);
                assert_eq!(max_delay_ms, 10000);
            }
            _ => assert!(false, "Expected exponential backoff for market data errors"),
        }
    }

    #[test]
    fn test_circuit_breaker_triggers() {
        let position_error = RiskServiceError::position_limit_exceeded("BTC", 10.0, 5.0);
        assert!(position_error.should_trigger_circuit_breaker());

        let var_error = RiskServiceError::var_limit_exceeded(2000.0, 1000.0, 99.0);
        assert!(var_error.should_trigger_circuit_breaker());

        let data_error = RiskServiceError::market_data_unavailable("ETH");
        assert!(!data_error.should_trigger_circuit_breaker());
    }

    #[test]
    fn test_common_error_integration() {
        let config_error = RiskServiceError::configuration("Missing risk parameters");
        let common_error: CommonError = config_error.into();
        
        assert_eq!(common_error.category(), ErrorCategory::Configuration);
        assert_eq!(common_error.severity(), ErrorSeverity::Critical);
        assert!(!common_error.is_retryable());
    }

    #[test]
    fn test_error_conversion_chain() {
        let io_error = std::io::Error::new(std::io::ErrorKind::ConnectionRefused, "Connection refused");
        let risk_error: RiskServiceError = io_error.into();
        let common_error: CommonError = risk_error.into();
        
        assert_eq!(common_error.category(), ErrorCategory::Network);
        assert_eq!(common_error.severity(), ErrorSeverity::Warn);
    }

    #[test]
    fn test_stress_test_error() {
        let stress_error = RiskServiceError::stress_test_failed("BLACK_MONDAY", "Portfolio loss exceeds threshold");
        assert_eq!(stress_error.category(), ErrorCategory::Risk);
        assert_eq!(stress_error.severity(), ErrorSeverity::Warn);
        assert!(stress_error.is_retryable());
        
        match stress_error.retry_strategy() {
            RetryStrategy::Linear { base_delay_ms } => assert_eq!(base_delay_ms, 2000),
            _ => assert!(false, "Expected linear backoff for stress test errors"),
        }
    }
}