eulumdat-goniosim 0.7.0

//! Validation tests: compare traced results against analytical solutions.
#![allow(clippy::needless_range_loop)]

use eulumdat_goniosim::*;

/// Isotropic point source in free space must produce constant candela everywhere.
///
/// Analytical: I = flux / (4 * pi) ≈ 79.58 cd for 1000 lm.
#[test]
fn isotropic_free_space() {
    let scene = bare_isotropic(1000.0);
    let config = TracerConfig {
        num_photons: 500_000,
        detector_c_resolution: 10.0,
        detector_g_resolution: 5.0,
        seed: 42,
        ..TracerConfig::default()
    };

    let result = Tracer::trace(&scene, &config);

    // All photons should be detected (no geometry to absorb them)
    assert_eq!(
        result.stats.photons_detected, result.stats.photons_traced,
        "All photons should escape in free space"
    );

    // Energy conservation
    let energy_ratio = result.stats.total_energy_detected / result.stats.total_energy_emitted;
    assert!(
        (energy_ratio - 1.0).abs() < 0.001,
        "Energy conservation violated: ratio = {energy_ratio}"
    );

    // Check candela values: should be approximately constant
    let candela = result.detector.to_candela(1000.0);
    let expected_cd = 1000.0 / (4.0 * std::f64::consts::PI); // ~79.58

    let mut sum_sq_error = 0.0;
    let mut count = 0;

    for ci in 0..candela.len() {
        for gi in 1..candela[ci].len() - 1 {
            // Skip polar bins (gamma=0, gamma=180) which have low counts
            let cd = candela[ci][gi];
            if cd > 0.0 {
                let err = (cd - expected_cd) / expected_cd;
                sum_sq_error += err * err;
                count += 1;
            }
        }
    }

    let rms_error = (sum_sq_error / count as f64).sqrt();
    assert!(
        rms_error < 0.10,
        "RMS error {rms_error:.4} exceeds 10% for isotropic source at 500k photons"
    );
}

/// Lambertian emitter in free space: I(gamma) = I_max * cos(gamma).
#[test]
fn lambertian_free_space() {
    let scene = bare_lambertian(1000.0);
    let config = TracerConfig {
        num_photons: 500_000,
        detector_c_resolution: 10.0,
        detector_g_resolution: 5.0,
        seed: 123,
        ..TracerConfig::default()
    };

    let result = Tracer::trace(&scene, &config);

    // Only downward hemisphere should have photons
    assert!(
        result.stats.photons_detected > 0,
        "Should detect some photons"
    );

    let candela = result.detector.to_candela(1000.0);

    // Find the peak at gamma=0 (nadir)
    let mut max_cd = 0.0f64;
    for ci in 0..candela.len() {
        max_cd = max_cd.max(candela[ci][0]);
    }

    // Check cosine falloff at gamma=60 (cos(60)=0.5) — should be ~50% of peak
    // Average over all C-planes at gamma=60deg (index = 60/5 = 12)
    let gi_60 = 12; // 60 degrees / 5 deg resolution
    let mut sum_60 = 0.0;
    let mut n_60 = 0;
    for ci in 0..candela.len() {
        if candela[ci][gi_60] > 0.0 {
            sum_60 += candela[ci][gi_60];
            n_60 += 1;
        }
    }
    if n_60 > 0 && max_cd > 0.0 {
        let ratio_60 = (sum_60 / n_60 as f64) / max_cd;
        let expected_ratio = 60.0f64.to_radians().cos(); // 0.5
        let error = (ratio_60 - expected_ratio).abs();
        // Tolerance is loose because `trace_parallel` seeds RNGs as seed+thread_idx,
        // so the photon distribution (and thus variance at gamma=60°) depends on
        // rayon's thread count. High-core-count Macs converge tighter than 2-core
        // CI runners. TODO: switch to per-photon-indexed seeding for thread-count
        // independence, then tighten this back to 0.15.
        assert!(
            error < 0.25,
            "Lambertian at 60deg: ratio={ratio_60:.3}, expected={expected_ratio:.3}, error={error:.3}"
        );
    }
}

/// Export round-trip: trace → detect → export → parse → compare.
#[test]
fn export_roundtrip() {
    let scene = bare_isotropic(1000.0);
    let config = TracerConfig {
        num_photons: 100_000,
        detector_c_resolution: 15.0,
        detector_g_resolution: 5.0,
        seed: 99,
        ..TracerConfig::default()
    };

    let result = Tracer::trace(&scene, &config);

    let export_config = ExportConfig {
        c_step_deg: 15.0,
        g_step_deg: 5.0,
        luminaire_name: "Test Isotropic".to_string(),
        ..ExportConfig::default()
    };

    let ldt = detector_to_eulumdat(&result.detector, 1000.0, &export_config);

    // Verify basic structure
    assert_eq!(ldt.luminaire_name, "Test Isotropic");
    assert!(!ldt.c_angles.is_empty());
    assert!(!ldt.g_angles.is_empty());
    assert!(!ldt.intensities.is_empty());

    // Should produce valid LDT
    let ldt_string = ldt.to_ldt();
    assert!(!ldt_string.is_empty());

    // Re-parse the exported LDT
    let parsed = eulumdat::Eulumdat::parse(&ldt_string).expect("Should parse exported LDT");
    assert_eq!(parsed.luminaire_name, "Test Isotropic");
    assert_eq!(parsed.c_angles.len(), ldt.c_angles.len());
    assert_eq!(parsed.g_angles.len(), ldt.g_angles.len());
}

/// Scene builder creates correct geometry.
#[test]
fn scene_builder_led_housing_cover() {
    let scene = SceneBuilder::new()
        .source(Source::Led {
            position: nalgebra::Point3::origin(),
            direction: nalgebra::Unit::new_unchecked(nalgebra::Vector3::new(0.0, 0.0, -1.0)),
            half_angle_deg: 60.0,
            flux_lm: 1000.0,
        })
        .reflector(
            catalog::anodized_aluminum(),
            ReflectorPlacement {
                distance_mm: 25.0,
                length_mm: 50.0,
                side: ReflectorSide::Surround,
            },
        )
        .cover(
            catalog::opal_pmma_3mm(),
            CoverPlacement {
                distance_mm: 40.0,
                width_mm: 60.0,
                height_mm: 60.0,
            },
        )
        .build();

    // Should have LED source, housing cylinder, cover sheet
    assert_eq!(scene.sources.len(), 1);
    assert_eq!(scene.objects.len(), 2);

    // Quick trace to verify it doesn't crash
    let config = TracerConfig {
        num_photons: 10_000,
        seed: 7,
        ..TracerConfig::default()
    };
    let result = Tracer::trace(&scene, &config);
    assert!(result.stats.photons_traced == 10_000);
    assert!(
        result.stats.photons_detected > 0,
        "Some photons should escape"
    );
}

/// MaterialParams catalog round-trip: all materials should produce valid Material variants.
#[test]
fn catalog_all_materials_convert() {
    let catalog = material_catalog();
    assert!(catalog.len() >= 12, "Should have at least 12 materials");

    for mat in &catalog {
        let _internal = mat.to_material();
        // Just verify it doesn't panic
    }
}