use num_traits::Float;
use approx::ApproxEq;

use std::ops::{Add, Sub};
use std::marker::PhantomData;
use std::any::TypeId;

use {Alpha, Xyz, Hsv, Limited, Mix, Shade, GetHue, Hue, Saturate, RgbHue, FromColor, IntoColor, clamp, flt};
use white_point::WhitePoint;
use rgb::{Rgb, RgbSpace, Linear};
use rgb::standards::Srgb;

///Linear HSL with an alpha component. See the [`Hsla` implementation in `Alpha`](struct.Alpha.html#Hsla).
pub type Hsla<S = Srgb, T = f32> = Alpha<Hsl<S, T>, T>;

///Linear HSL color space.
///
///The HSL color space can be seen as a cylindrical version of
///[RGB](rgb/struct.LinRgb.html), where the `hue` is the angle around the color
///cylinder, the `saturation` is the distance from the center, and the
///`lightness` is the height from the bottom. Its composition makes it
///especially good for operations like changing green to red, making a color
///more gray, or making it darker.
///
///See [HSV](struct.Hsv.html) for a very similar color space, with brightness instead of lightness.
#[derive(Debug, PartialEq)]
pub struct Hsl<S = Srgb, T = f32>
    where T: Float,
        S: RgbSpace
{
    ///The hue of the color, in degrees. Decides if it's red, blue, purple,
    ///etc.
    pub hue: RgbHue<T>,

    ///The colorfulness of the color. 0.0 gives gray scale colors and 1.0 will
    ///give absolutely clear colors.
    pub saturation: T,

    ///Decides how light the color will look. 0.0 will be black, 0.5 will give
    ///a clear color, and 1.0 will give white.
    pub lightness: T,

    ///The white point and RGB primaries this color is adapted to. The default
    ///is the sRGB standard.
    pub space: PhantomData<S>,

}

impl<S, T> Copy for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{}

impl<S, T> Clone for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    fn clone(&self) -> Hsl<S, T> { *self }
}


impl<T> Hsl<Srgb, T>
    where T: Float,
{
    ///HSL for linear sRGB.
    pub fn new(hue: RgbHue<T>, saturation: T, lightness: T) -> Hsl<Srgb, T> {
        Hsl {
            hue: hue,
            saturation: saturation,
            lightness: lightness,
            space: PhantomData,
        }
    }
}

impl<S, T> Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    ///Linear HSL.
    pub fn with_wp(hue: RgbHue<T>, saturation: T, lightness: T) -> Hsl<S, T> {
        Hsl {
            hue: hue,
            saturation: saturation,
            lightness: lightness,
            space: PhantomData,
        }
    }

    #[inline]
    fn reinterpret_as<Sp: RgbSpace>(self) -> Hsl<Sp, T> {
        Hsl {
            hue: self.hue,
            saturation: self.saturation,
            lightness: self.lightness,
            space: PhantomData,
        }
    }
}

///<span id="Hsla"></span>[`Hsla`](type.Hsla.html) implementations.
impl<T> Alpha<Hsl<Srgb, T>, T>
    where T: Float,
{
    ///HSL and transparency for linear sRGB.
    pub fn new(hue: RgbHue<T>, saturation: T, lightness: T, alpha: T) -> Hsla<Srgb, T> {
        Alpha {
            color: Hsl::new(hue, saturation, lightness),
            alpha: alpha,
        }
    }
}

///<span id="Hsla"></span>[`Hsla`](type.Hsla.html) implementations.
impl<S, T> Alpha<Hsl<S, T>, T>
    where T: Float,
        S: RgbSpace
{
    ///Linear HSL and transparency.
    pub fn with_wp(hue: RgbHue<T>, saturation: T, lightness: T, alpha: T) -> Hsla<S, T> {
        Alpha {
            color: Hsl::with_wp(hue, saturation, lightness),
            alpha: alpha,
        }
    }
}

impl<S, Wp, T> FromColor<Wp, T> for Hsl<S, T>
    where T: Float,
        S: RgbSpace<WhitePoint=Wp>,
        Wp: WhitePoint,
{
    fn from_xyz(xyz: Xyz<Wp, T>) -> Self {
        let rgb: Rgb<Linear<S>, T> = xyz.into_rgb();
        Self::from_rgb(rgb)
    }

    fn from_rgb<Sp: RgbSpace<WhitePoint=Wp>>(rgb: Rgb<Linear<Sp>, T>) -> Self {
        let rgb = Rgb::<Linear<S>, T>::from_rgb(rgb);

        let ( max, min, sep , coeff) = {
            let (max, min , sep, coeff) = if rgb.red > rgb.green {
                (rgb.red, rgb.green, rgb.green - rgb.blue, T::zero() )
            } else {
                (rgb.green, rgb.red, rgb.blue - rgb.red , flt(2.0))
            };
            if rgb.blue > max {
                ( rgb.blue, min , rgb.red - rgb.green , flt(4.0))
            } else {
                let min_val = if rgb.blue < min { rgb.blue } else { min };
                (max , min_val , sep, coeff)
            }
        };

        let mut h = T::zero();
        let mut s = T::zero();

        let sum = max + min;
        let l = sum / flt(2.0);
        if max != min {
            let d = max - min;
            s = if sum > T::one() { d /( flt::<T,_>(2.0) - sum) } else { d / sum };
            h = (( sep / d ) + coeff) *  flt(60.0);
        };

        Hsl {
            hue: h.into(),
            saturation: s,
            lightness: l,
            space: PhantomData,
        }
    }

    fn from_hsl<Sp: RgbSpace<WhitePoint=Wp>>(hsl: Hsl<Sp, T>) -> Self {
        if TypeId::of::<Sp::Primaries>() == TypeId::of::<S::Primaries>() {
            hsl.reinterpret_as()
        } else {
            Self::from_rgb(Rgb::<Linear<Sp>, T>::from_hsl(hsl))
        }
    }

    fn from_hsv<Sp: RgbSpace<WhitePoint=Wp>>(hsv: Hsv<Sp, T>) -> Self {
        let hsv = Hsv::<S, T>::from_hsv(hsv);

        let x = (flt::<T,_>(2.0) - hsv.saturation) * hsv.value;
        let saturation = if !hsv.value.is_normal() {
            T::zero()
        } else if x < T::one() {
            if x.is_normal() { hsv.saturation * hsv.value / x } else { T::zero() }
        } else {
            let denom = flt::<T,_>(2.0) - x;
            if denom.is_normal() { hsv.saturation * hsv.value / denom } else { T::zero() }
        };

        Hsl {
            hue: hsv.hue,
            saturation: saturation,
            lightness: x / flt(2.0),
            space: PhantomData,
        }
    }

}

impl<S, T> Limited for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    fn is_valid(&self) -> bool {
        self.saturation >= T::zero() && self.saturation <= T::one() &&
        self.lightness >= T::zero() && self.lightness <= T::one()
    }

    fn clamp(&self) -> Hsl<S, T> {
        let mut c = *self;
        c.clamp_self();
        c
    }

    fn clamp_self(&mut self) {
        self.saturation = clamp(self.saturation, T::zero(), T::one());
        self.lightness = clamp(self.lightness, T::zero(), T::one());
    }
}

impl<S, T> Mix for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Scalar = T;

    fn mix(&self, other: &Hsl<S, T>, factor: T) -> Hsl<S, T> {
        let factor = clamp(factor, T::zero(), T::one());
        let hue_diff: T = (other.hue - self.hue).to_degrees();

        Hsl {
            hue: self.hue + factor * hue_diff,
            saturation: self.saturation + factor * (other.saturation - self.saturation),
            lightness: self.lightness + factor * (other.lightness - self.lightness),
            space: PhantomData,
        }
    }
}

impl<S, T> Shade for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Scalar = T;

    fn lighten(&self, amount: T) -> Hsl<S, T> {
        Hsl {
            hue: self.hue,
            saturation: self.saturation,
            lightness: self.lightness + amount,
            space: PhantomData,
        }
    }
}

impl<S, T> GetHue for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Hue = RgbHue<T>;

    fn get_hue(&self) -> Option<RgbHue<T>> {
        if self.saturation <= T::zero() {
            None
        } else {
            Some(self.hue)
        }
    }
}

impl<S, T> Hue for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    fn with_hue(&self, hue: RgbHue<T>) -> Hsl<S, T> {
        Hsl {
            hue: hue,
            saturation: self.saturation,
            lightness: self.lightness,
            space: PhantomData,
        }
    }

    fn shift_hue(&self, amount: RgbHue<T>) -> Hsl<S, T> {
        Hsl {
            hue: self.hue + amount,
            saturation: self.saturation,
            lightness: self.lightness,
            space: PhantomData,
        }
    }
}

impl<S, T> Saturate for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Scalar = T;

    fn saturate(&self, factor: T) -> Hsl<S, T> {
        Hsl {
            hue: self.hue,
            saturation: self.saturation * (T::one() + factor),
            lightness: self.lightness,
            space: PhantomData,
        }
    }
}

impl<S, T> Default for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    fn default() -> Hsl<S, T> {
        Hsl::with_wp(RgbHue::from(T::zero()), T::zero(), T::zero())
    }
}

impl<S, T> Add<Hsl<S, T>> for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Output = Hsl<S, T>;

    fn add(self, other: Hsl<S, T>) -> Hsl<S, T> {
        Hsl {
            hue: self.hue + other.hue,
            saturation: self.saturation + other.saturation,
            lightness: self.lightness + other.lightness,
            space: PhantomData,
        }
    }
}

impl<S, T> Add<T> for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Output = Hsl<S, T>;

    fn add(self, c: T) -> Hsl<S, T> {
        Hsl {
            hue: self.hue + c,
            saturation: self.saturation + c,
            lightness: self.lightness + c,
            space: PhantomData,
        }
    }
}

impl<S, T> Sub<Hsl<S, T>> for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Output = Hsl<S, T>;

    fn sub(self, other: Hsl<S, T>) -> Hsl<S, T> {
        Hsl {
            hue: self.hue - other.hue,
            saturation: self.saturation - other.saturation,
            lightness: self.lightness - other.lightness,
            space: PhantomData,
        }
    }
}

impl<S, T> Sub<T> for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    type Output = Hsl<S, T>;

    fn sub(self, c: T) -> Hsl<S, T> {
        Hsl {
            hue: self.hue - c,
            saturation: self.saturation - c,
            lightness: self.lightness - c,
            space: PhantomData,
        }
    }
}

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Hsl<S, T>
    where T: Float,
        S: RgbSpace
{
    fn from(color: Alpha<Hsl<S, T>, T>) -> Hsl<S, T> {
        color.color
    }
}

impl<S, T> ApproxEq for Hsl<S, T>
    where T: Float + ApproxEq,
        T::Epsilon: Copy + Float,
        S: RgbSpace,
{
    type Epsilon = <T as ApproxEq>::Epsilon;

    fn default_epsilon() -> Self::Epsilon {
        T::default_epsilon()
    }
    fn default_max_relative() -> Self::Epsilon {
        T::default_max_relative()
    }
    fn default_max_ulps() -> u32 {
        T::default_max_ulps()
    }
    fn relative_eq(&self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon) -> bool {
        self.hue.relative_eq(&other.hue, epsilon, max_relative) &&
        self.saturation.relative_eq(&other.saturation, epsilon, max_relative) &&
        self.lightness.relative_eq(&other.lightness, epsilon, max_relative)
    }

    fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool{
        self.hue.ulps_eq(&other.hue, epsilon, max_ulps) &&
        self.saturation.ulps_eq(&other.saturation, epsilon, max_ulps) &&
        self.lightness.ulps_eq(&other.lightness, epsilon, max_ulps)
    }
}

#[cfg(test)]
mod test {
    use super::Hsl;
    use {LinSrgb, Hsv};
    use rgb::standards::Srgb;

    #[test]
    fn red() {
        let a = Hsl::from(LinSrgb::new(1.0, 0.0, 0.0));
        let b = Hsl::new(0.0.into(), 1.0, 0.5);
        let c = Hsl::from(Hsv::new(0.0.into(), 1.0, 1.0));

        assert_relative_eq!(a, b);
        assert_relative_eq!(a, c);

    }

    #[test]
    fn orange() {
        let a = Hsl::from(LinSrgb::new(1.0, 0.5, 0.0));
        let b = Hsl::new(30.0.into(), 1.0, 0.5);
        let c = Hsl::from(Hsv::new(30.0.into(), 1.0, 1.0));

        assert_relative_eq!(a, b);
        assert_relative_eq!(a, c);
    }

    #[test]
    fn green() {
        let a = Hsl::from(LinSrgb::new(0.0, 1.0, 0.0));
        let b = Hsl::new(120.0.into(), 1.0, 0.5);
        let c = Hsl::from(Hsv::new(120.0.into(), 1.0, 1.0));

        assert_relative_eq!(a, b);
        assert_relative_eq!(a, c);
    }

    #[test]
    fn blue() {
        let a = Hsl::from(LinSrgb::new(0.0, 0.0, 1.0));
        let b = Hsl::new(240.0.into(), 1.0, 0.5);
        let c = Hsl::from(Hsv::new(240.0.into(), 1.0, 1.0));

        assert_relative_eq!(a, b);
        assert_relative_eq!(a, c);
    }

    #[test]
    fn purple() {
        let a = Hsl::from(LinSrgb::new(0.5, 0.0, 1.0));
        let b = Hsl::new(270.0.into(), 1.0, 0.5);
        let c = Hsl::from(Hsv::new(270.0.into(), 1.0, 1.0));

        assert_relative_eq!(a, b);
        assert_relative_eq!(a, c);
    }

    #[test]
    fn ranges() {
        assert_ranges!{
            Hsl<Srgb, f64>;
            limited {
                saturation: 0.0 => 1.0,
                lightness: 0.0 => 1.0
            }
            limited_min {}
            unlimited {
                hue: -360.0 => 360.0
            }
        }
    }
}