// use std::time::SystemTime;
// use std::error;
use std::fmt;

// 派生判断结构体比较的特性(=,>,<,<=,>=)
#[derive(PartialEq,PartialOrd)]
pub struct UTCDatetime{
    year:u16,
    month:u8,
    day:u8,
    hour:u8,
    minute:u8,
    second:u8,
}

// 自定义一个错误类型
#[derive(Debug, Clone)]
pub enum IllegalTimeError{
    YearNumberError,
    MonthNumberError,
    DayNumberError,
    HourNumberError,
    MinuteNumberError,
    SecondNumberError,
    TimeStringError
}

impl fmt::Display for IllegalTimeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // write!(f, "Illegal time")
        match self{
            IllegalTimeError::YearNumberError=>write!(f, "Year Number Error"),
            IllegalTimeError::MonthNumberError=>write!(f, "Month Number Error"),
            IllegalTimeError::DayNumberError=>write!(f, "Day Number Error"),
            IllegalTimeError::HourNumberError=>write!(f, "Hour Number Error"),
            IllegalTimeError::MinuteNumberError=>write!(f, "Minute Number Error"),
            IllegalTimeError::SecondNumberError=>write!(f, "Second Number Error"),
            IllegalTimeError::TimeStringError=>write!(f,"The format of the input time string is not standardized")
        }
    }
}


impl UTCDatetime{
    /// Create a new UTCDatetimr structure
    pub fn new(year:u16,month:u8,day:u8,hour:u8,minute:u8,second:u8)->Result<UTCDatetime, IllegalTimeError>{
        if month==0 || month >12{
            // println!("月份非法");
            return Err(IllegalTimeError::MonthNumberError)
        }
        if day==0 || day >31{
            // println!("天数非法");
            return Err(IllegalTimeError::DayNumberError)
        }
        if hour >23{
            // println!("小时数非法");
            return Err(IllegalTimeError::HourNumberError)
        }
        if minute>59{
            // println!("分钟数非法");
            return Err(IllegalTimeError::MinuteNumberError)
        }
        if second>59{
            // println!("秒数非法");
            return Err(IllegalTimeError::SecondNumberError)
        }
        Ok(UTCDatetime{year,month,day,hour,minute,second})
    }
    // 返回utc时间的时间戳
    /// Returns the number of seconds since January 1, 1970
    pub fn get_timestamp(&self)->Result<u32,IllegalTimeError>{
        if self.year<1970{
            return Err(IllegalTimeError::YearNumberError)
        }
        let second=self.second as u32;
        let minute=self.minute as u32;
        let hour=self.hour as u32;
        let day =self.day as u32;

        // 计算这个月的秒数
        let seconds_this_month=second+60*minute+60*60*hour+60*60*24*(day-1);
        
        let mut seconds_past_years:u32=0;
        for i in 1970..self.year{
            if is_leap_year(i){
                seconds_past_years+=366*24*60*60;
            }else{
                seconds_past_years+=365*24*60*60;   
            }
        }

        // 计算今年过去的月份的秒数
        let mut seconds_past_months=0;
        for i in 1..self.month{
            let days_num=days_of_the_month(self.year, i) as u32;
            seconds_past_months+=days_num*24*60*60;
        }
        Ok(seconds_past_years+seconds_past_months+seconds_this_month)
    }

    // 返回今天是星期几 星期一到六 返回1到6 星期天返回0
    /// Return today is the day of the week,Monday to Saturday Return 1 to 6,Sunday return 0
    pub fn day_of_the_week(&self)->u8{
        let ts=self.get_timestamp().unwrap();
        //7*24*3600 为一周7天的秒数
        let this_week_seconds=ts%(7*24*3600);
        // 24*3600为一天的秒数
        let this_week_days=this_week_seconds/(24*3600);
        // 1970年一月一日是周四
        let week_number=(4+this_week_days)%7;
        week_number as u8
    }

    // 判断当前时间是否与输入时间相等,相等返回true,否则返回false
    /// Determine whether the current time is equal to the input time
    pub fn equals(&self,sd:&UTCDatetime)->bool{
        if self.year!=sd.year 
        ||self.month!=sd.month 
        ||self.day!=sd.day
        ||self.hour!=sd.hour
        ||self.minute!=sd.minute
        ||self.second!=sd.second{
            return false
        }
        true
    }

    // 如果当前时间在输入时间的后面则输出true,否则输出false
    fn compare_to(&self,sd:&UTCDatetime)->bool{
        if self.year>sd.year{
            return true
        }else if self.year<sd.year{
            return false
        }

        if self.month>sd.month{
            return true
        }else if self.month<sd.month{
            return false
        }

        if self.day>sd.day{
            return true
        }else if self.day<sd.day{
            return false
        }

        if self.hour>sd.hour{
            return true
        }else if self.hour<sd.hour{
            return false
        }

        if self.minute>sd.minute{
            return true
        }else if self.minute<sd.minute{
            return false
        }

        if self.second>sd.second{
            return true
        }else if self.second<sd.second{
            return false
        }
        // 两个时间相等的话
        false 
    }

    // 输入一个时间字符串(如"2002-04-01 00:00:01") 返回一个时间对象
    pub fn from_string(time_str:&str)->Result<UTCDatetime, IllegalTimeError>{
        let time_string_array:Vec<&str>=time_str.split(|x|(x=='-' || x==':' ||x==' ')).collect();
        if time_string_array.len()!=6{
            return Err(IllegalTimeError::TimeStringError)
        }   
        let year=time_string_array[0].parse::<u16>().unwrap();
        let month=time_string_array[1].parse::<u8>().unwrap();
        let day=time_string_array[2].parse::<u8>().unwrap();
        let hour=time_string_array[3].parse::<u8>().unwrap();
        let minute=time_string_array[4].parse::<u8>().unwrap();
        let second=time_string_array[5].parse::<u8>().unwrap();
        UTCDatetime::new(year,month,day,hour,minute,second)
    }
}
impl fmt::Display for UTCDatetime{
    fn fmt(&self,f: &mut fmt::Formatter)->fmt::Result{
        // 指定宽度输入数字
        write!(f,"{}-{:02}-{:02} {:02}:{:02}:{:02}",self.year,self.month,self.day,self.hour,self.minute,self.second)
    }
}

fn is_leap_year(year:u16)->bool{
    if (year%4==0 && year%100!=0)||year%400==0{
        return true
    }
    false
}

fn days_of_the_month(year:u16,month:u8)->u8{
    match month{
        1|3|5|7|8|10|12=>31,
        4|6|9|11=>30,
        2=>{
            if is_leap_year(year){
                return 29
            }
            28
        }
        _=>{0}
    }
}

fn main() ->Result<(),IllegalTimeError> {
    let a_time= UTCDatetime::new(2019, 1, 1, 1, 1, 0)?;
    let another_time = UTCDatetime::new(2019,1,1,1,1,0)?;
    println!("{}",a_time>=another_time);
    // println!("{}",a_time);
    // println!("{}",a_time.get_timestamp()?);
    // println!("{}",a_time.day_of_the_week());
    Ok(())
}