use glib::translate::*;
use std::boxed::Box as Box_;
use std::mem;

glib_wrapper! {
    #[derive(Debug, PartialOrd, Ord)] // Hash
    pub struct Color(Boxed<ffi::CoglColor>);

    match fn {
        copy => |ptr| ffi::cogl_color_copy(mut_override(ptr)),
        free => |ptr| ffi::cogl_color_free(ptr),
        get_type => || ffi::cogl_color_get_gtype(),
    }
}

impl Color {
    /// Creates a new (empty) color
    ///
    /// # Returns
    ///
    /// a newly-allocated `Color`. Use `Color::free`
    ///  to free the allocated resources
    pub fn new() -> Color {
        unsafe { from_glib_full(ffi::cogl_color_new()) }
    }

    /// Retrieves the alpha channel of `self` as a fixed point
    /// value between 0 and 1.0.
    ///
    /// # Returns
    ///
    /// the alpha channel of the passed color
    pub fn get_alpha(&self) -> f32 {
        unsafe { ffi::cogl_color_get_alpha(self.to_glib_none().0) }
    }

    /// Retrieves the alpha channel of `self` as a byte value
    /// between 0 and 255
    ///
    /// # Returns
    ///
    /// the alpha channel of the passed color
    pub fn get_alpha_byte(&self) -> u8 {
        unsafe { ffi::cogl_color_get_alpha_byte(self.to_glib_none().0) }
    }

    /// Retrieves the alpha channel of `self` as a floating point
    /// value between 0.0 and 1.0
    ///
    /// # Returns
    ///
    /// the alpha channel of the passed color
    pub fn get_alpha_float(&self) -> f32 {
        unsafe { ffi::cogl_color_get_alpha_float(self.to_glib_none().0) }
    }

    /// Retrieves the blue channel of `self` as a fixed point
    /// value between 0 and 1.0.
    ///
    /// # Returns
    ///
    /// the blue channel of the passed color
    pub fn get_blue(&self) -> f32 {
        unsafe { ffi::cogl_color_get_blue(self.to_glib_none().0) }
    }

    /// Retrieves the blue channel of `self` as a byte value
    /// between 0 and 255
    ///
    /// # Returns
    ///
    /// the blue channel of the passed color
    pub fn get_blue_byte(&self) -> u8 {
        unsafe { ffi::cogl_color_get_blue_byte(self.to_glib_none().0) }
    }

    /// Retrieves the blue channel of `self` as a floating point
    /// value between 0.0 and 1.0
    ///
    /// # Returns
    ///
    /// the blue channel of the passed color
    pub fn get_blue_float(&self) -> f32 {
        unsafe { ffi::cogl_color_get_blue_float(self.to_glib_none().0) }
    }

    /// Retrieves the green channel of `self` as a fixed point
    /// value between 0 and 1.0.
    ///
    /// # Returns
    ///
    /// the green channel of the passed color
    pub fn get_green(&self) -> f32 {
        unsafe { ffi::cogl_color_get_green(self.to_glib_none().0) }
    }

    /// Retrieves the green channel of `self` as a byte value
    /// between 0 and 255
    ///
    /// # Returns
    ///
    /// the green channel of the passed color
    pub fn get_green_byte(&self) -> u8 {
        unsafe { ffi::cogl_color_get_green_byte(self.to_glib_none().0) }
    }

    /// Retrieves the green channel of `self` as a floating point
    /// value between 0.0 and 1.0
    ///
    /// # Returns
    ///
    /// the green channel of the passed color
    pub fn get_green_float(&self) -> f32 {
        unsafe { ffi::cogl_color_get_green_float(self.to_glib_none().0) }
    }

    /// Retrieves the red channel of `self` as a fixed point
    /// value between 0 and 1.0.
    ///
    /// # Returns
    ///
    /// the red channel of the passed color
    pub fn get_red(&self) -> f32 {
        unsafe { ffi::cogl_color_get_red(self.to_glib_none().0) }
    }

    /// Retrieves the red channel of `self` as a byte value
    /// between 0 and 255
    ///
    /// # Returns
    ///
    /// the red channel of the passed color
    pub fn get_red_byte(&self) -> u8 {
        unsafe { ffi::cogl_color_get_red_byte(self.to_glib_none().0) }
    }

    /// Retrieves the red channel of `self` as a floating point
    /// value between 0.0 and 1.0
    ///
    /// # Returns
    ///
    /// the red channel of the passed color
    pub fn get_red_float(&self) -> f32 {
        unsafe { ffi::cogl_color_get_red_float(self.to_glib_none().0) }
    }

    /// Sets the values of the passed channels into a `Color`
    /// ## `red`
    /// value of the red channel, between 0 and 1.0
    /// ## `green`
    /// value of the green channel, between 0 and 1.0
    /// ## `blue`
    /// value of the blue channel, between 0 and 1.0
    /// ## `alpha`
    /// value of the alpha channel, between 0 and 1.0
    pub fn init_from_4f(&mut self, red: f32, green: f32, blue: f32, alpha: f32) {
        unsafe {
            ffi::cogl_color_init_from_4f(self.to_glib_none_mut().0, red, green, blue, alpha);
        }
    }

    /// Sets the values of the passed channels into a `Color`
    /// ## `color_array`
    /// a pointer to an array of 4 float color components
    pub fn init_from_4fv(&mut self, color_array: &[f32]) {
        unsafe {
            ffi::cogl_color_init_from_4fv(self.to_glib_none_mut().0, color_array.as_ptr());
        }
    }

    /// Sets the values of the passed channels into a `Color`.
    /// ## `red`
    /// value of the red channel, between 0 and 255
    /// ## `green`
    /// value of the green channel, between 0 and 255
    /// ## `blue`
    /// value of the blue channel, between 0 and 255
    /// ## `alpha`
    /// value of the alpha channel, between 0 and 255
    pub fn init_from_4ub(&mut self, red: u8, green: u8, blue: u8, alpha: u8) {
        unsafe {
            ffi::cogl_color_init_from_4ub(self.to_glib_none_mut().0, red, green, blue, alpha);
        }
    }

    /// Converts a non-premultiplied color to a pre-multiplied color. For
    /// example, semi-transparent red is (1.0, 0, 0, 0.5) when non-premultiplied
    /// and (0.5, 0, 0, 0.5) when premultiplied.
    pub fn premultiply(&mut self) {
        unsafe {
            ffi::cogl_color_premultiply(self.to_glib_none_mut().0);
        }
    }

    /// Sets the alpha channel of `self` to `alpha`.
    /// ## `alpha`
    /// a float value between 0.0f and 1.0f
    pub fn set_alpha(&mut self, alpha: f32) {
        unsafe {
            ffi::cogl_color_set_alpha(self.to_glib_none_mut().0, alpha);
        }
    }

    /// Sets the alpha channel of `self` to `alpha`.
    /// ## `alpha`
    /// a byte value between 0 and 255
    pub fn set_alpha_byte(&mut self, alpha: u8) {
        unsafe {
            ffi::cogl_color_set_alpha_byte(self.to_glib_none_mut().0, alpha);
        }
    }

    /// Sets the alpha channel of `self` to `alpha`.
    /// ## `alpha`
    /// a float value between 0.0f and 1.0f
    pub fn set_alpha_float(&mut self, alpha: f32) {
        unsafe {
            ffi::cogl_color_set_alpha_float(self.to_glib_none_mut().0, alpha);
        }
    }

    /// Sets the blue channel of `self` to `blue`.
    /// ## `blue`
    /// a float value between 0.0f and 1.0f
    pub fn set_blue(&mut self, blue: f32) {
        unsafe {
            ffi::cogl_color_set_blue(self.to_glib_none_mut().0, blue);
        }
    }

    /// Sets the blue channel of `self` to `blue`.
    /// ## `blue`
    /// a byte value between 0 and 255
    pub fn set_blue_byte(&mut self, blue: u8) {
        unsafe {
            ffi::cogl_color_set_blue_byte(self.to_glib_none_mut().0, blue);
        }
    }

    /// Sets the blue channel of `self` to `blue`.
    /// ## `blue`
    /// a float value between 0.0f and 1.0f
    pub fn set_blue_float(&mut self, blue: f32) {
        unsafe {
            ffi::cogl_color_set_blue_float(self.to_glib_none_mut().0, blue);
        }
    }

    /// Sets the green channel of `self` to `green`.
    /// ## `green`
    /// a float value between 0.0f and 1.0f
    pub fn set_green(&mut self, green: f32) {
        unsafe {
            ffi::cogl_color_set_green(self.to_glib_none_mut().0, green);
        }
    }

    /// Sets the green channel of `self` to `green`.
    /// ## `green`
    /// a byte value between 0 and 255
    pub fn set_green_byte(&mut self, green: u8) {
        unsafe {
            ffi::cogl_color_set_green_byte(self.to_glib_none_mut().0, green);
        }
    }

    /// Sets the green channel of `self` to `green`.
    /// ## `green`
    /// a float value between 0.0f and 1.0f
    pub fn set_green_float(&mut self, green: f32) {
        unsafe {
            ffi::cogl_color_set_green_float(self.to_glib_none_mut().0, green);
        }
    }

    /// Sets the red channel of `self` to `red`.
    /// ## `red`
    /// a float value between 0.0f and 1.0f
    pub fn set_red(&mut self, red: f32) {
        unsafe {
            ffi::cogl_color_set_red(self.to_glib_none_mut().0, red);
        }
    }

    /// Sets the red channel of `self` to `red`.
    /// ## `red`
    /// a byte value between 0 and 255
    pub fn set_red_byte(&mut self, red: u8) {
        unsafe {
            ffi::cogl_color_set_red_byte(self.to_glib_none_mut().0, red);
        }
    }

    /// Sets the red channel of `self` to `red`.
    /// ## `red`
    /// a float value between 0.0f and 1.0f
    pub fn set_red_float(&mut self, red: f32) {
        unsafe {
            ffi::cogl_color_set_red_float(self.to_glib_none_mut().0, red);
        }
    }

    /// Converts `self` to the HLS format.
    ///
    /// The `hue` value is in the 0 .. 360 range. The `luminance` and
    /// `saturation` values are in the 0 .. 1 range.
    /// ## `hue`
    /// return location for the hue value or `None`
    /// ## `saturation`
    /// return location for the saturation value or `None`
    /// ## `luminance`
    /// return location for the luminance value or `None`
    pub fn to_hsl(&self) -> (f32, f32, f32) {
        unsafe {
            let mut hue = mem::MaybeUninit::uninit();
            let mut saturation = mem::MaybeUninit::uninit();
            let mut luminance = mem::MaybeUninit::uninit();
            ffi::cogl_color_to_hsl(
                self.to_glib_none().0,
                hue.as_mut_ptr(),
                saturation.as_mut_ptr(),
                luminance.as_mut_ptr(),
            );
            let hue = hue.assume_init();
            let saturation = saturation.assume_init();
            let luminance = luminance.assume_init();
            (hue, saturation, luminance)
        }
    }

    /// Converts a pre-multiplied color to a non-premultiplied color. For
    /// example, semi-transparent red is (0.5, 0, 0, 0.5) when premultiplied
    /// and (1.0, 0, 0, 0.5) when non-premultiplied.
    pub fn unpremultiply(&mut self) {
        unsafe {
            ffi::cogl_color_unpremultiply(self.to_glib_none_mut().0);
        }
    }

    fn equal(v1: &Self, v2: &Self) -> bool {
        let a = Box_::into_raw(Box::new(v1)) as *mut _;
        let b = Box_::into_raw(Box::new(v2)) as *mut _;
        unsafe { ffi::cogl_color_equal(a, b) == crate::TRUE }
    }

    /// Converts a color expressed in HLS (hue, luminance and saturation)
    /// values into a `Color`.
    /// ## `color`
    /// return location for a `Color`
    /// ## `hue`
    /// hue value, in the 0 .. 360 range
    /// ## `saturation`
    /// saturation value, in the 0 .. 1 range
    /// ## `luminance`
    /// luminance value, in the 0 .. 1 range
    pub fn init_from_hsl(hue: f32, saturation: f32, luminance: f32) -> Color {
        unsafe {
            let mut color = Color::uninitialized();
            ffi::cogl_color_init_from_hsl(color.to_glib_none_mut().0, hue, saturation, luminance);
            color
        }
    }
}

#[doc(hidden)]
impl Uninitialized for Color {
    #[inline]
    unsafe fn uninitialized() -> Self {
        mem::zeroed()
    }
}

impl Default for Color {
    fn default() -> Self {
        Self::new()
    }
}

impl PartialEq for Color {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        Color::equal(self, other)
    }
}

impl Eq for Color {}