use rin_material::{BasicMaterial, Property};
use super::{
    into_gl_property, MaterialTransparency, ProgramSettings, Shader, PropertyChanged
};
use rin_gl as gl;

impl super::Material for BasicMaterial{
    fn properties(&self) -> PropertyChanged<Vec<glin::Property>>{
        if self.properties.has_changed(){
            let properties = self.properties.iter()
                .flat_map(|p| if let Property::PointSize(point_size) = p {
                        #[cfg(not(any(feature="gles", feature="webgl")))]
                        let props = vec![
                            glin::Property::ProgramPointSize(true),
                            glin::Property::PointSize(*point_size)
                        ];

                        #[cfg(any(feature="gles", feature="webgl"))]
                        let props = vec![];

                        props
                    }else{
                        vec![
                            into_gl_property(p)
                        ]
                    }).collect();
            PropertyChanged::New(properties)
        }else{
            PropertyChanged::Old
        }
    }

    fn transparency(&self) -> PropertyChanged<MaterialTransparency>{
        if self.alpha_type.has_changed() || self.base_color.has_changed() {
            PropertyChanged::New(MaterialTransparency{
                alpha_type: *self.alpha_type,
                is_translucent: if let Some(alpha) = self.base_color.get().map(|c| c.a){
                    alpha > 0. && alpha < 1.
                }else{
                    false
                },
                is_visible: if let Some(alpha) = self.base_color.get().map(|c| c.a){
                    alpha > 0.
                }else{
                    true
                },
                priority: None,
            })
        }else{
            PropertyChanged::Old
        }
    }

    fn shaders(&self) -> PropertyChanged<Vec<Shader>>{
        PropertyChanged::Always(vec![
            gl::vertex_shader!("shaders/basic_material.vs.glsl"),
            gl::fragment_shader!("shaders/basic_material.fs.glsl")
        ])
    }

    fn program_settings(&self) -> PropertyChanged<ProgramSettings>{
        let get_point_size = || {
            self.properties.iter()
                .filter_map(|p| if let Property::PointSize(size) = p {
                    Some(size)
                }else{
                    None
                }).next()
        };
        let point_size_changed = if self.properties.has_changed() {
            get_point_size()
        }else{
            None
        };
        if self.base_color.option_changed() || self.texture.option_changed() || point_size_changed.is_some() {
            let use_global_color = (self.base_color.is_some() as u8).to_string();
            let use_texture = (self.texture.is_some() as u8).to_string();
            let point_size = if point_size_changed.is_none(){
                get_point_size()
            }else{
                point_size_changed
            };
            let debug_texcoords = (*self.debug_texcoords.get() as u8).to_string();
            let debug_normals = (*self.debug_normals.get() as u8).to_string();
            if *self.debug_texcoords.get() && *self.debug_normals.get() {
                panic!("Debug normals and debug texcoords can't be true simulataneously")
            }
            let output_linear_colors = (*self.output_linear_colors.get() as u8).to_string();
            if let Some(point_size) = point_size {
                let point_size = point_size.to_string();
                PropertyChanged::New(ProgramSettings{
                    defines: vec![
                        ("USE_GLOBAL_COLOR".to_owned(),         use_global_color),
                        ("HAS_COLOR_TEXTURE".to_owned(),        use_texture),
                        ("USE_BGR".to_owned(),                  "0".to_owned()),
                        ("POINT_SIZE".to_owned(),               point_size),
                        ("DEBUG_TEXCOORDS".to_owned(),          debug_texcoords),
                        ("DEBUG_NORMALS".to_owned(),            debug_normals),
                        ("MANUAL_SRGB".to_owned(),              output_linear_colors),
                        ("SRGB_FAST_APPROXIMATION".to_owned(),  "1".to_owned()),
                    ],
                    .. Default::default()
                })
            }else{
                PropertyChanged::New(ProgramSettings{
                    defines: vec![
                        ("USE_GLOBAL_COLOR".to_owned(),        use_global_color),
                        ("HAS_COLOR_TEXTURE".to_owned(),       use_texture),
                        ("USE_BGR".to_owned(),                 "0".to_owned()),
                        ("DEBUG_TEXCOORDS".to_owned(),         debug_texcoords),
                        ("DEBUG_NORMALS".to_owned(),           debug_normals),
                        ("MANUAL_SRGB".to_owned(),             output_linear_colors),
                        ("SRGB_FAST_APPROXIMATION".to_owned(), "1".to_owned()),
                    ],
                    .. Default::default()
                })
            }
        }else{
            PropertyChanged::Old
        }
    }
}