linreg-core 0.8.1

// ============================================================================
// Jarque-Bera Test Validation
// ============================================================================
//
// Comprehensive validation of the Jarque-Bera normality test
// against R and Python reference implementations.
//
// The Jarque-Bera test checks if residuals are normally distributed
// by examining skewness and kurtosis.

use crate::common::{
    load_dataset, load_python_diagnostic_result, load_r_diagnostic_result, ALL_DATASETS,
    STAT_TOLERANCE,
};

use linreg_core::diagnostics;

#[test]
fn validate_jarque_bera_all_datasets() {
    println!("\n");
    println!("╔══════════════════════════════════════════════════════════════════════╗");
    println!("║  JARQUE-BERA TEST - COMPREHENSIVE MULTI-DATASET VALIDATION         ║");
    println!("╚══════════════════════════════════════════════════════════════════════╝");
    println!();

    let current_dir = std::env::current_dir().expect("Failed to get current dir");
    let datasets_dir = current_dir.join("verification/datasets/csv");
    let r_results_dir = current_dir.join("verification/results/r");
    let python_results_dir = current_dir.join("verification/results/python");

    let mut total_tests = 0;
    let mut passed_r = 0;
    let mut passed_python = 0;
    let mut failed_tests = Vec::new();

    for dataset_name in ALL_DATASETS {
        let csv_path = datasets_dir.join(format!("{}.csv", dataset_name));
        if !csv_path.exists() {
            println!("    Skipping {}: CSV file not found", dataset_name);
            continue;
        }

        println!("  ┌─────────────────────────────────────────────────────────────────┐");
        println!("  │  Dataset: {:<52}│", dataset_name);
        println!("  └─────────────────────────────────────────────────────────────────┘");

        let dataset = match load_dataset(&csv_path) {
            Ok(d) => d,
            Err(e) => {
                println!("     Failed to load dataset: {}", e);
                failed_tests.push((dataset_name.to_string(), "Load failed".to_string()));
                continue;
            },
        };

        println!(
            "    Loaded: n = {}, predictors = {}",
            dataset.y.len(),
            dataset.x_vars.len()
        );

        // Run Jarque-Bera test
        let rust_result =
            match diagnostics::jarque_bera_test(&dataset.y, &dataset.x_vars) {
                Ok(r) => r,
                Err(e) => {
                    println!("     Jarque-Bera test failed: {}", e);
                    failed_tests.push((
                        dataset_name.to_string(),
                        format!("JB test error: {}", e),
                    ));
                    continue;
                },
            };

        println!(
            "    Rust: X-squared = {:.6}, p = {:.6}",
            rust_result.statistic, rust_result.p_value
        );

        // Validate against R
        let r_result_path = r_results_dir.join(format!("{}_jarque_bera.json", dataset_name));
        if let Some(r_ref) = load_r_diagnostic_result(&r_result_path) {
            total_tests += 1;

            let r_stat = r_ref.statistic.get(0).copied().unwrap_or(0.0);
            let r_pval = r_ref.p_value.get(0).copied().unwrap_or(1.0);

            let stat_diff = (rust_result.statistic - r_stat).abs();
            let pval_diff = (rust_result.p_value - r_pval).abs();

            println!("    R:        X-squared = {:.6}, p = {:.6}", r_stat, r_pval);
            println!(
                "              Diff: stat = {:.2e}, p = {:.2e}",
                stat_diff, pval_diff
            );

            if stat_diff <= STAT_TOLERANCE && pval_diff <= STAT_TOLERANCE {
                println!("     R validation: PASS");
                passed_r += 1;
            } else {
                println!("     R validation: FAIL");
                failed_tests.push((
                    dataset_name.to_string(),
                    format!("R mismatch: stat diff={:.2e}", stat_diff),
                ));
            }
        } else {
            println!(
                "      R reference file not found: {}",
                r_result_path.display()
            );
            failed_tests.push((
                dataset_name.to_string(),
                "R reference file missing".to_string(),
            ));
        }

        // Validate against Python
        let python_result_path =
            python_results_dir.join(format!("{}_jarque_bera.json", dataset_name));
        if let Some(py_ref) = load_python_diagnostic_result(&python_result_path) {
            total_tests += 1;

            let py_stat = py_ref.statistic;
            let py_pval = py_ref.p_value;

            let stat_diff = (rust_result.statistic - py_stat).abs();
            let pval_diff = (rust_result.p_value - py_pval).abs();

            println!("    Python:   X-squared = {:.6}, p = {:.6}", py_stat, py_pval);
            println!(
                "              Diff: stat = {:.2e}, p = {:.2e}",
                stat_diff, pval_diff
            );

            if stat_diff <= STAT_TOLERANCE && pval_diff <= STAT_TOLERANCE {
                println!("     Python validation: PASS");
                passed_python += 1;
            } else {
                println!("     Python validation: FAIL");
                failed_tests.push((
                    dataset_name.to_string(),
                    format!("Python mismatch: stat diff={:.2e}", stat_diff),
                ));
            }
        } else {
            println!(
                "      Python reference file not found: {}",
                python_result_path.display()
            );
            failed_tests.push((
                dataset_name.to_string(),
                "Python reference file missing".to_string(),
            ));
        }

        println!();
    }

    // Summary
    println!("╔══════════════════════════════════════════════════════════════════════╗");
    println!("║  JARQUE-BERA VALIDATION SUMMARY                                    ║");
    println!("╠══════════════════════════════════════════════════════════════════════╣");
    println!("║  Total tests run:       {:>40}║", total_tests);
    println!("║  R validations passed:   {:>40}║", passed_r);
    println!("║  Python validations passed: {:>39}║", passed_python);
    println!("║  Failed tests:          {:>40}║", failed_tests.len());
    println!("╚══════════════════════════════════════════════════════════════════════╝");

    if !failed_tests.is_empty() {
        println!("\n  Failed tests:");
        for (dataset, reason) in &failed_tests {
            println!("    - {}: {}", dataset, reason);
        }
    }

    assert!(total_tests > 0, "No Jarque-Bera validation tests were run.");
    let pass_rate = (passed_r + passed_python) as f64 / total_tests as f64;
    assert!(
        pass_rate >= 0.9,
        "Jarque-Bera validation pass rate ({:.1}%) is below 90%.",
        pass_rate * 100.0
    );

    println!();
    println!(" Jarque-Bera comprehensive validation passed!");
}