use color::{Rgb, Rgba, ToRgb, ToRgba};
use super::{texture::TextureSampler, AlphaType};
use rin::util::{Result, Error};
use std::cell::UnsafeCell;
use rin::math::{Deg, Rad, Vec2, Vec3, Vec4};

#[derive(Debug)]
pub enum ParameterValue<'a>{
    Float(&'a mut f32),
    Int(&'a mut i32),
    Bool(&'a mut bool),
    Vec2(&'a mut Vec2),
    Vec3(&'a mut Vec3),
    Vec4(&'a mut Vec4),
    Rgb(&'a mut Rgb<f32>),
    Rgba(&'a mut Rgba<f32>),
    Texture(&'a mut TextureSampler),
    AlphaType(&'a mut AlphaType),
    Rad(&'a mut Rad<f32>),
    Deg(&'a mut Deg<f32>),
}


#[derive(Debug)]
pub struct Parameter<'a>{
    name: &'static str,
    value: ParameterValue<'a>,
    any_changed: &'a mut bool,
}

pub trait IntoParameterValue{
    fn into_parameter_value(&mut self) -> ParameterValue;
}

impl IntoParameterValue for f32{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Float(self)
    }
}

impl IntoParameterValue for i32{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Int(self)
    }
}

impl IntoParameterValue for bool{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Bool(self)
    }
}

impl IntoParameterValue for Vec2{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Vec2(self)
    }
}

impl IntoParameterValue for Vec3{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Vec3(self)
    }
}


impl IntoParameterValue for Vec4{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Vec4(self)
    }
}


impl IntoParameterValue for Rgb<f32>{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Rgb(self)
    }
}

impl IntoParameterValue for Rgba<f32>{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Rgba(self)
    }
}

impl IntoParameterValue for TextureSampler{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Texture(self)
    }
}

impl IntoParameterValue for AlphaType{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::AlphaType(self)
    }
}

impl IntoParameterValue for Rad<f32>{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Rad(self)
    }
}

impl IntoParameterValue for Deg<f32>{
    fn into_parameter_value(&mut self) -> ParameterValue{
        ParameterValue::Deg(self)
    }
}

impl<'a> Parameter<'a>{
    pub fn new<V: IntoParameterValue>(name: &'static str, value: &'a mut V, any_changed: &'a Changed) -> Parameter<'a> {
        Parameter{
            name,
            value: value.into_parameter_value(),
            any_changed: unsafe{ &mut *any_changed.changed.get() },
        }
    }

    pub fn name(&self) -> &str{
        &self.name
    }

    pub fn float(&self) -> Option<f32>{
        match &self.value{
            ParameterValue::Float(f) => Some(**f),
            _ => None,
        }
    }

    pub fn int(&self) -> Option<i32>{
        match &self.value{
            ParameterValue::Int(f) => Some(**f),
            _ => None,
        }
    }

    pub fn boolean(&self) -> Option<bool>{
        match &self.value{
            ParameterValue::Bool(f) => Some(**f),
            _ => None,
        }
    }

    pub fn vec2(&self) -> Option<Vec2>{
        match &self.value{
            ParameterValue::Vec2(f) => Some(**f),
            _ => None,
        }
    }

    pub fn vec3(&self) -> Option<Vec3>{
        match &self.value{
            ParameterValue::Vec3(f) => Some(**f),
            _ => None,
        }
    }

    pub fn vec4(&self) -> Option<Vec4>{
        match &self.value{
            ParameterValue::Vec4(f) => Some(**f),
            _ => None,
        }
    }

    pub fn rgb(&self) -> Option<Rgb<f32>>{
        match &self.value{
            ParameterValue::Rgb(f) => Some(**f),
            _ => None,
        }
    }

    pub fn rgba(&self) -> Option<Rgba<f32>>{
        match &self.value{
            ParameterValue::Rgba(f) => Some(**f),
            _ => None,
        }
    }

    pub fn texture(&self) -> Option<TextureSampler>{
        match &self.value{
            ParameterValue::Texture(f) => Some(**f),
            _ => None,
        }
    }

    pub fn alpha_type(&self) -> Option<AlphaType>{
        match &self.value{
            ParameterValue::AlphaType(f) => Some(**f),
            _ => None,
        }
    }

    pub fn set_float(&mut self, v: f32) -> Result<()>{
        match &mut self.value{
            ParameterValue::Float(f) => {
                **f = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_int(&mut self, v: i32) -> Result<()>{
        match &mut self.value{
            ParameterValue::Int(i) => {
                **i = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_bool(&mut self, v: bool) -> Result<()>{
        match &mut self.value{
            ParameterValue::Bool(b) => {
                **b = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_vec2(&mut self, v: Vec2) -> Result<()>{
        match &mut self.value{
            ParameterValue::Vec2(f) => {
                **f = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_vec3(&mut self, v: Vec3) -> Result<()>{
        match &mut self.value{
            ParameterValue::Vec3(f) => {
                **f = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_vec4(&mut self, v: Vec4) -> Result<()>{
        match &mut self.value{
            ParameterValue::Vec4(f) => {
                **f = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_rgb<C: ToRgb>(&mut self, v: C) -> Result<()>{
        match &mut self.value{
            ParameterValue::Rgb(c) => {
                **c = v.to_rgb();
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_rgba<C: ToRgba>(&mut self, v: C) -> Result<()>{
        match &mut self.value{
            ParameterValue::Rgba(c) => {
                **c = v.to_rgba();
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_color<C: ToRgba + ToRgb>(&mut self, v: C) -> Result<()>{
        match &mut self.value{
            ParameterValue::Rgba(c) => {
                **c = v.to_rgba();
                *self.any_changed = true;
                Ok(())
            }
            ParameterValue::Rgb(c) => {
                **c = v.to_rgb();
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_texture<T: Into<TextureSampler>>(&mut self, v: T) -> Result<()>{
        match &mut self.value{
            ParameterValue::Texture(t) => {
                **t = v.into();
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_alpha_type(&mut self, v: AlphaType) -> Result<()>{
        match &mut self.value{
            ParameterValue::AlphaType(a) => {
                **a = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_radians(&mut self, v: Rad<f32>) -> Result<()>{
        match &mut self.value{
            ParameterValue::Rad(a) => {
                **a = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }

    pub fn set_degrees(&mut self, v: Deg<f32>) -> Result<()>{
        match &mut self.value{
            ParameterValue::Deg(a) => {
                **a = v;
                *self.any_changed = true;
                Ok(())
            }
            _ => Err(Error::new("Wrong type")),
        }
    }
}

#[derive(Debug)]
pub struct Changed{
    changed: UnsafeCell<bool>
}

impl Changed{
    pub fn changed(&self) -> bool{
        unsafe{ *self.changed.get() }
    }

    pub fn reset(&mut self){
        unsafe{ *self.changed.get() = false };
    }
}

impl Default for Changed{
    fn default() -> Changed{
        Changed{
            changed: UnsafeCell::new(true)
        }
    }
}