use core::cmp::{max, min};

#[derive(Clone, PartialEq, Eq)]
pub struct Calendar {
    base_year: u16,
    frozen: bool,
    hours: u8,
    minutes: u8,
    seconds: u8,
    day: u8,
    month: u8,
    year: u16,
}

impl Calendar {
    pub fn new(hours: u8, minutes: u8, seconds: u8, day: u8, month: u8, year: u16) -> Self {
        Self::with_base_year(year, hours, minutes, seconds, day, month, year)
    }

    /// Calendar may have a base year, that will be used when calling [to_ticks](`Calendar::to_ticks`).
    pub fn with_base_year(
        base_year: u16,
        hours: u8,
        minutes: u8,
        seconds: u8,
        day: u8,
        month: u8,
        year: u16,
    ) -> Self {
        Self {
            base_year,
            hours,
            minutes,
            seconds,
            day,
            month,
            year,
            frozen: false,
        }
    }

    /// Calculate current date based off of the seconds elapsed since
    /// a base date
    pub fn from_ticks(base_year: u16, mut seconds: u32) -> Self {
        let total_seconds = seconds;
        let seconds = total_seconds % 60;

        let total_minutes = total_seconds / 60;
        let minutes = total_minutes % 60;

        let total_hours = total_minutes / 60;
        let hours = total_hours % 24;

        let elapsed_days = total_hours / 24;
        // elapsed_days / 365 / 4 subtracts leap days each 4 years, except for the last leap day
        // that could have been in the last 3 years, solution for that day is presented
        // below.
        let estimated_years_elapsed = (elapsed_days - elapsed_days / 365 / 4) / 365;
        let estimated_year = base_year as u32 + estimated_years_elapsed;

        // estimated_years_elapsed may not be correct, imagine a situation,
        // the current year is a leap year, ie. 2024, base is 2021 (1. 1. 00:00:00),
        // it's 31. 12. 2024, the problem is that the last leap year, 2024, is not captured
        // by elapsed_days / 365 / 4 in this case.
        // If we did not subtract a day from the elapsed days, the program would
        // incorrectly conclude it's 1. 1. 2025.
        let mut elapsed_days_without_leap_day_in_past_3_years = total_hours / 24;
        // uhh... naming of this property is 1. long, 2. still not correct,
        // the variable should have leap days that were in last 3 years,
        // but not in the current one.
        for current_year in max(base_year as u32, estimated_year - 3)..=estimated_year - 1 {
            elapsed_days_without_leap_day_in_past_3_years -=
                if Self::is_leap_year(current_year as u16) {
                    1
                } else {
                    0
                };
        }

        // this should be the correct year
        let years_elapsed = (elapsed_days_without_leap_day_in_past_3_years
            - elapsed_days_without_leap_day_in_past_3_years / 365 / 4)
            / 365;
        let year = base_year as u32 + years_elapsed;

        if year != estimated_year && Self::is_leap_year(year as u16) {
            // we went back one year, the current year is a leap year,
            // because leap day is included in Self::days_in_month,
            // it should not be present in the elapsed days...
            elapsed_days_without_leap_day_in_past_3_years += 1;
        }

        let leap_year = Self::is_leap_year(year as u16);

        let days_from_year_start =
            elapsed_days_without_leap_day_in_past_3_years - years_elapsed * 365 - years_elapsed / 4;
        let mut month = 1;
        let mut day = days_from_year_start;
        let mut total_days_in_month = Self::days_in_month(month, leap_year) as u32;
        while day >= total_days_in_month {
            day -= total_days_in_month;
            month += 1;
            total_days_in_month = Self::days_in_month(month, leap_year) as u32;
        }
        day += 1;

        Self {
            base_year,
            seconds: seconds as u8,
            minutes: minutes as u8,
            hours: hours as u8,
            day: day as u8,
            month: month as u8,
            year: year as u16,
            frozen: false,
        }
    }

    /// Converts the date into ticks, elapsed seconds
    /// from base year, that was specified upon creation of the calendar.
    pub fn to_ticks(&self) -> u32 {
        let mut ticks = 0u32;

        ticks += self.seconds as u32;
        ticks += self.minutes as u32 * 60;
        ticks += self.hours as u32 * 60 * 60;
        ticks += (self.day - 1) as u32 * 24 * 60 * 60;
        ticks +=
            Self::days_in_year(self.month, Self::is_leap_year(self.year)) as u32 * 24 * 60 * 60;
        let elapsed_years = self.year as u32 - self.base_year as u32;
        ticks += (elapsed_years * 365 + elapsed_years / 4) * 24 * 60 * 60;

        for year in max(self.year - 3, self.base_year)..=self.year - 1 {
            ticks += if Self::is_leap_year(year) {
                24 * 60 * 60
            } else {
                0
            };
        }

        ticks
    }

    /// Adds a second, correctly updating
    /// minutes, hours, days, month, year...
    pub fn second_elapsed(&mut self) {
        if self.frozen {
            return;
        }

        self.seconds = (self.seconds + 1) % 60;
        let minute_elapsed = self.seconds == 0;
        self.minutes = (self.minutes + if minute_elapsed { 1 } else { 0 }) % 60;

        let hour_elapsed = minute_elapsed && self.minutes == 0;
        self.hours = (self.hours + if hour_elapsed { 1 } else { 0 }) % 24;

        let day_elapsed = hour_elapsed && self.hours == 0;
        let day = self.day - 1 + if day_elapsed { 1 } else { 0 };
        let days_in_month = Self::days_in_month(self.month, Self::is_leap_year(self.year));
        self.day = day % days_in_month + 1;

        let month_elapsed = day_elapsed && self.day == 1;
        self.month = (self.month - 1 + if month_elapsed { 1 } else { 0 }) % 12 + 1;
        let year_elapsed = month_elapsed && self.month == 1;
        self.year += if year_elapsed { 1 } else { 0 };
    }

    pub fn hours(&self) -> u8 {
        self.hours
    }

    pub fn minutes(&self) -> u8 {
        self.minutes
    }

    pub fn seconds(&self) -> u8 {
        self.seconds
    }

    pub fn day(&self) -> u8 {
        self.day
    }

    pub fn month(&self) -> u8 {
        self.month
    }

    pub fn year(&self) -> u16 {
        self.year
    }

    pub fn second_elapsed(&mut self) {
        self.seconds = (self.seconds + 1) % 60;
        let minute_elapsed = self.seconds == 0;
        self.minutes = (self.minutes + if minute_elapsed { 1 } else { 0 }) % 60;

        let hour_elapsed = minute_elapsed && self.minutes == 0;
        self.hours = (self.hours + if hour_elapsed { 1 } else { 0 }) % 24;

        let day_elapsed = hour_elapsed && self.hours == 0;
        let day = self.day - 1 + if day_elapsed { 1 } else { 0 };
        let days_in_month = Self::days_in_month(self.month, Self::is_leap_year(self.year));
        self.day = day % days_in_month + 1;

        let month_elapsed = day_elapsed && self.day == 1;
        self.month = (self.month - 1 + if month_elapsed { 1 } else { 0 }) % 12 + 1;
        let year_elapsed = month_elapsed && self.month == 1;
        self.year += if year_elapsed { 1 } else { 0 };
    }

    fn is_leap_year(year: u16) -> bool {
        matches!(year % 4, 0 if year % 100 != 0 || year % 400 == 0)
    }

    fn days_in_month(month: u8, leap_year: bool) -> u8 {
        match month {
            2 if leap_year => 29,
            2 => 28,
            1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
            4 | 6 | 9 | 11 => 30,
            _ => panic!(),
        }
    }

    fn days_in_year(before_month: u8, leap_year: bool) -> u16 {
        let mut days_in_year = 0u16;
        for i in 1..before_month {
            days_in_year += Self::days_in_month(i, leap_year) as u16;
        }

        days_in_year
    }
}