suns 0.0.4

use suns::rendering::materials::StellarMaterial;
use suns::rendering::shaders::{
    ShaderEndpoint, UniformValue, corona_intensity_at_radius, limb_darkening_factor,
};

// ── materials ──

#[test]
fn photosphere_temp_5778() {
    let m = StellarMaterial::photosphere();
    assert!((m.temperature_k - 5778.0).abs() < 1.0);
    assert_eq!(m.opacity, 1.0);
}

#[test]
fn chromosphere_hotter_than_photosphere() {
    let p = StellarMaterial::photosphere();
    let c = StellarMaterial::chromosphere();
    assert!(c.temperature_k > p.temperature_k);
}

#[test]
fn corona_much_hotter() {
    let m = StellarMaterial::corona();
    assert!(m.temperature_k >= 1_000_000.0);
    assert!(m.opacity < 0.01);
}

#[test]
fn sunspot_cooler_than_photosphere() {
    let s = StellarMaterial::sunspot();
    let p = StellarMaterial::photosphere();
    assert!(s.temperature_k < p.temperature_k);
}

#[test]
fn prominence_emission() {
    let m = StellarMaterial::prominence();
    assert!(m.emission_intensity > 1.0);
    assert!(m.opacity > 0.1 && m.opacity < 0.5);
}

#[test]
fn planck_peak_photosphere_visible() {
    let m = StellarMaterial::photosphere();
    let peak = m.planck_peak_wavelength_nm();
    assert!(peak > 400.0 && peak < 600.0);
}

#[test]
fn planck_peak_corona_xray() {
    let m = StellarMaterial::corona();
    let peak = m.planck_peak_wavelength_nm();
    assert!(peak < 10.0);
}

#[test]
fn luminous_exitance_photosphere() {
    let m = StellarMaterial::photosphere();
    let lum = m.luminous_exitance();
    assert!(lum > 6e7 && lum < 7e7);
}

#[test]
fn luminous_exitance_increases_with_temp() {
    let p = StellarMaterial::photosphere();
    let c = StellarMaterial::corona();
    assert!(c.luminous_exitance() > p.luminous_exitance());
}

// ── shaders ──

#[test]
fn photosphere_shader_name() {
    let s = ShaderEndpoint::photosphere();
    assert_eq!(s.name, "sun_photosphere_pbr");
    assert!(s.uniforms.len() >= 6);
}

#[test]
fn photosphere_shader_solar_radius() {
    let s = ShaderEndpoint::photosphere();
    let r = s
        .uniforms
        .iter()
        .find(|u| u.name == "u_solar_radius")
        .unwrap();
    match r.value {
        UniformValue::Float(v) => assert!(v > 6e8),
        _ => panic!("expected Float"),
    }
}

#[test]
fn photosphere_shader_temp() {
    let s = ShaderEndpoint::photosphere();
    let t = s
        .uniforms
        .iter()
        .find(|u| u.name == "u_effective_temp_k")
        .unwrap();
    match t.value {
        UniformValue::Float(v) => assert!((v - 5778.0).abs() < 1.0),
        _ => panic!("expected Float"),
    }
}

#[test]
fn corona_shader_name() {
    let s = ShaderEndpoint::corona();
    assert_eq!(s.name, "sun_corona");
    assert!(s.uniforms.len() >= 4);
}

#[test]
fn corona_shader_falloff() {
    let s = ShaderEndpoint::corona();
    let f = s
        .uniforms
        .iter()
        .find(|u| u.name == "u_corona_falloff_exponent")
        .unwrap();
    match f.value {
        UniformValue::Float(v) => assert!((v - 2.5).abs() < 0.01),
        _ => panic!("expected Float"),
    }
}

#[test]
fn active_region_shader_name() {
    let s = ShaderEndpoint::active_region();
    assert_eq!(s.name, "sun_active_region");
    assert!(s.uniforms.len() >= 5);
}

#[test]
fn active_region_strong_magnetic_field() {
    let s = ShaderEndpoint::active_region();
    let b = s
        .uniforms
        .iter()
        .find(|u| u.name == "u_magnetic_field_intensity")
        .unwrap();
    match b.value {
        UniformValue::Float(v) => assert!(v > 0.1),
        _ => panic!("expected Float"),
    }
}

#[test]
fn chromosphere_shader_name() {
    let s = ShaderEndpoint::chromosphere();
    assert_eq!(s.name, "sun_chromosphere");
    assert!(s.uniforms.len() >= 4);
}

#[test]
fn chromosphere_shader_color() {
    let s = ShaderEndpoint::chromosphere();
    let c = s
        .uniforms
        .iter()
        .find(|u| u.name == "u_chromosphere_color")
        .unwrap();
    match c.value {
        UniformValue::Vec3(rgb) => {
            assert!(rgb[0] > rgb[1]);
            assert!(rgb[0] > rgb[2]);
        }
        _ => panic!("expected Vec3"),
    }
}

// ── physics functions ──

#[test]
fn limb_darkening_center() {
    let factor = limb_darkening_factor(0.6, 1.0);
    assert!((factor - 1.0).abs() < 1e-6);
}

#[test]
fn limb_darkening_edge() {
    let factor = limb_darkening_factor(0.6, 0.0);
    assert!((factor - 0.4).abs() < 1e-6);
}

#[test]
fn limb_darkening_monotonic() {
    let f1 = limb_darkening_factor(0.6, 0.3);
    let f2 = limb_darkening_factor(0.6, 0.7);
    assert!(f2 > f1);
}

#[test]
fn corona_intensity_at_surface() {
    let intensity = corona_intensity_at_radius(2.5, 1.0);
    assert!((intensity - 1.0).abs() < 1e-6);
}

#[test]
fn corona_intensity_decreases() {
    let i1 = corona_intensity_at_radius(2.5, 2.0);
    let i2 = corona_intensity_at_radius(2.5, 5.0);
    assert!(i1 > i2);
    assert!(i2 > 0.0);
}

#[test]
fn corona_intensity_inside_sun() {
    let intensity = corona_intensity_at_radius(2.5, 0.5);
    assert!((intensity - 1.0).abs() < 1e-6);
}