use color::consts::BLACK;
use glin;
use graphics::{self, Dds};
use std::mem;
use traits::Renderer;
use renderer::Renderer2d;
use std::path::Path;
use util::{Result, Error};
use glin::CreationContext;

pub struct ImageBasedLight{
    diffuse: glin::CubeMap,
    specular: glin::CubeMap,
    strength: f32,
}

pub struct Builder{
    pub(crate) gl: ::CreationProxy
}

impl Builder {
    pub fn from_paths<P: AsRef<Path>>(&self, diffuse: P, specular: P) -> Result<ImageBasedLight>{
        let diffuse_img = Dds::load(diffuse)
            .map_err(|e| Error::with_cause("Error loading diffuse map", e))?;
        let diffuse = self.gl.new_cubemap().from_cubemap_image(&diffuse_img)
            .map_err(|e| Error::with_cause("Error loading diffuse map texture", e))?;
        let specular_img = Dds::load(specular)
            .map_err(|e| Error::with_cause("Error loading specular map", e))?;
        let specular = self.gl.new_cubemap().from_cubemap_image(&specular_img)
            .map_err(|e| Error::with_cause("Error loading specular map texture", e))?;
        Ok(ImageBasedLight::new(diffuse, specular))
    }

    pub fn from_cubemaps(diffuse: glin::CubeMap, specular: glin::CubeMap) -> ImageBasedLight{
        ImageBasedLight{
            diffuse,
            specular,
            strength: 1.,
        }
    }
}


impl ImageBasedLight{
    pub fn new(diffuse: glin::CubeMap, specular: glin::CubeMap) -> ImageBasedLight{
        ImageBasedLight{
            diffuse,
            specular,
            strength: 1.,
        }
    }

    pub fn diffuse(&self) -> &glin::CubeMap{
        &self.diffuse
    }

    pub fn specular(&self) -> &glin::CubeMap{
        &self.specular
    }

    pub fn strength(&self) -> f32{
        self.strength
    }

    pub fn set_diffuse(&mut self, diffuse: glin::CubeMap){
        self.diffuse = diffuse;
    }

    pub fn set_specular(&mut self, specular: glin::CubeMap){
        self.specular = specular;
    }

    pub fn set_strength(&mut self, strength: f32){
        self.strength = strength;
    }
}

impl ::Light for ImageBasedLight{
    fn ty(&self) -> &str{
        "IMAGE_BASED_LIGHT"
    }

    fn uniforms(&self, _: &graphics::Mvp, texture_bind_offset: &mut u32) -> Vec<glin::program::Uniform>{
        let uniforms = uniforms!{
            enabled: 1f32,
            type: 4f32,
            diffmap: (&self.diffuse, *texture_bind_offset + 1),
            envmap: (&self.specular, *texture_bind_offset + 2),
            ibl_strength: self.strength,
        };
        *texture_bind_offset += 2;
        uniforms
    }
}


pub fn generate_radiance_map_from_faces(env_images: &glin::cubemap::Faces<graphics::Image>, gl: &::Renderer) -> graphics::Dds {
    let envmap = gl.new_cubemap().from_faces(env_images).unwrap();
    generate_radiance_map(&envmap, gl)
}

pub fn generate_radiance_map_from_cubemap_img(env_image: &graphics::Dds, gl: &::Renderer) -> graphics::Dds {
    let envmap = gl.new_cubemap().from_cubemap_image(env_image).unwrap();
    generate_radiance_map(&envmap, gl)
}

pub fn generate_radiance_map(envmap: &glin::CubeMap, gl: &::Renderer) -> graphics::Dds {
    let w = envmap.width();
    let h = w;

    let program = shaders::get_radiance_program(gl);
    let num_mips = (w as f32).log2().floor() as i32 + 1;
    let uniforms = uniforms!{
        maximumMips: num_mips,
        cubeSize: envmap.width() as f32,
        cubeMap: (envmap, 0)

    };
    let mut material = ::ShaderMaterial::new(program);
    material.set_properties(vec![
        glin::Property::TextureCubemapSeamless(true),
    ]);

    let mut dds_data = vec![ ];
    let mut fbos = (0..num_mips).map(|mip|{
        let w = w as i32 >> mip;
        let h = h as i32 >> mip;
        let color = gl.new_fbo_color_attachment()
            .texture(w as u32, h as u32, glin::fbo::ColorFormat::RGB32F)
            .unwrap();
        gl.new_fbo().from_color(color).unwrap()
    }).collect::<Vec<_>>();

    for f in 0..6 {
        let mut uniforms = uniforms.clone();
        uniforms.push(glin::program::uniform("face", &(f as i32)));
        // dds_data.extend_from_slice(img.pixels::<u8>());
        for mip in 0..num_mips as i32 {
            let mut uniforms = uniforms.clone();
            uniforms.push(glin::program::uniform("currentMip", &mip));
            material.set_uniforms(uniforms);
            let fbo = &mut fbos[mip as usize];

            {
                let gl = gl.with_fbo(fbo);
                gl.clear(&BLACK);
                gl.draw_mesh_with_material(&graphics::rectangle_texcoords(-1., -1., 2., 2., 0., 0., 1., 1.), &material);
            }

            dds_data.extend(download_fbo(fbo));
        }
    }

    graphics::dds::Builder::new(w as usize, h as usize, graphics::dds::Format::RGB, graphics::dds::Type::Float)
        .is_cubemap_allfaces()
        .has_mipmaps(num_mips as usize)
        .create(dds_data)
        .unwrap()
}

pub fn generate_irradiance_map_from_faces(env_images: &glin::cubemap::Faces<graphics::Image>, size: u32, gl: &::Renderer) -> graphics::Dds {
    let envmap = gl.new_cubemap().from_faces(env_images).unwrap();
    generate_irradiance_map(&envmap, size, gl)
}

pub fn generate_irradiance_map_from_cubemap_img(env_image: &graphics::Dds, size: u32, gl: &::Renderer) -> graphics::Dds {
    let envmap = gl.new_cubemap().from_cubemap_image(env_image).unwrap();
    generate_irradiance_map(&envmap, size, gl)
}

pub fn generate_irradiance_map(envmap: &glin::CubeMap, size: u32, gl: &::Renderer) -> graphics::Dds {
    let w = size;
    let h = size;

    let program = shaders::get_irradiance_program(gl);

    let color = gl.new_fbo_color_attachment()
        .texture(w, h, glin::fbo::ColorFormat::RGB32F)
        .unwrap();
    let mut fbo = gl.new_fbo().from_color(color).unwrap();
    let mut dds_data = vec![ ];

    let uniforms = uniforms!{
        cubeSize: envmap.width() as f32,
        cubeMap: (envmap, 0)
    };
    let mut material = ::ShaderMaterial::new(program);
    material.set_properties(vec![
        glin::Property::TextureCubemapSeamless(true),
    ]);
    {
        for f in 0..6i32 {
            let mut uniforms = uniforms.clone();
            uniforms.push(glin::program::uniform("face", &f));
            material.set_uniforms(uniforms);
            gl.with_fbo(&mut fbo)
                .draw_mesh_with_material(&graphics::rectangle_texcoords(-1., -1., 2., 2., 0., 0., 1., 1.), &material);

            dds_data.extend(download_fbo(&fbo));
        }
    }

    graphics::dds::Builder::new(w as usize, h as usize, graphics::dds::Format::RGB, graphics::dds::Type::Float)
        .is_cubemap_allfaces()
        .create(dds_data)
        .unwrap()
}

pub fn generate_brdf_lut(size: u32, gl: &::Renderer) -> graphics::Dds {
    let w = size;
    let h = size;

    let program = shaders::get_brdf_lut_program(gl);

    let color = gl.new_fbo_color_attachment()
        .texture(w, h, glin::fbo::ColorFormat::RGB16F)
        .unwrap();
    let mut fbo = gl.new_fbo().from_color(color).unwrap();
    {
        let gl = gl.with_fbo(&mut fbo);
        gl.clear(&BLACK);
        gl.draw_mesh_with_material(&graphics::rectangle_texcoords(-1., -1., 2., 2., 0., 0., 1., 1.), &program);
    }

    unsafe{
        let mut dds_data: Vec<u8> = vec![mem::uninitialized(); w as usize * h as usize * 3 * mem::size_of::<f32>()];
        fbo.color_tex(0).unwrap().read_to(&mut dds_data, glin::gl::RGB, glin::gl::FLOAT);
        graphics::dds::Builder::new(w as usize, h as usize, graphics::dds::Format::RGB, graphics::dds::Type::Float)
            .create(dds_data)
            .unwrap()
    }
}

pub fn equirectangular_to_cubemap(map: &glin::Texture, size: u32, gl: &::Renderer) -> graphics::Dds{
    let w = size;
    let h = size;
    let program = shaders::get_equirectangular_program(gl);

    let color = gl.new_fbo_color_attachment()
        .texture(w, h, glin::fbo::ColorFormat::RGB32F)
        .unwrap();
    let mut fbo = gl.new_fbo().from_color(color).unwrap();
    let mut dds_data = vec![ ];
    let mut material = ::ShaderMaterial::new(program);
    material.set_properties(vec![
        glin::Property::TextureCubemapSeamless(true),
    ]);
    {
        for f in 0..6i32 {
            let uniforms = uniforms!{
                face: f,
                equirectangular_map: map,
            };
            material.set_uniforms(uniforms);
            gl.with_fbo(&mut fbo)
                .draw_mesh_with_material(&graphics::rectangle_texcoords(-1., -1., 2., 2., 0., 0., 1., 1.), &material);

            dds_data.extend(download_fbo(&fbo));
        }
    }

    graphics::dds::Builder::new(w as usize, h as usize, graphics::dds::Format::RGB, graphics::dds::Type::Float)
        .is_cubemap_allfaces()
        .create(dds_data)
        .unwrap()
}

#[cfg(not(any(target_os="android", target_os="emscripten")))]
mod shaders{
    program_cache!("shaders/envgen.vs.glsl", "shaders/irradiance.fs.glsl", get_irradiance_program, IRR_SHADER);
    program_cache!("shaders/envgen.vs.glsl", "shaders/radiance.fs.glsl", get_radiance_program, RAD_SHADER);
    program_cache!("shaders/envgen.vs.glsl", "shaders/brdf_lut.fs.glsl", get_brdf_lut_program, LUT_SHADER);
    program_cache!("shaders/envgen.vs.glsl", "shaders/equirectangular.fs.glsl", get_equirectangular_program, EQUI_SHADER);
}

#[cfg(feature="freeimage")]
fn download_fbo(fbo: &glin::Fbo) -> Vec<u8> {
    let mut img = graphics::Image::new::<f32>(graphics::image::Type::RGBF,
        fbo.width() as usize, fbo.height() as usize, 32*3, None);
    unsafe{ fbo.color_tex(0).unwrap().read_to(img.pixels_mut::<f32>(), glin::gl::RGB, glin::gl::FLOAT); }
    img.flip_vertical().unwrap().bits().to_vec()
}

#[cfg(not(feature="freeimage"))]
fn download_fbo(fbo: &glin::Fbo) -> Vec<u8> {
    unsafe{
        let mut buffer: Vec<f32> = vec![mem::uninitialized(); (fbo.width() * fbo.height() * 3) as usize];
        fbo.color_tex(0).unwrap().read_to(&mut buffer, glin::gl::RGB, glin::gl::FLOAT);
        let img: graphics::image::ImageBuffer<graphics::image::Rgb<f32>, Vec<f32>> =
            graphics::image::ImageBuffer::from_raw(fbo.width(), fbo.height(), buffer).unwrap();
        graphics::image::imageops::flip_vertical(&img)
            .into_raw()
            .iter()
            .flat_map(|p| mem::transmute::<f32, [u8;4]>(*p).to_vec())
            .collect()
    }
}