use rin_math::{Rotation2, vec2, vec3, Angle};
use rin_material::{
    PbrMaterial as MutinyPbrMaterial, StandardMaterial, LambertMaterial, AnisotropicMaterial,
    ClothMaterial, ClothSubsurfaceMaterial, SubsurfaceMaterial, AlphaType, ClearcoatMaterial
};
use rin_gl as gl;
use std::mem;
use super::{std140_data::Data, PropertyChanged, MaterialTransparency, ToGlinShaderPrecision};


pub trait PbrMaterial: super::Material + MutinyPbrMaterial{
    fn pbr_data(&self) -> Data;
}

impl PbrMaterial for StandardMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(12 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.roughness);
        pbr_data.push(*self.metallic);
        pbr_data.push(*self.reflectance);
        pbr_data.push(*self.reflectance_tint);
        pbr_data.finish();
        data
    }
}

impl PbrMaterial for LambertMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(8 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.finish();
        data
    }
}


impl PbrMaterial for AnisotropicMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(22 * mem::size_of::<f32>());
        let ani_direction = Rotation2::new(self.anisotropic_rotation.value()) * vec2(1.0, 0.0);
        let ani_direction = vec3!(ani_direction, 0.0);
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.roughness);
        pbr_data.push(*self.metallic);
        pbr_data.push(*self.reflectance);
        pbr_data.push(*self.reflectance_tint);
        pbr_data.push(ani_direction);
        pbr_data.push(*self.anisotropy);
        pbr_data.finish();
        // data.pad::<[f32;2]>();
        data
    }
}


impl PbrMaterial for ClothMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(16 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.sheen_color);
        pbr_data.push(*self.roughness);
        pbr_data.finish();
        data
    }
}

impl PbrMaterial for ClothSubsurfaceMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(20 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.sheen_color);
        pbr_data.push(*self.subsurface_color);
        pbr_data.push(*self.roughness);
        pbr_data.finish();
        data
    }
}


impl PbrMaterial for SubsurfaceMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(20 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.roughness);
        pbr_data.push(*self.metallic);
        pbr_data.push(*self.reflectance);
        pbr_data.push(*self.reflectance_tint);
        pbr_data.push(*self.subsurface_color);
        pbr_data.push(*self.subsurface_power);
        pbr_data.push(*self.thickness);
        pbr_data.finish();
        data
    }
}


impl PbrMaterial for ClearcoatMaterial{
    fn pbr_data(&self) -> Data{
        let mut data = Data::with_capacity(16 * mem::size_of::<f32>());
        let mut pbr_data = data.start_struct();
        pbr_data.push(*self.base_color);
        pbr_data.push(*self.emissive_color);
        pbr_data.push(*self.normal_scale);
        pbr_data.push(*self.roughness);
        pbr_data.push(*self.metallic);
        pbr_data.push(*self.reflectance);
        pbr_data.push(*self.reflectance_tint);
        pbr_data.push(*self.clearcoat);
        pbr_data.push(*self.clearcoat_roughness);
        pbr_data.finish();
        data
    }
}


// impl PbrMaterial for DisneyPrincipledMaterial{
//     fn pbr_data(&self) -> Data{
//         unimplemented!()
//     }
// }

impl<M: PbrMaterial> super::Material for M{
    fn data(&self) -> PropertyChanged<Option<Data>>{
        if self.any_data_changed() {
            PropertyChanged::New(Some(self.pbr_data()))
        }else{
            PropertyChanged::Old
        }
    }

    fn properties(&self) -> PropertyChanged<Vec<glin::Property>> {
        if self.is_double_sided().has_changed() || self.alpha_ty().has_changed(){
            let props = if **self.is_double_sided() {
                vec![glin::Property::CullFace(None)]
            }else{
                vec![gl::Property::CullFace(Some(gl::BACK))]
            };

            PropertyChanged::New(props)
        }else{
            PropertyChanged::Old
        }
    }

    fn transparency(&self) -> PropertyChanged<MaterialTransparency>{
        if self.alpha_ty().has_changed()
            || self.base_color().has_changed()
            || self.override_translucent().has_changed()
        {
            let base_color_alpha = self.base_color_alpha();
            PropertyChanged::New(MaterialTransparency{
                alpha_type: **self.alpha_ty(),

                is_translucent: if let Some(is_translucent) = **self.override_translucent(){
                    is_translucent
                }else{
                    **self.alpha_ty() == AlphaType::Blending
                        && base_color_alpha > 0.
                        && base_color_alpha < 1.
                },

                is_visible: **self.alpha_ty() == AlphaType::None || base_color_alpha > 0.,

                priority: None,
            })
        }else{
            PropertyChanged::Old
        }
    }

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

    fn program_settings(&self) -> PropertyChanged<super::ProgramSettings>{
        if self.any_texture_option_changed()
            || self.is_double_sided().has_changed()
            || self.alpha_ty().has_changed()
            || self.shader_precision().has_changed()
        {
            let has_metallic_roughness_map = (self.metallic_roughness_map().is_some() as u8).to_string();
            let has_metallic_map       = (self.metallic_map().is_some() as u8).to_string();
            let has_roughness_map      = (self.roughness_map().is_some() as u8).to_string();
            let has_base_color_tex     = (self.base_color_map().is_some() as u8).to_string();
            let has_normal_map         = (self.normal_map().is_some() as u8).to_string();
            let has_emissive_map       = (self.emissive_map().is_some() as u8).to_string();
            let has_occlusion_map      = (self.occlusion_map().is_some() as u8).to_string();
            let has_anisotropy_map     = (self.anisotropy_map().is_some() as u8).to_string();
            let ty                     = self.pbr_material_type().to_string();
            let alpha_type             = self.alpha_ty().to_string();
            let ibl_brdf               = if self.pbr_material_type().is_cloth() {
                "NEEDS_IBL_CLOTH_BRDF".to_string()
            }else{
                "NEEDS_IBL_BRDF".to_string()
            };

            // TODO: This should be in the main shader?
            let is_double_sided        = (**self.is_double_sided() as u8).to_string();
            let has_separate_alpha     = "0".to_string();

            //TODO: Remove this from main shader, the brdf lut is specific to each pbr shader
            #[cfg(image_ty="freeimage")]
            let inverted_ibl_lut       = "1".to_string();
            #[cfg(image_ty="image")]
            let inverted_ibl_lut       = "1".to_string();
            #[cfg(not(image_enabled))]
            {
                log::error!("no support for image loading, can't load brdf lut for pbr materials. Add one of \"image\" or \"freeimage\" features to your Cargo.toml");
                panic!();
            }
            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")
            }

            // TODO: impl ToOwned for ProgramSettings<S> where S: ToOwned
            let settings = super::ProgramSettings{
                defines: vec![
                    ("HAS_TEXTURE".to_owned(),             has_base_color_tex),
                    ("HAS_NORMALMAP".to_owned(),           has_normal_map),
                    ("HAS_METALROUGHNESSMAP".to_owned(),   has_metallic_roughness_map),
                    ("HAS_METALLICMAP".to_owned(),         has_metallic_map),
                    ("HAS_ROUGHNESSMAP".to_owned(),        has_roughness_map),
                    ("HAS_EMISSIVEMAP".to_owned(),         has_emissive_map),
                    ("HAS_ANISOTROPYMAP".to_owned(),       has_anisotropy_map),
                    ("HAS_OCCLUSIONMAP".to_owned(),        has_occlusion_map),
                    ("HAS_SEPARATE_ALPHA".to_owned(),      has_separate_alpha),
                    ("DOUBLE_SIDED".to_owned(),            is_double_sided),
                    ("MANUAL_SRGB".to_owned(),             "1".to_owned()),
                    ("SRGB_FAST_APPROXIMATION".to_owned(), "1".to_owned()),
                    ("MATERIAL_TYPE".to_owned(),            ty),
                    ("ALPHA_TYPE".to_owned(),               alpha_type),
                    ("TARGET_MOBILE".to_owned(),            "0".to_owned()),
                    #[cfg(image_enabled)]
                    ("INVERTED_IBL_BRDF_LUT".to_owned(),    inverted_ibl_lut),
                    #[cfg(image_enabled)]
                    (ibl_brdf,                              "1".to_owned()),
                    ("DEBUG_TEXCOORDS".to_owned(),          debug_texcoords),
                    ("DEBUG_NORMALS".to_owned(),            debug_normals),
                ],
                includes_replace: vec![
                    ("material_uniforms.glsl".to_string(), include_str!("shaders/material_uniforms.glsl").to_owned()),
                ],
                precision: self.shader_precision().to_glin(),
                .. Default::default()
            };

            PropertyChanged::New(settings)
        }else{
            PropertyChanged::Old
        }
    }
}

// TODO: this should be here not in program cache
// #[cfg(image_enabled)]
// mod textures{
//     use glin;
//     use rin::graphics;
//     use rin::gl;
//     use glin::RenderSurface;

//     image_cache!(get_image_32bit, IMAGE32, {
//         let brdf_lut = include_bytes!("textures/brdfLUT.exr");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     image_cache!(get_image_16bit, IMAGE16, {
//         let brdf_lut = include_bytes!("textures/brdfLUT16.png");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     image_cache!(get_cloth_ashikhmin_image_32bit, CLOTH_ASHIKHMIN_IMAGE32, {
//         let brdf_lut = include_bytes!("textures/cloth_ashikhmin_brdfLUT.exr");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     image_cache!(get_cloth_ashikhmin_image_16bit, CLOTH_ASHIKHMIN_IMAGE16, {
//         let brdf_lut = include_bytes!("textures/cloth_ashikhmin_brdfLUT16.png");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     image_cache!(get_cloth_charlie_image_32bit, CLOTH_CHARLIE_IMAGE32, {
//         let brdf_lut = include_bytes!("textures/cloth_charlie_brdfLUT.exr");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     image_cache!(get_cloth_charlie_image_16bit, CLOTH_CHARLIE_IMAGE16, {
//         let brdf_lut = include_bytes!("textures/cloth_charlie_brdfLUT16.png");
//         graphics::image::load_from_memory(brdf_lut).unwrap()
//     });

//     // image_cache!(get_image_8bit, IMAGE8, {
//     //     let brdf_lut = include_bytes!("textures/brdfLUT.png");
//     //     graphics::image::load_from_memory(brdf_lut).unwrap()
//     // });

//     pub fn brdf_texture<'r, R: RenderSurface>(gl: &'r gl::Renderer<R>) -> &'r glin::Texture{
//         if graphics::image::supports(graphics::image::Format::Exr){
//             get_image_32bit(gl)
//         }else{
//             get_image_16bit(gl)
//         }
//     }

//     pub fn cloth_ashikhmin_brdf_texture<'r, R: RenderSurface>(gl: &'r gl::Renderer<R>) -> &'r glin::Texture{
//         if graphics::image::supports(graphics::image::Format::Exr){
//             get_cloth_ashikhmin_image_32bit(gl)
//         }else{
//             get_cloth_ashikhmin_image_16bit(gl)
//         }
//     }

//     pub fn _cloth_charlie_brdf_texture<'r, R: RenderSurface>(gl: &'r gl::Renderer<R>) -> &'r glin::Texture{
//         if graphics::image::supports(graphics::image::Format::Exr){
//             get_cloth_charlie_image_32bit(gl)
//         }else{
//             get_cloth_charlie_image_16bit(gl)
//         }
//     }
// }