//! Value at Risk (`VaR`) calculation methods
//!
//! Implements Historical, Parametric, and Monte Carlo `VaR` methods.

use crate::error::{Result, RiskAnalyzerError};
use rand::SeedableRng;
use rand_distr::{Distribution, Normal};

/// Calculate historical `VaR` from a sample of returns
///
/// # Arguments
/// * `returns` - Historical returns (must be non-empty)
/// * `confidence` - Confidence level (e.g., 0.95 for 95%)
///
/// # Returns
/// `VaR` as a positive value (represents potential loss)
pub fn historical_var(returns: &[f64], confidence: f64) -> Result<f64> {
    if returns.is_empty() {
        return Err(RiskAnalyzerError::InsufficientData(
            "Returns array is empty".to_string(),
        ));
    }

    if !(0.0..=1.0).contains(&confidence) {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Confidence level must be between 0 and 1, got {confidence}"
        )));
    }

    let mut sorted = returns.to_vec();
    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));

    let index = ((1.0 - confidence) * sorted.len() as f64).floor() as usize;
    let index = index.min(sorted.len() - 1);

    Ok(-sorted[index])
}

/// Calculate parametric `VaR` assuming normal distribution
///
/// # Arguments
/// * `mean` - Mean return
/// * `std_dev` - Standard deviation of returns
/// * `confidence` - Confidence level (e.g., 0.95 for 95%)
///
/// # Returns
/// `VaR` as a positive value (represents potential loss)
pub fn parametric_var(mean: f64, std_dev: f64, confidence: f64) -> Result<f64> {
    if std_dev < 0.0 {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Standard deviation must be non-negative, got {std_dev}"
        )));
    }

    if !(0.0..=1.0).contains(&confidence) {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Confidence level must be between 0 and 1, got {confidence}"
        )));
    }

    let z_score = normal_quantile(1.0 - confidence)?;
    Ok(-(mean + z_score * std_dev))
}

/// Calculate Monte Carlo `VaR` by simulating future returns
///
/// # Arguments
/// * `mean` - Mean return per period
/// * `std_dev` - Standard deviation per period
/// * `horizon` - Time horizon in periods
/// * `num_simulations` - Number of Monte Carlo paths
/// * `confidence` - Confidence level (e.g., 0.95 for 95%)
///
/// # Returns
/// `VaR` as a positive value (represents potential loss)
pub fn monte_carlo_var(
    mean: f64,
    std_dev: f64,
    horizon: u32,
    num_simulations: u32,
    confidence: f64,
) -> Result<f64> {
    if num_simulations == 0 {
        return Err(RiskAnalyzerError::InvalidConfig(
            "Number of simulations must be positive".to_string(),
        ));
    }

    if horizon == 0 {
        return Err(RiskAnalyzerError::InvalidConfig(
            "Time horizon must be positive".to_string(),
        ));
    }

    if std_dev < 0.0 {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Standard deviation must be non-negative, got {std_dev}"
        )));
    }

    if !(0.0..=1.0).contains(&confidence) {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Confidence level must be between 0 and 1, got {confidence}"
        )));
    }

    let mut rng = rand::rngs::StdRng::seed_from_u64(42);
    let normal = Normal::new(mean, std_dev).map_err(|e| {
        RiskAnalyzerError::CalculationError(format!("Failed to create normal distribution: {e}"))
    })?;

    let mut final_returns = Vec::with_capacity(num_simulations as usize);

    for _ in 0..num_simulations {
        let mut cumulative_return = 0.0;
        for _ in 0..horizon {
            cumulative_return += normal.sample(&mut rng);
        }
        final_returns.push(cumulative_return);
    }

    historical_var(&final_returns, confidence)
}

/// Calculate the quantile of a standard normal distribution
///
/// Uses Beasley-Springer-Moro algorithm for inverse normal CDF
fn normal_quantile(p: f64) -> Result<f64> {
    if !(0.0..=1.0).contains(&p) {
        return Err(RiskAnalyzerError::InvalidConfig(format!(
            "Probability must be between 0 and 1, got {p}"
        )));
    }

    if p == 0.0 {
        return Ok(f64::NEG_INFINITY);
    }
    if p == 1.0 {
        return Ok(f64::INFINITY);
    }

    let a = [
        -3.969_683_028_665_376e1,
        2.209_460_984_245_205e2,
        -2.759_285_104_469_687e2,
        1.383_577_518_672_69e2,
        -3.066_479_806_614_716e1,
        2.506_628_277_459_239,
    ];

    let b = [
        -5.447_609_879_822_406e1,
        1.615_858_368_580_409e2,
        -1.556_989_798_598_866e2,
        6.680_131_188_771_972e1,
        -1.328_068_155_288_572e1,
    ];

    let c = [
        -7.784_894_002_430_293e-3,
        -3.223_964_580_411_365e-1,
        -2.400_758_277_161_838,
        -2.549_732_539_343_734,
        4.374_664_141_464_968,
        2.938_163_982_698_783,
    ];

    let d = [
        7.784_695_709_041_462e-3,
        3.224_671_290_700_398e-1,
        2.445_134_137_142_996,
        3.754_408_661_907_416,
    ];

    let p_low = 0.02425;
    let p_high = 1.0 - p_low;

    let q = if p < p_low {
        let q = (-2.0 * p.ln()).sqrt();
        (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
            / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0)
    } else if p <= p_high {
        let q = p - 0.5;
        let r = q * q;
        (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q
            / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0)
    } else {
        let q = (-2.0 * (1.0 - p).ln()).sqrt();
        -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
            / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0)
    };

    Ok(q)
}

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

    #[test]
    fn test_historical_var_empty_returns() {
        let result = historical_var(&[], 0.95);
        assert!(result.is_err());
        assert!(matches!(
            result.unwrap_err(),
            RiskAnalyzerError::InsufficientData(_)
        ));
    }

    #[test]
    fn test_historical_var_invalid_confidence() {
        let returns = vec![0.01, -0.02, 0.03];
        let result = historical_var(&returns, 1.5);
        assert!(result.is_err());
    }

    #[test]
    fn test_historical_var_95_confidence() {
        let returns = vec![
            0.01, -0.02, 0.03, -0.01, 0.02, -0.03, 0.015, -0.025, 0.005, -0.015,
        ];
        let var = historical_var(&returns, 0.95).unwrap();
        assert!(var > 0.0);
        assert!(var <= 0.03);
    }

    #[test]
    fn test_historical_var_99_confidence() {
        let returns = vec![
            0.01, -0.02, 0.03, -0.01, 0.02, -0.03, 0.015, -0.025, 0.005, -0.015, -0.04, 0.025,
            -0.035, 0.018, -0.028, 0.012, -0.022, 0.008, -0.018, 0.002,
        ];
        let var = historical_var(&returns, 0.99).unwrap();
        assert!(var > 0.0);
        assert!(var >= 0.035);
    }

    #[test]
    fn test_parametric_var_negative_std() {
        let result = parametric_var(0.01, -0.1, 0.95);
        assert!(result.is_err());
    }

    #[test]
    fn test_parametric_var_invalid_confidence() {
        let result = parametric_var(0.01, 0.1, 2.0);
        assert!(result.is_err());
    }

    #[test]
    fn test_parametric_var_positive_mean() {
        let var = parametric_var(0.001, 0.02, 0.95).unwrap();
        assert!(var > 0.0);
    }

    #[test]
    fn test_parametric_var_negative_mean() {
        let var = parametric_var(-0.001, 0.02, 0.95).unwrap();
        assert!(var > 0.0);
    }

    #[test]
    fn test_parametric_var_99_vs_95() {
        let mean = 0.001;
        let std = 0.02;
        let var_95 = parametric_var(mean, std, 0.95).unwrap();
        let var_99 = parametric_var(mean, std, 0.99).unwrap();
        assert!(var_99 > var_95);
    }

    #[test]
    fn test_monte_carlo_var_zero_simulations() {
        let result = monte_carlo_var(0.001, 0.02, 1, 0, 0.95);
        assert!(result.is_err());
    }

    #[test]
    fn test_monte_carlo_var_zero_horizon() {
        let result = monte_carlo_var(0.001, 0.02, 0, 1000, 0.95);
        assert!(result.is_err());
    }

    #[test]
    fn test_monte_carlo_var_negative_std() {
        let result = monte_carlo_var(0.001, -0.02, 1, 1000, 0.95);
        assert!(result.is_err());
    }

    #[test]
    fn test_monte_carlo_var_basic() {
        let var = monte_carlo_var(0.001, 0.02, 1, 10_000, 0.95).unwrap();
        assert!(var > 0.0);
        assert!(var < 0.1);
    }

    #[test]
    fn test_monte_carlo_var_horizon_scaling() {
        let var_1 = monte_carlo_var(0.001, 0.02, 1, 10_000, 0.95).unwrap();
        let var_10 = monte_carlo_var(0.001, 0.02, 10, 10_000, 0.95).unwrap();
        assert!(var_10 > var_1);
    }

    #[test]
    fn test_monte_carlo_var_confidence_scaling() {
        let var_95 = monte_carlo_var(0.001, 0.02, 1, 10_000, 0.95).unwrap();
        let var_99 = monte_carlo_var(0.001, 0.02, 1, 10_000, 0.99).unwrap();
        assert!(var_99 > var_95);
    }

    #[test]
    fn test_normal_quantile_invalid() {
        let result = normal_quantile(1.5);
        assert!(result.is_err());
    }

    #[test]
    fn test_normal_quantile_0_5() {
        let q = normal_quantile(0.5).unwrap();
        assert!((q.abs()) < 1e-10);
    }

    #[test]
    fn test_normal_quantile_0_05() {
        let q = normal_quantile(0.05).unwrap();
        assert!((q - (-1.6449)).abs() < 0.01);
    }

    #[test]
    fn test_normal_quantile_0_95() {
        let q = normal_quantile(0.95).unwrap();
        assert!((q - 1.6449).abs() < 0.01);
    }

    #[test]
    fn test_normal_quantile_0_01() {
        let q = normal_quantile(0.01).unwrap();
        assert!((q - (-2.3263)).abs() < 0.01);
    }

    #[test]
    fn test_normal_quantile_0_99() {
        let q = normal_quantile(0.99).unwrap();
        assert!((q - 2.3263).abs() < 0.01);
    }
}