#[derive(Debug, Default)]
struct DateTime {
    second: usize,
    minute: usize,
    hour: usize,
    date: usize,
    week_day: usize,
    month: usize,
    year: usize,
    days_since_epoch: usize,
    day_of_year: usize,
    is_leap_year: bool,
}

const WEEK_DAYS: [usize; 7] = [4, 5, 6, 0, 1, 2, 3];

use std::time::SystemTime;

impl DateTime {
    /// Create a new `DateTime` with the current date and time in UTC.
    ///
    /// ```rust
    /// # use sys_time::DateTime;
    /// assert!(OffsetDateTime::now_utc().year() >= 2019);
    /// ```
    #[inline(always)]
    fn now_utc() -> Option<DateTime> {
        let mut datetime = DateTime::default();

        let mut month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

        let mut epoch = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .ok()
            .and_then(|t| usize::try_from(t.as_secs()).ok())?;

        let mut leap_days = 0;

        // Add or substract time zone here.
        // epoch += 19800; //GMT +5:30 = +19800 seconds

        datetime.second = epoch % 60;
        epoch /= 60;
        datetime.minute = epoch % 60;
        epoch /= 60;
        datetime.hour = epoch % 24;
        epoch /= 24;

        //number of days since epoch
        datetime.days_since_epoch = epoch;

        //Calculating WeekDay
        datetime.week_day = WEEK_DAYS[datetime.days_since_epoch % 7];

        // ball parking year, may not be accurate!
        datetime.year = 1970 + (datetime.days_since_epoch / 365);

        for i in (1972..datetime.year).step_by(4) {
            // Calculating number of leap days since epoch/1970
            if ((i % 4 == 0) && (i % 100 != 0)) || (i % 400 == 0) {
                leap_days += 1
            };
        }

        // Calculating accurate current year by (days_since_epoch - extra leap days)
        datetime.year = 1970 + ((datetime.days_since_epoch - leap_days) / 365);
        datetime.day_of_year = ((datetime.days_since_epoch - leap_days) % 365) + 1;

        //February = 28 days for non-leap years
        if ((datetime.year % 4 == 0) && (datetime.year % 100 != 0)) || (datetime.year % 400 == 0) {
            month_days[1] = 29; //February = 29 days for leap years
            datetime.is_leap_year = true; //if current year is leap, set indicator to 1
        } else {
            month_days[1] = 28
        };

        let mut temp_days = 0;
        //calculating current Month
        for i in 0..=11 {
            datetime.month = i;
            if datetime.day_of_year <= temp_days {
                break;
            }
            temp_days += month_days[datetime.month];
        }

        //calculating current Date
        temp_days -= month_days[datetime.month - 1];
        datetime.date = datetime.day_of_year - temp_days;

        Some(datetime)
    }

    #[inline(always)]
    pub fn hour(&self) -> usize {
        self.hour
    }

    #[inline(always)]
    pub fn minute(&self) -> usize {
        self.minute
    }

    #[inline(always)]
    pub fn second(&self) -> usize {
        self.second
    }
    #[inline(always)]
    pub fn day(&self) -> usize {
        self.date
    }

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

    pub fn month<'a>(&'a self) -> Month {
        match self.month {
            1 => Month::January,
            2 => Month::February,
            3 => Month::March,
            4 => Month::April,
            5 => Month::May,
            6 => Month::June,
            7 => Month::July,
            8 => Month::August,
            9 => Month::September,
            10 => Month::October,
            11 => Month::November,
            12 => Month::December,
            _ => panic!("Month is not valid"),
        }
    }

    #[inline(always)]
    pub fn weekday<'a>(&'a self) -> Weekday {
        match self.week_day {
            0 => Weekday::Sunday,
            1 => Weekday::Monday,
            2 => Weekday::Tuesday,
            3 => Weekday::Wednesday,
            4 => Weekday::Thursday,
            5 => Weekday::Friday,
            6 => Weekday::Saturday,
            _ => panic!("Week is not valid"),
        }
    }
}

#[derive(Debug, PartialEq)]
pub enum Weekday {
    Sunday = 1,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
}

impl std::fmt::Display for Weekday {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match *self {
            Weekday::Sunday => write!(f, "Sunday"),
            Weekday::Monday => write!(f, "Monday"),
            Weekday::Tuesday => write!(f, "Tuesday"),
            Weekday::Wednesday => write!(f, "Wednesday"),
            Weekday::Thursday => write!(f, "Thrusday"),
            Weekday::Friday => write!(f, "Friday"),
            Weekday::Saturday => write!(f, "Saturday"),
        }
    }
}

#[derive(Debug, PartialEq)]
pub enum Month {
    January = 1,
    February,
    March,
    April,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December,
}

impl std::fmt::Display for Month {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match *self {
            Month::January => write!(f, "January"),
            Month::February => write!(f, "February"),
            Month::March => write!(f, "March"),
            Month::April => write!(f, "April"),
            Month::May => write!(f, "May"),
            Month::June => write!(f, "June"),
            Month::July => write!(f, "July"),
            Month::August => write!(f, "August"),
            Month::September => write!(f, "September"),
            Month::October => write!(f, "October"),
            Month::November => write!(f, "November"),
            Month::December => write!(f, "December"),
        }
    }
}