rustolio_utils/time/calendar/

month.rs

//
// SPDX-License-Identifier: MPL-2.0
//
// Copyright (c) 2026 Tobias Binnewies. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

use time::util::is_leap_year;

use super::super::{Date, Month, Weekday};

use super::CalendarWeek;

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct CalendarMonth {
    year: i32,
    month: Month,
}

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

impl CalendarMonth {
    pub(in super::super) const fn new(year: i32, month: Month) -> Self {
        Self { year, month }
    }

    pub fn prev(&self) -> CalendarMonth {
        let (month, year) = match self.month {
            Month::January => (Month::December, self.year - 1),
            _ => (self.month.previous(), self.year),
        };
        Self { year, month }
    }

    pub fn next(&self) -> CalendarMonth {
        let (month, year) = match self.month {
            Month::December => (Month::January, self.year + 1),
            _ => (self.month.next(), self.year),
        };
        Self { year, month }
    }

    pub fn days(&self) -> u8 {
        match self.month {
            Month::April | Month::June | Month::September | Month::November => 30,
            Month::February => {
                if is_leap_year(self.year) {
                    29
                } else {
                    28
                }
            }
            _ => 31,
        }
    }

    pub fn weeks(&self, starting_weekday: Weekday) -> Vec<CalendarWeek> {
        let days = self.days();

        let first_day = Date::new(1, self.month, self.year).unwrap();
        let last_day = Date::new(days, self.month, self.year).unwrap();
        let first_weekday = first_day.weekday();
        let first_week = first_day.iso_week();
        let last_week = last_day.iso_week();

        let to_fill = apply_starting_weekday(first_weekday, starting_weekday);

        let mut weeks = Vec::with_capacity(6);
        let mut current_weekdays = [(0, false); 7];

        let mut idx = 0;

        // Fill first week with last days of prev months
        let prev_month_days = self.prev().days();
        for i in (0..to_fill).rev() {
            current_weekdays[idx] = (prev_month_days - i, false);
            idx += 1;
        }

        // Fill weeks with days
        let mut current_week = first_week;
        for day in 1..=days {
            if idx == 7 {
                weeks.push(CalendarWeek::new(
                    current_week,
                    current_weekdays,
                    starting_weekday,
                ));
                current_week = Date::new(day, self.month, self.year).unwrap().iso_week();
                idx = 0;
            }
            current_weekdays[idx] = (day, true);
            idx += 1;
        }

        // Fill last week with first days of next month
        let mut next_month_day = 1;
        for i in idx..7 {
            current_weekdays[i] = (next_month_day, false);
            next_month_day += 1;
        }

        weeks.push(CalendarWeek::new(
            last_week,
            current_weekdays,
            starting_weekday,
        ));

        weeks
    }
}

fn apply_starting_weekday(weekday: Weekday, start_with: Weekday) -> u8 {
    let raw = weekday as i8 - start_with as i8;
    (match raw < 0 {
        true => raw + 7,
        false => raw,
    }) as u8
}

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

    #[test]
    fn test_calendar_weeks() {
        let cm = CalendarMonth::new(2026, Month::January);
        let weeks = cm.weeks(Weekday::Monday);
        let expected = vec![
            CalendarWeek::new(
                1,
                [
                    (29, false),
                    (30, false),
                    (31, false),
                    (01, true),
                    (02, true),
                    (03, true),
                    (04, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                2,
                [
                    (05, true),
                    (06, true),
                    (07, true),
                    (08, true),
                    (09, true),
                    (10, true),
                    (11, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                3,
                [
                    (12, true),
                    (13, true),
                    (14, true),
                    (15, true),
                    (16, true),
                    (17, true),
                    (18, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                4,
                [
                    (19, true),
                    (20, true),
                    (21, true),
                    (22, true),
                    (23, true),
                    (24, true),
                    (25, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                5,
                [
                    (26, true),
                    (27, true),
                    (28, true),
                    (29, true),
                    (30, true),
                    (31, true),
                    (01, false),
                ],
                Weekday::Monday,
            ),
        ];
        assert_eq!(weeks, expected);

        let cm = CalendarMonth::new(2025, Month::December);
        let weeks = cm.weeks(Weekday::Monday);
        let expected = vec![
            CalendarWeek::new(
                49,
                [
                    (01, true),
                    (02, true),
                    (03, true),
                    (04, true),
                    (05, true),
                    (06, true),
                    (07, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                50,
                [
                    (08, true),
                    (09, true),
                    (10, true),
                    (11, true),
                    (12, true),
                    (13, true),
                    (14, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                51,
                [
                    (15, true),
                    (16, true),
                    (17, true),
                    (18, true),
                    (19, true),
                    (20, true),
                    (21, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                52,
                [
                    (22, true),
                    (23, true),
                    (24, true),
                    (25, true),
                    (26, true),
                    (27, true),
                    (28, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                1,
                [
                    (29, true),
                    (30, true),
                    (31, true),
                    (01, false),
                    (02, false),
                    (03, false),
                    (04, false),
                ],
                Weekday::Monday,
            ),
        ];
        assert_eq!(weeks, expected);

        let cm = CalendarMonth::new(2027, Month::January);
        let weeks = cm.weeks(Weekday::Monday);
        let expected = vec![
            CalendarWeek::new(
                53,
                [
                    (28, false),
                    (29, false),
                    (30, false),
                    (31, false),
                    (01, true),
                    (02, true),
                    (03, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                1,
                [
                    (04, true),
                    (05, true),
                    (06, true),
                    (07, true),
                    (08, true),
                    (09, true),
                    (10, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                2,
                [
                    (11, true),
                    (12, true),
                    (13, true),
                    (14, true),
                    (15, true),
                    (16, true),
                    (17, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                3,
                [
                    (18, true),
                    (19, true),
                    (20, true),
                    (21, true),
                    (22, true),
                    (23, true),
                    (24, true),
                ],
                Weekday::Monday,
            ),
            CalendarWeek::new(
                4,
                [
                    (25, true),
                    (26, true),
                    (27, true),
                    (28, true),
                    (29, true),
                    (30, true),
                    (31, true),
                ],
                Weekday::Monday,
            ),
        ];
        assert_eq!(weeks, expected);
    }
}