use chrono::{Local, NaiveDate};
use dimensioned::si;

#[derive(Clone, Debug, PartialEq)]
pub struct ParseError;

// This interval doesn't feel right, either. The idea that I have a specific interval type for just
// NaiveDate is odd. This should be genericized, as should the iterator. Also, it shouldn't live
// here, but in utilities.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DayInterval {
    pub start: NaiveDate,
    pub end: NaiveDate,
}

impl Default for DayInterval {
    fn default() -> Self {
        Self {
            start: (Local::now() - chrono::Duration::days(7)).date_naive(),
            end: Local::now().date_naive(),
        }
    }
}

impl DayInterval {
    pub fn days(&self) -> impl Iterator<Item = NaiveDate> {
        DayIterator {
            current: self.start,
            end: self.end,
        }
    }
}

struct DayIterator {
    current: NaiveDate,
    end: NaiveDate,
}

impl Iterator for DayIterator {
    type Item = NaiveDate;

    fn next(&mut self) -> Option<Self::Item> {
        if self.current <= self.end {
            let val = self.current;
            self.current += chrono::Duration::days(1);
            Some(val)
        } else {
            None
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FormatOption {
    Abbreviated,
    #[allow(unused)]
    Full,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TimeFormatter(chrono::NaiveTime);

impl TimeFormatter {
    #[allow(unused)]
    pub fn format(&self, option: FormatOption) -> String {
        match option {
            FormatOption::Abbreviated => self.0.format("%H:%M"),
            FormatOption::Full => self.0.format("%H:%M:%S"),
        }
        .to_string()
    }

    #[allow(unused)]
    pub fn parse(s: &str) -> Result<TimeFormatter, ParseError> {
        let parts = s
            .split(':')
            .map(|part| part.parse::<u32>().map_err(|_| ParseError))
            .collect::<Result<Vec<u32>, ParseError>>()?;
        match parts.len() {
            0 => Err(ParseError),
            1 => Err(ParseError),
            2 => chrono::NaiveTime::from_hms_opt(parts[0], parts[1], 0)
                .map(|v| TimeFormatter(v))
                .ok_or(ParseError),
            3 => chrono::NaiveTime::from_hms_opt(parts[0], parts[1], parts[2])
                .map(|v| TimeFormatter(v))
                .ok_or(ParseError),
            _ => Err(ParseError),
        }
    }
}

impl std::ops::Deref for TimeFormatter {
    type Target = chrono::NaiveTime;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<chrono::NaiveTime> for TimeFormatter {
    fn from(value: chrono::NaiveTime) -> Self {
        Self(value)
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
pub struct WeightFormatter(si::Kilogram<f64>);

impl WeightFormatter {
    #[allow(unused)]
    pub fn format(&self, option: FormatOption) -> String {
        match option {
            FormatOption::Abbreviated => format!("{} kg", self.0.value_unsafe),
            FormatOption::Full => format!("{} kilograms", self.0.value_unsafe),
        }
    }

    #[allow(unused)]
    pub fn parse(s: &str) -> Result<WeightFormatter, ParseError> {
        s.parse::<f64>()
            .map(|w| WeightFormatter(w * si::KG))
            .map_err(|_| ParseError)
    }
}

impl std::ops::Add for WeightFormatter {
    type Output = WeightFormatter;
    fn add(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 + rside.0)
    }
}

impl std::ops::Sub for WeightFormatter {
    type Output = WeightFormatter;
    fn sub(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 - rside.0)
    }
}

impl std::ops::Deref for WeightFormatter {
    type Target = si::Kilogram<f64>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<si::Kilogram<f64>> for WeightFormatter {
    fn from(value: si::Kilogram<f64>) -> Self {
        Self(value)
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
pub struct DistanceFormatter(si::Meter<f64>);

impl DistanceFormatter {
    #[allow(unused)]
    pub fn format(&self, option: FormatOption) -> String {
        match option {
            FormatOption::Abbreviated => format!("{} km", self.0.value_unsafe / 1000.),
            FormatOption::Full => format!("{} kilometers", self.0.value_unsafe / 1000.),
        }
    }

    #[allow(unused)]
    pub fn parse(s: &str) -> Result<DistanceFormatter, ParseError> {
        let value = s.parse::<f64>().map_err(|_| ParseError)?;
        Ok(DistanceFormatter(value * 1000. * si::M))
    }
}

impl std::ops::Add for DistanceFormatter {
    type Output = DistanceFormatter;
    fn add(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 + rside.0)
    }
}

impl std::ops::Sub for DistanceFormatter {
    type Output = DistanceFormatter;
    fn sub(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 - rside.0)
    }
}

impl std::ops::Deref for DistanceFormatter {
    type Target = si::Meter<f64>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<si::Meter<f64>> for DistanceFormatter {
    fn from(value: si::Meter<f64>) -> Self {
        Self(value)
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
pub struct DurationFormatter(si::Second<f64>);

impl DurationFormatter {
    #[allow(unused)]
    pub fn format(&self, option: FormatOption) -> String {
        let (hours, minutes) = self.hours_and_minutes();
        let (h, m) = match option {
            FormatOption::Abbreviated => ("h", "m"),
            FormatOption::Full => (" hours", " minutes"),
        };
        if hours > 0 {
            format!("{}{} {}{}", hours, h, minutes, m)
        } else {
            format!("{}{}", minutes, m)
        }
    }

    #[allow(unused)]
    pub fn parse(s: &str) -> Result<DurationFormatter, ParseError> {
        let value = s.parse::<f64>().map_err(|_| ParseError)?;
        Ok(DurationFormatter(value * 60. * si::S))
    }

    #[allow(unused)]
    fn hours_and_minutes(&self) -> (i64, i64) {
        let minutes: i64 = (self.0.value_unsafe / 60.).round() as i64;
        let hours: i64 = minutes / 60;
        let minutes = minutes - (hours * 60);
        (hours, minutes)
    }
}

impl std::ops::Add for DurationFormatter {
    type Output = DurationFormatter;
    fn add(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 + rside.0)
    }
}

impl std::ops::Sub for DurationFormatter {
    type Output = DurationFormatter;
    fn sub(self, rside: Self) -> Self::Output {
        Self::Output::from(self.0 - rside.0)
    }
}

impl std::ops::Deref for DurationFormatter {
    type Target = si::Second<f64>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<si::Second<f64>> for DurationFormatter {
    fn from(value: si::Second<f64>) -> Self {
        Self(value)
    }
}

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

    #[test]
    fn it_parses_weight_values() {
        assert_eq!(
            WeightFormatter::parse("15.3"),
            Ok(WeightFormatter(15.3 * si::KG))
        );
        assert_eq!(WeightFormatter::parse("15.ab"), Err(ParseError));
    }

    #[test]
    fn it_formats_weight_values() {
        assert_eq!(
            WeightFormatter::from(15.3 * si::KG).format(FormatOption::Abbreviated),
            "15.3 kg"
        );
        assert_eq!(
            WeightFormatter::from(15.3 * si::KG).format(FormatOption::Full),
            "15.3 kilograms"
        );
    }

    #[test]
    fn it_parses_distance_values() {
        assert_eq!(
            DistanceFormatter::parse("70"),
            Ok(DistanceFormatter(70000. * si::M))
        );
        assert_eq!(DistanceFormatter::parse("15.ab"), Err(ParseError));
    }

    #[test]
    fn it_formats_distance_values() {
        assert_eq!(
            DistanceFormatter::from(70000. * si::M).format(FormatOption::Abbreviated),
            "70 km"
        );
        assert_eq!(
            DistanceFormatter::from(70000. * si::M).format(FormatOption::Full),
            "70 kilometers"
        );
    }

    #[test]
    fn it_parses_duration_values() {
        assert_eq!(
            DurationFormatter::parse("70"),
            Ok(DurationFormatter(4200. * si::S))
        );
        assert_eq!(DurationFormatter::parse("15.ab"), Err(ParseError));
    }

    #[test]
    fn it_formats_duration_values() {
        assert_eq!(
            DurationFormatter::from(4200. * si::S).format(FormatOption::Abbreviated),
            "1h 10m"
        );
        assert_eq!(
            DurationFormatter::from(4200. * si::S).format(FormatOption::Full),
            "1 hours 10 minutes"
        );
    }

    #[test]
    fn it_parses_time_values() {
        assert_eq!(
            TimeFormatter::parse("13:25"),
            Ok(TimeFormatter::from(
                chrono::NaiveTime::from_hms_opt(13, 25, 0).unwrap()
            )),
        );
        assert_eq!(
            TimeFormatter::parse("13:25:50"),
            Ok(TimeFormatter::from(
                chrono::NaiveTime::from_hms_opt(13, 25, 50).unwrap()
            )),
        );
    }

    #[test]
    fn it_formats_time_values() {
        let time = TimeFormatter::from(chrono::NaiveTime::from_hms_opt(13, 25, 50).unwrap());
        assert_eq!(time.format(FormatOption::Abbreviated), "13:25".to_owned());
        assert_eq!(time.format(FormatOption::Full), "13:25:50".to_owned());
    }
}
