astro-math 0.2.1

use crate::moon::*;
use chrono::{TimeZone, Utc};
use crate::julian_date;

#[test]
fn test_moon_position_range() {
    // Test over several dates to ensure values are in expected ranges
    let dates = [
        Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap(),
        Utc.with_ymd_and_hms(2024, 4, 15, 12, 0, 0).unwrap(),
        Utc.with_ymd_and_hms(2024, 7, 30, 18, 0, 0).unwrap(),
        Utc.with_ymd_and_hms(2024, 11, 11, 6, 0, 0).unwrap(),
    ];
    
    for dt in dates {
        let (lon, lat) = moon_position(dt);
        assert!((0.0..360.0).contains(&lon), "Longitude out of range: {}", lon);
        assert!((-6.0..=6.0).contains(&lat), "Latitude out of range: {}", lat);
    }
}

#[test]
fn test_moon_phases_cycle() {
    // Test that phase angle increases monotonically over short periods
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    let mut prev_phase = moon_phase_angle(start);
    
    for hours in 1..24 {
        let dt = start + chrono::Duration::hours(hours);
        let phase = moon_phase_angle(dt);
        
        // Phase should generally increase (with small possible jumps near 360/0)
        if (phase - prev_phase).abs() < 300.0 {  // Not crossing 0/360 boundary
            assert!(phase > prev_phase, "Phase not increasing: {} -> {}", prev_phase, phase);
        }
        prev_phase = phase;
    }
}

#[test]
fn test_moon_distance_extremes() {
    // Test multiple dates to find reasonable extremes
    let mut min_dist = f64::MAX;
    let mut max_dist = f64::MIN;
    
    // Check every 12 hours for a month
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    for half_days in 0..60 {
        let dt = start + chrono::Duration::hours(half_days * 12);
        let dist = moon_distance(dt);
        min_dist = min_dist.min(dist);
        max_dist = max_dist.max(dist);
    }
    
    // Perigee ~356,500 km, Apogee ~406,700 km
    assert!(min_dist > 350000.0 && min_dist < 365000.0);
    assert!(max_dist > 395000.0 && max_dist < 410000.0);
}

#[test]
fn test_phase_illumination_consistency() {
    // Test that phase angle and illumination are consistent
    let dates = [
        (0.0, 0.0),    // New moon
        (90.0, 50.0),  // First quarter
        (180.0, 100.0), // Full moon
        (270.0, 50.0),  // Last quarter
    ];
    
    for (expected_phase, expected_illum) in dates {
        // Create a date with approximately the right phase
        let base = Utc.with_ymd_and_hms(2024, 1, 11, 12, 0, 0).unwrap(); // Near new moon
        let offset_days = (expected_phase / 360.0 * 29.53) as i64; // Lunar month
        let dt = base + chrono::Duration::days(offset_days);
        
        let illum = moon_illumination(dt);
        
        // Check illumination is in reasonable range
        // (won't be exact due to simplified calculation)
        if expected_illum == 0.0 {
            assert!(illum < 10.0);
        } else if expected_illum == 100.0 {
            assert!(illum > 90.0);
        } else {
            assert!(illum > 30.0 && illum < 70.0);
        }
    }
}

#[test]
fn test_moon_edge_cases() {
    // Test moon phase angle wraparound
    let dt = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    let phase = moon_phase_angle(dt);
    assert!((0.0..360.0).contains(&phase));
}

#[test]
fn test_moon_distance_formula() {
    // Additional moon distance test
    let dt = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    let dist = moon_distance(dt);
    
    // Distance should be reasonable
    assert!(dist > 350000.0); // Minimum possible distance
    assert!(dist < 410000.0); // Maximum possible distance
}

#[test]
fn test_moon_negative_normalizations() {
    // Test negative longitude normalization
    let dt = Utc.with_ymd_and_hms(1900, 1, 1, 0, 0, 0).unwrap();
    let (lon, _) = moon_position(dt);
    assert!((0.0..360.0).contains(&lon));
    
    // Test negative phase normalization
    let phase = moon_phase_angle(dt);
    assert!((0.0..360.0).contains(&phase));
    
    // Test negative RA normalization
    let (ra, _) = moon_equatorial(dt);
    assert!((0.0..360.0).contains(&ra));
}

#[test]
fn test_moon_phase_edge_cases() {
    // Test all phase name branches
    let base_dt = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    
    // Since we can't easily control the exact phase, at least ensure
    // the function works for various dates throughout a month
    for i in 0..30 {
        let dt = base_dt + chrono::Duration::days(i);
        let name = moon_phase_name(dt);
        assert!(["New Moon", "Waxing Crescent", "First Quarter", "Waxing Gibbous",
                 "Full Moon", "Waning Gibbous", "Last Quarter", "Waning Crescent"]
                .contains(&name));
    }
}

#[test]
fn test_moon_known_phases_erfa() {
    // Test against known lunar phases from astronomical almanacs
    // These are precise times from the US Naval Observatory
    
    // New Moon: January 11, 2024 11:57 UTC
    let new_moon = Utc.with_ymd_and_hms(2024, 1, 11, 11, 57, 0).unwrap();
    let phase = moon_phase_angle(new_moon);
    let illum = moon_illumination(new_moon);
    assert!(!(5.0..=355.0).contains(&phase), "New moon phase angle: {}", phase);
    assert!(illum < 2.0, "New moon illumination: {}", illum);
    
    // Full Moon: January 25, 2024 17:54 UTC  
    let full_moon = Utc.with_ymd_and_hms(2024, 1, 25, 17, 54, 0).unwrap();
    let phase = moon_phase_angle(full_moon);
    let illum = moon_illumination(full_moon);
    assert!(phase > 175.0 && phase < 185.0, "Full moon phase angle: {}", phase);
    assert!(illum > 98.0, "Full moon illumination: {}", illum);
    
    // First Quarter: January 18, 2024 03:53 UTC
    let first_quarter = Utc.with_ymd_and_hms(2024, 1, 18, 3, 53, 0).unwrap();
    let phase = moon_phase_angle(first_quarter);
    let illum = moon_illumination(first_quarter);
    assert!(phase > 85.0 && phase < 95.0, "First quarter phase angle: {}", phase);
    assert!(illum > 45.0 && illum < 55.0, "First quarter illumination: {}", illum);
}

#[test]
fn test_moon_perigee_apogee_erfa() {
    // Test known perigee and apogee events
    // Perigee: January 13, 2024 (approximately 362,267 km)
    let perigee = Utc.with_ymd_and_hms(2024, 1, 13, 10, 0, 0).unwrap();
    let dist_perigee = moon_distance(perigee);
    assert!(dist_perigee > 360000.0 && dist_perigee < 365000.0, 
            "Perigee distance: {}", dist_perigee);
    
    // Apogee: January 29, 2024 (approximately 405,777 km)
    let apogee = Utc.with_ymd_and_hms(2024, 1, 29, 8, 0, 0).unwrap();
    let dist_apogee = moon_distance(apogee);
    assert!(dist_apogee > 404000.0 && dist_apogee < 407000.0,
            "Apogee distance: {}", dist_apogee);
}

#[test]
fn test_moon_libration_range() {
    // ERFA's Moon98 includes libration effects
    // Latitude should vary within ±6.7° due to libration
    let mut min_lat: f64 = 90.0;
    let mut max_lat: f64 = -90.0;
    
    // Sample over a month
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    for hours in (0..720).step_by(6) {
        let dt = start + chrono::Duration::hours(hours);
        let (_, lat) = moon_position(dt);
        min_lat = min_lat.min(lat);
        max_lat = max_lat.max(lat);
    }
    
    // Check libration range
    // ERFA's Moon98 provides high-precision positions
    // Ecliptic latitude varies within ±5.145° orbital inclination
    assert!(min_lat > -6.0 && min_lat < -4.0, "Min latitude: {}", min_lat);
    assert!(max_lat > 4.0 && max_lat < 6.0, "Max latitude: {}", max_lat);
}

#[test]
fn test_moon_synodic_period() {
    // Test that the synodic period is approximately 29.53 days
    let start_new_moon = Utc.with_ymd_and_hms(2024, 1, 11, 11, 57, 0).unwrap();
    let next_new_moon = Utc.with_ymd_and_hms(2024, 2, 9, 23, 0, 0).unwrap();
    
    let start_phase = moon_phase_angle(start_new_moon);
    let end_phase = moon_phase_angle(next_new_moon);
    
    // Both should be near 0 degrees (new moon)
    assert!(!(5.0..=355.0).contains(&start_phase));
    assert!(!(5.0..=355.0).contains(&end_phase));
    
    // Period should be about 29.3 days
    let period_days = julian_date(next_new_moon) - julian_date(start_new_moon);
    assert!(period_days > 29.0 && period_days < 30.0, "Synodic period: {} days", period_days);
}

#[test]
fn test_moon_equatorial_precision() {
    // Test equatorial coordinates against known positions
    // Using data from astronomical almanac for verification
    let dt = Utc.with_ymd_and_hms(2024, 1, 15, 0, 0, 0).unwrap();
    let (ra, dec) = moon_equatorial(dt);
    
    // Expected approximate values for this date
    // These are rough values - ERFA should be accurate to arcseconds
    // Moon moves quickly, so RA range needs to be wider
    assert!((0.0..360.0).contains(&ra), "RA: {}", ra);
    assert!((-30.0..=30.0).contains(&dec), "Dec: {}", dec);
}

#[test]
fn test_moon_velocity_continuity() {
    // Test that moon position changes smoothly (no discontinuities)
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    let mut prev_lon = moon_position(start).0;
    
    for minutes in 1..60 {
        let dt = start + chrono::Duration::minutes(minutes * 10);
        let (lon, _) = moon_position(dt);
        
        // Moon moves about 13 degrees per day = 0.54 deg/hour = 0.09 deg/10min
        // Should move between 0.05 and 0.15 degrees in 10 minutes
        let mut diff = lon - prev_lon;
        
        // Handle wraparound
        if diff < -180.0 {
            diff += 360.0;
        } else if diff > 180.0 {
            diff -= 360.0;
        }
        
        assert!(diff > 0.05 && diff < 0.15, 
                "Unexpected motion: {} degrees in 10 minutes", diff);
        
        prev_lon = lon;
    }
}

#[test]
fn test_moon_ecliptic_inclination() {
    // Moon's orbit is inclined about 5.145 degrees to ecliptic
    // Latitude should stay within ±5.145° plus libration
    let mut count_within_orbit = 0;
    let total_samples = 100;
    
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    for i in 0..total_samples {
        let dt = start + chrono::Duration::hours(i * 7); // Sample every 7 hours
        let (_, lat) = moon_position(dt);
        
        if lat.abs() <= 5.2 {
            count_within_orbit += 1;
        }
    }
    
    // Most of the time should be within orbital inclination
    assert!(count_within_orbit > total_samples * 7 / 10, 
            "Only {} of {} samples within orbital plane", count_within_orbit, total_samples);
}