// 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 https://mozilla.org/MPL/2.0/.

use crate::common::math::TermNum;

use crate::day_count::BoundedDayCount;

use crate::day_count::Fixed;

use crate::day_count::FromFixed;

use crate::CalendarError;

/// Represents a clock time as hours, minutes and seconds

#[derive(Debug, PartialEq, PartialOrd, Clone, Copy)]

pub struct ClockTime {

    pub hours: u8,

    pub minutes: u8,

    pub seconds: f32,

}

impl ClockTime {

    /// Returns an error if the ClockTime is invalid.

    pub fn validate(self) -> Result<(), CalendarError> {

        if self.hours > 23 {

            Err(CalendarError::InvalidHour)

        } else if self.minutes >= 60 {

            Err(CalendarError::InvalidMinute)

        } else if self.seconds > 60.0 {

            //Allow 60.0 for leap second

            Err(CalendarError::InvalidSecond)

        } else {

            Ok(())

        }

    }

    pub fn hour_1_to_12(self) -> u8 {

        (self.hours as i64).adjusted_remainder(12) as u8

    }

}

/// Represents a clock time as a fraction of a day

///

/// This is internally a floating point number, where the fractional portion represents

/// a particular time of day. For example 1.0 is midnight at the start of day 1, and 1.5 is

/// noon on day 1.

///

/// Note that equality and ordering operations are subject to limitations similar to

/// equality and ordering operations on a floating point number. Two `TimeOfDay` values represent

/// the same day or even the same second, but still appear different on the sub-second level.

#[derive(Debug, PartialEq, PartialOrd, Clone, Copy, Default)]

pub struct TimeOfDay(f64);

impl TimeOfDay {

    /// Create a new `TimeOfDay`

    pub fn new(t: f64) -> Self {

        TimeOfDay(t)

    }

    pub fn midnight() -> Self {

        TimeOfDay(0.0)

    }

    pub fn noon() -> Self {

        TimeOfDay(0.5)

    }

    /// Get underlying floating point from `TimeOfDay`

    pub fn get(self) -> f64 {

        self.0

    }

    /// Split `TimeOfDay` into hours, minutes, and seconds

    pub fn to_clock(self) -> ClockTime {

        //LISTING 1.44 (*Calendrical Calculations: The Ultimate Edition* by Reingold & Dershowitz.)

        let b = [24.0, 60.0, 60.0];

        let mut a = [0.0, 0.0, 0.0, 0.0];

        TermNum::to_mixed_radix(self.get(), &b, 0, &mut a)

            .expect("Valid inputs, other failures are impossible.");

        ClockTime {

            hours: a[1] as u8,

            minutes: a[2] as u8,

            seconds: a[3] as f32,

        }

    }

    /// Aggregate hours, minutes and second fields into a `TimeOfDay`

    pub fn try_from_clock(clock: ClockTime) -> Result<Self, CalendarError> {

        //LISTING 1.43 (*Calendrical Calculations: The Ultimate Edition* by Reingold & Dershowitz.)

        clock.validate()
?768
;

        let a = [

            0.0,

            clock.hours as f64,

            clock.minutes as f64,

            clock.seconds as f64,

        ];

        let b = [24.0, 60.0, 60.0];

        let t = TermNum::from_mixed_radix(&a, &b, 0)
?0
;

        Ok(TimeOfDay::new(t))

    }

}

impl FromFixed for TimeOfDay {

    fn from_fixed(t: Fixed) -> TimeOfDay {

        TimeOfDay::new(t.to_time_of_day().get())

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::day_count::BoundedDayCount;

    use crate::day_count::JulianDay;

    use crate::day_count::ToFixed;

    use crate::day_count::FIXED_MAX;

    use crate::day_count::FIXED_MIN;

    use proptest::proptest;

    #[test]

    fn time() {

        let j0: JulianDay = JulianDay::new(0.0);

        assert_eq!(j0.convert::<TimeOfDay>().0, 0.5);

    }

    #[test]

    fn obvious_clock_times() {

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 0,

                minutes: 0,

                seconds: 0.0

            })

            .unwrap(),

            TimeOfDay::new(0.0)

        );

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 0,

                minutes: 0,

                seconds: 1.0

            })

            .unwrap(),

            TimeOfDay::new(1.0 / (24.0 * 60.0 * 60.0))

        );

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 0,

                minutes: 1,

                seconds: 0.0

            })

            .unwrap(),

            TimeOfDay::new(1.0 / (24.0 * 60.0))

        );

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 6,

                minutes: 0,

                seconds: 0.0

            })

            .unwrap(),

            TimeOfDay::new(0.25)

        );

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 12,

                minutes: 0,

                seconds: 0.0

            })

            .unwrap(),

            TimeOfDay::new(0.5)

        );

        assert_eq!(

            TimeOfDay::try_from_clock(ClockTime {

                hours: 18,

                minutes: 0,

                seconds: 0.0

            })

            .unwrap(),

            TimeOfDay::new(0.75)

        );

    }

    proptest! {

        #[test]

        fn clock_time_round_trip(ahr in 0..24,amn in 0..59,asc in 0..59) {

            let hours = ahr as u8;

            let minutes = amn as u8;

            let seconds = asc as f32;

            let c0 = ClockTime { hours, minutes, seconds };

            let t = TimeOfDay::try_from_clock(c0).unwrap();

            let c1 = t.to_clock();

            assert_eq!(c0, c1);

        }

        #[test]

        fn clock_time_from_moment(x in FIXED_MIN..FIXED_MAX) {

            let t = TimeOfDay::from_fixed(Fixed::new(x));

            let c = t.to_clock();

            c.validate().unwrap();

        }

        #[test]

        fn invalid_hour(ahr in 25..u8::MAX,amn in 0..59,asc in 0..59) {

            let c0 = ClockTime { hours: ahr as u8, minutes: amn as u8, seconds: asc as f32 };

            assert!(TimeOfDay::try_from_clock(c0).is_err());

        }

        #[test]

        fn invalid_minute(ahr in 0..59,amn in 60..u8::MAX,asc in 0..59) {

            let c0 = ClockTime { hours: ahr as u8, minutes: amn as u8, seconds: asc as f32 };

            assert!(TimeOfDay::try_from_clock(c0).is_err());

        }

        #[test]

        fn invalid_second(ahr in 0..59,amn in 0..59,asc in 61..u8::MAX) {

            let c0 = ClockTime { hours: ahr as u8, minutes: amn as u8, seconds: asc as f32 };

            assert!(TimeOfDay::try_from_clock(c0).is_err());

        }

    }

}