use num_traits::{clamp, Signed, Zero};
use std::ops::Rem;

#[derive(Copy, Clone, Debug)]
/// Main color structure, holds RGBA but can be constructed
/// using other color spaces.
pub struct Color {
    /// Red value of the color in the range [0.0, 1.0].
    pub r: f32,
    /// Green value of the color in the range [0.0, 1.0].
    pub g: f32,
    /// Blue value of the color in the range [0.0, 1.0].
    pub b: f32,
    /// Alpha value of the color in the range [0.0, 1.0].
    pub a: f32,
}

impl Color {
    /// Shorthand to create a new RGBA color value. Clamps
    /// values to their respective ranges.
    pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
        let r = clamp(r, 0.0, 1.0);
        let g = clamp(g, 0.0, 1.0);
        let b = clamp(b, 0.0, 1.0);
        let a = clamp(a, 0.0, 1.0);

        Self { r, g, b, a }
    }

    /// Construct a color from an 8-digit hexidecimal color
    /// code.
    ///
    /// # Examples
    ///
    /// Basic usage:
    /// ```no_run
    /// use courgette::RGB;
    ///
    /// // FF at the end represents 1.0 alpha.
    /// let red = RGB::hex(0xFF0000FF);
    /// let yellow = RGB::hex(0xFFFF00FF);
    /// let green = RGB::hex(0x00FF00FF);
    /// let cyan = RGB::hex(0x00FFFFFF);
    /// let blue = RGB::hex(0x0000FFFF);
    /// let magenta = RGB::hex(0xFF00FFFF);
    /// ```
    pub fn hex(hex: u32) -> Self {
        Self::new(
            ((hex & 0xFF000000) >> 24) as f32 / 255.0,
            ((hex & 0x00FF0000) >> 16) as f32 / 255.0,
            ((hex & 0x0000FF00) >> 8) as f32 / 255.0,
            (hex & 0x000000FF) as f32 / 255.0,
        )
    }

    /// Construct a color from a 6-digit hexidecimal color
    /// code.
    pub fn hex_rgb(hex: u32) -> Self {
        Self::new(
            ((hex & 0xFF0000) >> 16) as f32 / 255.0,
            ((hex & 0x00FF00) >> 8) as f32 / 255.0,
            (hex & 0x0000FF) as f32 / 255.0,
            1.0,
        )
    }

    /// Construct a color from HSLA values. Applies modulo
    /// 360 to hue.
    pub fn hsla(h: f32, s: f32, l: f32, a: f32) -> Self {
        // https://en.wikipedia.org/wiki/HSL_and_HSV#Alternative_HSL_to_RGB
        //
        // Replace `a` with `x` so it doesn't inerfere with alpha.
        let h = modulo(h, 360.0);

        let x = s * l.min(1.0 - l);
        let f = |n: f32| {
            let k = modulo(n + h / 30.0, 12.0);
            l - x * (k - 3.0).min(9.0 - k).min(1.0).max(-1.0)
        };

        Self::new(f(0.0), f(8.0), f(4.0), a)
    }

    /// Construct a color from HSL values. Calls
    /// `Color::hsla` with alpha of 1.0.
    pub fn hsl(h: f32, s: f32, l: f32) -> Self {
        Self::hsla(h, s, l, 1.0)
    }

    /// Construct a color from HSVA values. Applies modulo
    /// 360 to hue.
    pub fn hsva(h: f32, s: f32, v: f32, a: f32) -> Self {
        // https://en.wikipedia.org/wiki/HSL_and_HSV#Alternative_HSL_to_RGB
        //
        // Replace `a` with `x` so it doesn't inerfere with alpha.
        let h = modulo(h, 360.0);

        let f = |n: f32| {
            let k = modulo(n + h / 60.0, 6.0);
            v - v * s * k.min(4.0 - k).min(1.0).max(0.0)
        };

        Self::new(f(5.0), f(3.0), f(1.0), a)

    }

    /// Construct a color from HSV values. Calls
    /// `Color::hsva` with alpha of 1.0.
    pub fn hsv(h: f32, s: f32, v: f32) -> Self {
        Self::hsva(h, s, v, 1.0)
    }

    /// Construct a color from HSBA values. HSB is
    /// equivelant to HSV, therefore this simply calls
    /// `Color::hsva`.
    pub fn hsba(h: f32, s: f32, b: f32, a: f32) -> Self {
        Self::hsva(h, s, b, a)
    }

    /// Construct a color from HSB values. Calls
    /// `Color::hsba` with alpha of 1.0.
    pub fn hsb(h: f32, s: f32, b: f32) -> Self {
        Self::hsva(h, s, b, 1.0)
    }

    /// Change the brightness of the current color, with a
    /// percent of 1.0 being normal brightness.
    ///
    /// # Examples
    ///
    /// Basic usage:
    /// ```no_run
    /// use courgette::Color;
    ///
    /// let color = Color::hex(0xff4488ff);
    ///
    /// let brighter = color.brightness(1.1); // Lighten color by 10%.
    /// let darker = color.brightness(0.9); // Dark color by 10%.
    /// ```
    pub fn brightness(self, percent: f32) -> Self {
        let a = self.a;
        let (h, s, _) = self.get_hsv();

        Self::hsva(h, s, percent, a)
    }

    /// Invert the current color.
    pub fn invert(self) -> Self {
        let Self { r, g, b, a } = self;

        Self::new(1.0 - r, 1.0 - g, 1.0 - b, a)
    }

    /// Get greyscale version of the color.
    pub fn grey(self) -> Self {
        let mean = (self.r + self.g + self.b) / 3.0;

        Self::new(mean, mean, mean, self.a)
    }

    /// Get hue shifted color of the current color. Hue
    /// value has a modulo of 360.0 applied.
    pub fn hue(self, hue: f32) -> Self {
        let hue = modulo(hue, 360.0);

        let a = self.a;
        let (_, s, v) = self.get_hsv();

        Self::hsla(hue, s, v, a)
    }

    /// Hue shift the current color. Changes hue by `dhue`
    /// (delta hue) value.
    pub fn hue_shift(self, dhue: f32) -> Self {
        let (h, _, _) = self.get_hsv();

        self.hue(h + dhue)
    }

    fn get_hsv(self) -> (f32, f32, f32) {
        // https://en.wikipedia.org/wiki/HSL_and_HSV#RGB_to_HSL_and_HSV
        let Self { r, g, b, .. } = self;

        let max = r.max(g.max(b));
        let min = r.min(g.min(b));

        let delta = max - min;

        let h = match max {
            m if m == r => 60.0 * ((g - b) / delta),
            m if m == g => 60.0 * (2.0 + (b - r) / delta),
            m if m == b => 60.0 * (4.0 + (r - g) / delta),
            _ => 0.0,
        };

        let h = if h < 0.0 { h + 360.0 } else { h };
        let s = if max == 0.0 { 0.0 } else { delta / max };
        let v = max;

        (h, s, v)
    }

}

impl Into<[f32; 4]> for Color {
    fn into(self) -> [f32; 4] {
        let Self { r, g, b, a } = self;

        [r, g, b, a]
    }
}

impl Into<[f32; 3]> for Color {
    fn into(self) -> [f32; 3] {
        let Self { r, g, b, .. } = self;

        [r, g, b]
    }
}

fn modulo<T>(num: T, det: T) -> T
where
    T: Rem<Output = T>,
    T: PartialOrd,
    T: Zero,
    T: Signed,
    T: Copy,
{
    let num = num % det;
    if num < T::zero() {
        num + det.abs()
    } else {
        num
    }
}