guise-ui 0.10.0

//! `Date` — a plain calendar date plus the math the date components need.
//!
//! Pure logic, no gpui: leap years, month lengths, weekday math, month grids
//! for calendar layouts, and a small token formatter/parser. Algorithms for
//! day-count conversion follow Howard Hinnant's civil-date derivations.

use std::fmt;
use std::time::{SystemTime, UNIX_EPOCH};

/// English month names, January first.
pub const MONTH_NAMES: [&str; 12] = [
    "January",
    "February",
    "March",
    "April",
    "May",
    "June",
    "July",
    "August",
    "September",
    "October",
    "November",
    "December",
];

/// Day of week. `index()` is 0-based from Sunday.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Weekday {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
}

impl Weekday {
    pub const ALL: [Weekday; 7] = [
        Weekday::Sunday,
        Weekday::Monday,
        Weekday::Tuesday,
        Weekday::Wednesday,
        Weekday::Thursday,
        Weekday::Friday,
        Weekday::Saturday,
    ];

    pub fn index(self) -> u32 {
        self as u32
    }

    pub fn from_index(index: u32) -> Weekday {
        Weekday::ALL[(index % 7) as usize]
    }

    pub fn name(self) -> &'static str {
        match self {
            Weekday::Sunday => "Sunday",
            Weekday::Monday => "Monday",
            Weekday::Tuesday => "Tuesday",
            Weekday::Wednesday => "Wednesday",
            Weekday::Thursday => "Thursday",
            Weekday::Friday => "Friday",
            Weekday::Saturday => "Saturday",
        }
    }

    /// Two-letter header label ("Su", "Mo", …).
    pub fn short(self) -> &'static str {
        &self.name()[..2]
    }
}

/// A calendar date. Construct with [`Date::new`], which validates.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Date {
    year: i32,
    month: u32,
    day: u32,
}

/// True for Gregorian leap years.
pub fn is_leap_year(year: i32) -> bool {
    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
}

/// Number of days in the given month (1–12) of the given year.
pub fn days_in_month(year: i32, month: u32) -> u32 {
    match month {
        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
        4 | 6 | 9 | 11 => 30,
        2 => {
            if is_leap_year(year) {
                29
            } else {
                28
            }
        }
        _ => 0,
    }
}

/// Days since 1970-01-01 (negative before it).
fn days_from_civil(year: i32, month: u32, day: u32) -> i64 {
    let y = i64::from(if month <= 2 { year - 1 } else { year });
    let era = if y >= 0 { y } else { y - 399 } / 400;
    let yoe = y - era * 400;
    let mp = (i64::from(month) + 9) % 12;
    let doy = (153 * mp + 2) / 5 + i64::from(day) - 1;
    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    era * 146097 + doe - 719468
}

/// Inverse of [`days_from_civil`].
fn civil_from_days(days: i64) -> (i32, u32, u32) {
    let z = days + 719468;
    let era = if z >= 0 { z } else { z - 146096 } / 146097;
    let doe = z - era * 146097;
    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let day = (doy - (153 * mp + 2) / 5 + 1) as u32;
    let month = (if mp < 10 { mp + 3 } else { mp - 9 }) as u32;
    let year = (if month <= 2 { y + 1 } else { y }) as i32;
    (year, month, day)
}

impl Date {
    /// A validated date, or `None` for impossible ones (Feb 30, month 13, …).
    pub fn new(year: i32, month: u32, day: u32) -> Option<Date> {
        if (1..=12).contains(&month) && day >= 1 && day <= days_in_month(year, month) {
            Some(Date { year, month, day })
        } else {
            None
        }
    }

    /// Today in UTC (std has no timezone database; a calendar highlight is
    /// the intended use, not civil timekeeping).
    pub fn today() -> Date {
        let secs = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map(|d| d.as_secs() as i64)
            .unwrap_or(0);
        Date::from_days(secs.div_euclid(86_400))
    }

    pub fn year(self) -> i32 {
        self.year
    }

    pub fn month(self) -> u32 {
        self.month
    }

    pub fn day(self) -> u32 {
        self.day
    }

    /// Days since 1970-01-01.
    pub fn to_days(self) -> i64 {
        days_from_civil(self.year, self.month, self.day)
    }

    /// The date `days` after 1970-01-01.
    pub fn from_days(days: i64) -> Date {
        let (year, month, day) = civil_from_days(days);
        Date { year, month, day }
    }

    pub fn weekday(self) -> Weekday {
        Weekday::from_index((self.to_days() + 4).rem_euclid(7) as u32)
    }

    pub fn add_days(self, days: i64) -> Date {
        Date::from_days(self.to_days() + days)
    }

    /// Shift by whole months, clamping the day to the target month's length
    /// (Jan 31 + 1 month = Feb 28/29).
    pub fn add_months(self, months: i32) -> Date {
        let total = self.year * 12 + (self.month as i32 - 1) + months;
        let year = total.div_euclid(12);
        let month = (total.rem_euclid(12) + 1) as u32;
        let day = self.day.min(days_in_month(year, month));
        Date { year, month, day }
    }

    pub fn month_name(self) -> &'static str {
        MONTH_NAMES[(self.month - 1) as usize]
    }

    /// Render through a token pattern. Tokens: `YYYY`, `MM`, `M`, `DD`, `D`,
    /// `MMM` (Jan), `MMMM` (January). Anything else passes through.
    pub fn format(self, pattern: &str) -> String {
        let mut out = String::with_capacity(pattern.len() + 4);
        let bytes = pattern.as_bytes();
        let mut i = 0;
        while i < bytes.len() {
            let run = |ch: u8| bytes[i..].iter().take_while(|&&b| b == ch).count();
            match bytes[i] {
                b'Y' => {
                    let n = run(b'Y');
                    out.push_str(&format!("{:04}", self.year));
                    i += n;
                }
                b'M' => match run(b'M') {
                    1 => {
                        out.push_str(&self.month.to_string());
                        i += 1;
                    }
                    2 => {
                        out.push_str(&format!("{:02}", self.month));
                        i += 2;
                    }
                    3 => {
                        out.push_str(&self.month_name()[..3]);
                        i += 3;
                    }
                    _ => {
                        out.push_str(self.month_name());
                        i += run(b'M');
                    }
                },
                b'D' => {
                    let n = run(b'D');
                    if n >= 2 {
                        out.push_str(&format!("{:02}", self.day));
                    } else {
                        out.push_str(&self.day.to_string());
                    }
                    i += n;
                }
                other => {
                    out.push(other as char);
                    i += 1;
                }
            }
        }
        out
    }

    /// Parse `"YYYY-MM-DD"` (also tolerates single-digit month/day).
    pub fn parse_iso(s: &str) -> Option<Date> {
        let mut parts = s.trim().split('-');
        let year: i32 = parts.next()?.parse().ok()?;
        let month: u32 = parts.next()?.parse().ok()?;
        let day: u32 = parts.next()?.parse().ok()?;
        if parts.next().is_some() {
            return None;
        }
        Date::new(year, month, day)
    }
}

impl fmt::Display for Date {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
    }
}

/// The 42 cells (6 weeks × 7 days) a month calendar shows for `year`/`month`,
/// starting each week on `week_start`. Leading/trailing cells come from the
/// neighboring months; compare `.month()` against `month` to dim them.
pub fn month_grid(year: i32, month: u32, week_start: Weekday) -> Vec<Date> {
    let first = Date::new(year, month, 1).unwrap_or_else(|| Date::from_days(0));
    let lead = (first.weekday().index() + 7 - week_start.index()) % 7;
    let start = first.add_days(-i64::from(lead));
    (0..42).map(|i| start.add_days(i)).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn leap_years() {
        assert!(is_leap_year(2024));
        assert!(is_leap_year(2000));
        assert!(!is_leap_year(1900));
        assert!(!is_leap_year(2026));
    }

    #[test]
    fn month_lengths() {
        assert_eq!(days_in_month(2026, 1), 31);
        assert_eq!(days_in_month(2026, 2), 28);
        assert_eq!(days_in_month(2024, 2), 29);
        assert_eq!(days_in_month(2026, 4), 30);
        assert_eq!(days_in_month(2026, 13), 0);
    }

    #[test]
    fn validation() {
        assert!(Date::new(2026, 2, 29).is_none());
        assert!(Date::new(2024, 2, 29).is_some());
        assert!(Date::new(2026, 0, 1).is_none());
        assert!(Date::new(2026, 12, 31).is_some());
        assert!(Date::new(2026, 6, 0).is_none());
    }

    #[test]
    fn epoch_round_trip() {
        assert_eq!(Date::new(1970, 1, 1).unwrap().to_days(), 0);
        assert_eq!(Date::from_days(0), Date::new(1970, 1, 1).unwrap());
        for days in [-1_000_000, -365, -1, 0, 1, 365, 738_000, 1_000_000] {
            assert_eq!(Date::from_days(days).to_days(), days);
        }
    }

    #[test]
    fn known_weekdays() {
        // 1970-01-01 was a Thursday; 2026-07-14 is a Tuesday.
        assert_eq!(Date::new(1970, 1, 1).unwrap().weekday(), Weekday::Thursday);
        assert_eq!(Date::new(2026, 7, 14).unwrap().weekday(), Weekday::Tuesday);
        assert_eq!(Date::new(2000, 1, 1).unwrap().weekday(), Weekday::Saturday);
        assert_eq!(Date::new(1899, 12, 31).unwrap().weekday(), Weekday::Sunday);
    }

    #[test]
    fn add_days_crosses_boundaries() {
        let d = Date::new(2026, 12, 31).unwrap();
        assert_eq!(d.add_days(1), Date::new(2027, 1, 1).unwrap());
        assert_eq!(d.add_days(-365), Date::new(2025, 12, 31).unwrap());
        let leap = Date::new(2024, 2, 28).unwrap();
        assert_eq!(leap.add_days(1), Date::new(2024, 2, 29).unwrap());
        assert_eq!(leap.add_days(2), Date::new(2024, 3, 1).unwrap());
    }

    #[test]
    fn add_months_clamps() {
        let jan31 = Date::new(2026, 1, 31).unwrap();
        assert_eq!(jan31.add_months(1), Date::new(2026, 2, 28).unwrap());
        assert_eq!(jan31.add_months(13), Date::new(2027, 2, 28).unwrap());
        assert_eq!(jan31.add_months(-2), Date::new(2025, 11, 30).unwrap());
        let jul = Date::new(2026, 7, 14).unwrap();
        assert_eq!(jul.add_months(12), Date::new(2027, 7, 14).unwrap());
        assert_eq!(jul.add_months(-7), Date::new(2025, 12, 14).unwrap());
    }

    #[test]
    fn ordering() {
        let a = Date::new(2026, 7, 14).unwrap();
        let b = Date::new(2026, 7, 15).unwrap();
        let c = Date::new(2027, 1, 1).unwrap();
        assert!(a < b && b < c);
    }

    #[test]
    fn grid_starts_on_week_start() {
        // July 2026 starts on a Wednesday.
        let grid = month_grid(2026, 7, Weekday::Sunday);
        assert_eq!(grid.len(), 42);
        assert_eq!(grid[0], Date::new(2026, 6, 28).unwrap());
        assert_eq!(grid[3], Date::new(2026, 7, 1).unwrap());
        assert_eq!(grid[41], Date::new(2026, 8, 8).unwrap());
        for cell in &grid {
            assert_eq!(cell.weekday().index(), (cell.to_days() + 4).rem_euclid(7) as u32);
        }

        let monday = month_grid(2026, 7, Weekday::Monday);
        assert_eq!(monday[0].weekday(), Weekday::Monday);
        assert_eq!(monday[2], Date::new(2026, 7, 1).unwrap());
    }

    #[test]
    fn grid_when_month_starts_on_week_start() {
        // March 2026 starts on a Sunday: no leading cells.
        let grid = month_grid(2026, 3, Weekday::Sunday);
        assert_eq!(grid[0], Date::new(2026, 3, 1).unwrap());
    }

    #[test]
    fn formatting() {
        let d = Date::new(2026, 7, 4).unwrap();
        assert_eq!(d.format("YYYY-MM-DD"), "2026-07-04");
        assert_eq!(d.format("M/D/YYYY"), "7/4/2026");
        assert_eq!(d.format("MMM D, YYYY"), "Jul 4, 2026");
        assert_eq!(d.format("MMMM D"), "July 4");
        assert_eq!(d.to_string(), "2026-07-04");
    }

    #[test]
    fn iso_parsing() {
        assert_eq!(Date::parse_iso("2026-07-04"), Date::new(2026, 7, 4));
        assert_eq!(Date::parse_iso(" 2026-7-4 "), Date::new(2026, 7, 4));
        assert_eq!(Date::parse_iso("2026-02-30"), None);
        assert_eq!(Date::parse_iso("2026-07"), None);
        assert_eq!(Date::parse_iso("2026-07-04-01"), None);
        assert_eq!(Date::parse_iso("garbage"), None);
    }

    #[test]
    fn weekday_helpers() {
        assert_eq!(Weekday::Sunday.short(), "Su");
        assert_eq!(Weekday::from_index(8), Weekday::Monday);
        assert_eq!(Weekday::Saturday.index(), 6);
    }
}