use std::fmt;

pub trait Angle<T> {
    /// Converts the given angle to degrees
    fn to_degrees(&self) -> Degrees<T>;

    /// Converts the given angle to radians
    fn to_radians(&self) -> Radians<T>;
}

/// Represents an angle in degrees
#[derive(Debug, Clone, Copy)]
pub struct Degrees<T> {
    pub degrees: T,
}

impl<T: fmt::Display> fmt::Display for Degrees<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.degrees.fmt(f)?;
        write!(f, "°")
    }
}

impl From<f64> for Degrees<f64> {
    fn from(degrees: f64) -> Self {
        Self { degrees }
    }
}

impl Angle<f64> for Degrees<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        *self
    }

    fn to_radians(&self) -> Radians<f64> {
        Radians::from(self.degrees * std::f64::consts::PI / 180.0)
    }
}

/// Represents an angle in minutes of arc
#[derive(Debug, Clone, Copy)]
pub struct ArcMinutes<T> {
    pub minutes: T,
}

impl<T: fmt::Display> fmt::Display for ArcMinutes<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.minutes.fmt(f)?;
        write!(f, "’")
    }
}

impl From<f64> for ArcMinutes<f64> {
    fn from(minutes: f64) -> Self {
        Self { minutes }
    }
}

impl Angle<f64> for ArcMinutes<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        Degrees::from(self.minutes / 60.0)
    }

    fn to_radians(&self) -> Radians<f64> {
        Radians::from(self.minutes * std::f64::consts::PI / 10800.0)
    }
}

/// Represents an angle in seconds of arc
#[derive(Debug, Clone, Copy)]
pub struct ArcSeconds<T> {
    pub seconds: T,
}

impl<T: fmt::Display> fmt::Display for ArcSeconds<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.seconds.fmt(f)?;
        write!(f, "”")
    }
}

impl From<f64> for ArcSeconds<f64> {
    fn from(seconds: f64) -> Self {
        Self { seconds }
    }
}

impl Angle<f64> for ArcSeconds<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        Degrees::from(self.seconds / 3600.0)
    }

    fn to_radians(&self) -> Radians<f64> {
        Radians::from(self.seconds * std::f64::consts::PI / 648000.0)
    }
}

/// Represents an angle in radians
#[derive(Debug, Clone, Copy)]
pub struct Radians<T> {
    pub radians: T,
}

impl From<f64> for Radians<f64> {
    fn from(radians: f64) -> Self {
        Self { radians }
    }
}

impl Angle<f64> for Radians<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        Degrees::from(self.radians * 180.0 * std::f64::consts::FRAC_1_PI)
    }

    fn to_radians(&self) -> Radians<f64> {
        *self
    }

    // fn to_degrees_minutes_seconds(self) -> DMS<f64> {
    //     todo!()
    // }
}

/// Represents an angle in degrees, minutes and seconds
#[derive(Clone, Copy, Debug)]
pub struct Dms<T> {
    pub degrees: Degrees<T>,
    pub minutes: ArcMinutes<T>,
    pub seconds: ArcSeconds<T>,
}

impl Dms<f64> {
    pub fn new(degrees: f64, minutes: f64, seconds: f64) -> Self {
        Self {
            degrees: Degrees::from(degrees),
            minutes: ArcMinutes::from(minutes),
            seconds: ArcSeconds::from(seconds),
        }
    }
}

impl Angle<f64> for Dms<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        Degrees::from(
            self.degrees.degrees
                + self.minutes.to_degrees().degrees
                + self.seconds.to_degrees().degrees,
        )
    }

    fn to_radians(&self) -> Radians<f64> {
        self.to_degrees().to_radians()
    }
}

impl<T: fmt::Display> fmt::Display for Dms<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}{}{}", self.degrees, self.minutes, self.seconds)
    }
}

/// Represents an angle in hours, minutes and seconds. Note that 1 hours is equal to 15 degrees.
#[derive(Clone, Copy, Debug)]
pub struct Hms<T> {
    pub hours: T,
    pub minutes: T,
    pub seconds: T,
}

impl Angle<f64> for Hms<f64> {
    fn to_degrees(&self) -> Degrees<f64> {
        let total_hours = self.hours + self.minutes / 60.0 + self.seconds / 3600.0;
        Degrees::from(total_hours * 15.0)
    }

    fn to_radians(&self) -> Radians<f64> {
        self.to_degrees().to_radians()
    }
}

impl<T: fmt::Display> fmt::Display for Hms<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}h{}m{}s", self.hours, self.minutes, self.seconds)
    }
}

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

    #[test]
    fn hms_test() {
        let value = Hms {
            hours: 9.0,
            minutes: 14.0,
            seconds: 55.8,
        };
        assert_eq!(value.to_string(), "9h14m55.8s");
        crate::assert_approx_equal(value.to_radians().radians.tan(), -0.877517);
    }

    #[test]
    fn dms_test() {
        let value = Dms::new(8.0, 5.0, 9.0);
        assert_eq!(value.to_string(), "8°5’9”");
    }
}