use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Severity {
    Critical,
    Warning,
    Info,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ParamDiagnostic {
    pub severity: Severity,
    pub message: String,
    pub suggested_fix: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ValidationResult {
    pub n: usize,
    pub q: u64,
    pub beta_or_sigma: f64,
    pub is_cbd: bool,

    pub noise_budget_max: f64,
    pub noise_budget_rms: f64,
    pub decryption_budget: f64,
    pub failure_prob: f64,
    pub expected_failures_in_500: f64,

    pub passes: bool,
    pub diagnostics: Vec<ParamDiagnostic>,

    pub suggested_beta: f64,
    pub suggested_q: u64,
}

pub struct ParamValidator;

impl ParamValidator {
    pub fn validate_lwe(n: usize, q: u64, beta: f64) -> ValidationResult {
        Self::validate_inner(n, q, beta, false)
    }

    pub fn validate_kyber(n: usize, q: u64, eta: usize) -> ValidationResult {
        let mut r = Self::validate_inner(n, q, eta as f64, true);
        r.beta_or_sigma = eta as f64;
        r
    }

    pub fn validate_gaussian(n: usize, q: u64, sigma: f64) -> ValidationResult {
        Self::validate_inner(n, q, sigma, false)
    }

    fn validate_inner(n: usize, q: u64, noise_param: f64, is_cbd: bool) -> ValidationResult {
        let q_f = q as f64;
        let n_f = n as f64;

        let std_per_coeff = if is_cbd {
            (noise_param / 2.0).sqrt()
        } else {
            noise_param
        };

        let beta_max = if is_cbd { noise_param } else { 3.0 * std_per_coeff };

        let noise_budget_rms = std_per_coeff * (3.0 * n_f).sqrt() * beta_max;
        let noise_budget_max = beta_max * beta_max * n_f * 3.0; 
        let decryption_budget = q_f / 4.0;

        let total_std = std_per_coeff * beta_max * (3.0 * n_f).sqrt();
        let z = decryption_budget / total_std.max(1e-10);
        let failure_prob = 2.0 * gaussian_q_function(z);

        let expected_failures_in_500 = failure_prob * 500.0;
        let passes = noise_budget_rms < decryption_budget * 0.8;

        let mut diagnostics = Vec::new();

        if noise_budget_max >= decryption_budget && expected_failures_in_500 > 1e-3 {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Critical,
                message: format!(
                    "WORST-CASE noise ({:.1}) EXCEEDS expected limit and probability of failure is high. Decryption WILL fail for some inputs.",
                    noise_budget_max
                ),
                suggested_fix: Some(format!(
                    "Either: (a) reduce β to ≤{:.1}, or (b) increase q to ≥{}",
                    (decryption_budget / (n_f * 3.0)).sqrt(),
                    (noise_budget_max * 4.0).ceil() as u64
                )),
            });
        } else if noise_budget_max >= decryption_budget {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Info,
                message: format!(
                    "WORST-CASE noise bound ({:.1}) exceeds budget ({:.1}), but failure probability is low. Typical for practical RLWE.",
                    noise_budget_max, decryption_budget
                ),
                suggested_fix: None,
            });
        } else if noise_budget_max > decryption_budget * 0.85 {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Warning,
                message: format!(
                    "WORST-CASE noise ({:.1}) is dangerously close to budget ({:.1}). Rare failures may occur.",
                    noise_budget_max, decryption_budget
                ),
                suggested_fix: Some("Increase q or decrease noise to increase margin".to_string()),
            });
        } else if noise_budget_rms >= decryption_budget * 0.5 {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Warning,
                message: format!(
                    "RMS noise ({:.1}) is {:.0}% of budget ({:.1}). Failure rate ≈{:.2}%. Marginal parameters.",
                    noise_budget_rms,
                    100.0 * noise_budget_rms / decryption_budget,
                    decryption_budget,
                    failure_prob * 100.0
                ),
                suggested_fix: Some("Increase q by 2x or decrease β by √2".to_string()),
            });
        } else {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Info,
                message: format!(
                    "Noise budget OK: RMS noise {:.1} is {:.0}% of q/4={:.1}.",
                    noise_budget_rms,
                    100.0 * noise_budget_rms / decryption_budget,
                    decryption_budget
                ),
                suggested_fix: None,
            });
        }

        let estimated_security = estimate_security_bits(n, q, std_per_coeff);
        if estimated_security < 80.0 {
            diagnostics.push(ParamDiagnostic {
                severity: Severity::Critical,
                message: format!(
                    "Parameters provide only ~{:.0} bits of security (need ≥128).",
                    estimated_security
                ),
                suggested_fix: Some("Use n≥256 and q≥3329 for any security claim".to_string()),
            });
        }

        let suggested_beta = (decryption_budget / (n_f * 3.0)).sqrt() * 0.5;
        let suggested_q = (noise_budget_max * 8.0).ceil() as u64;

        ValidationResult {
            n,
            q,
            beta_or_sigma: noise_param,
            is_cbd,
            noise_budget_max,
            noise_budget_rms,
            decryption_budget,
            failure_prob,
            expected_failures_in_500,
            passes,
            diagnostics,
            suggested_beta,
            suggested_q,
        }
    }
}

fn gaussian_q_function(z: f64) -> f64 {
    if z > 10.0 { return 0.0; }
    if z < 0.0  { return 1.0; }
    let t = 1.0 / (1.0 + 0.2316419 * z);
    let poly = t * (0.319381530
        + t * (-0.356563782
        + t * (1.781477937
        + t * (-1.821255978
        + t * 1.330274429))));
    let phi = (-z * z / 2.0).exp() / (2.0 * std::f64::consts::PI).sqrt();
    phi * poly
}

fn estimate_security_bits(n: usize, q: u64, sigma: f64) -> f64 {
    let n_f = n as f64;
    let q_f = q as f64;
    let alpha = sigma / q_f;
    if alpha <= 0.0 { return 0.0; }
    0.265 * n_f * (-alpha.log2())
}