use rin_graphics as graphics;
use glin::gl;
use gl::types::*;
use glin::{self, VaoDraw};
use rin_util::LazyUpdate;
use super::{traits::ToSimpleVao, CreationProxy};
use std::ops::Deref;
use rin_graphics::PrimitiveTypeToGl;

/// Contains geometry in RAM and GPU memory and updates the GPU
/// version before drawing if the RAM version changed since the last
/// draw
///
/// See [Mesh](../graphics/struct.Mesh.html) for more info
pub struct VaoMesh<T>{
    mesh: graphics::Mesh<T>,
    vao: LazyUpdate<glin::SimpleVao<T>>,
    usage: GLenum
}

pub struct Builder(pub(crate) CreationProxy);

impl Builder{
    pub fn build<T,U>(&self, usage: GLenum) -> VaoMesh<T>
        where graphics::Mesh<T>: ToSimpleVao<T,U> {

        let mesh = graphics::Mesh::default();
        self.from_mesh(mesh, usage)
    }

    pub fn from_shader<T,U>(&self, shader: &glin::Program, usage: GLenum) -> VaoMesh<T>
        where graphics::Mesh<T>: ToSimpleVao<T,U> {

        let mesh = graphics::Mesh::default();
        self.from_mesh_shader(mesh,shader,usage)
    }

    pub fn from_mesh<T,U>(&self, mesh: graphics::Mesh<T>, usage: GLenum) -> VaoMesh<T>
        where graphics::Mesh<T>: ToSimpleVao<T,U> {
        let vao = mesh.to_simple_vao(
            &self.0,
            crate::default_attribute_bindings(),
            usage).unwrap();
        VaoMesh{
            mesh: mesh,
            vao: LazyUpdate::new(vao),
            usage: usage
        }
    }
    pub fn from_mesh_shader<T,U>(&self, mesh: graphics::Mesh<T>, program: &glin::Program, usage: GLenum) -> VaoMesh<T>
        where graphics::Mesh<T>: ToSimpleVao<T,U> {
        let vao = mesh.to_simple_vao(&self.0, program, usage).unwrap();
        VaoMesh {
            mesh: mesh,
            vao: LazyUpdate::new(vao),
            usage: usage
        }
    }
}

impl<T:Clone + 'static> VaoMesh<T>{
    pub fn mesh(&self) -> &graphics::Mesh<T>{
        &self.mesh
    }

    pub fn mesh_mut(&mut self) -> &mut graphics::Mesh<T>{
        self.vao.set_changed();
        &mut self.mesh
    }

    pub fn primitive_type(&self) -> graphics::PrimitiveType{
        self.mesh.primitive_type()
    }

    pub fn set_primitive_type(&mut self, ty: graphics::PrimitiveType){
        self.mesh.set_primitive_type(ty);
        self.vao.set_mode(ty.to_gl());
    }

    fn update_vao(&self){
		self.vao.update(|vao| {
	        if vao.len() < self.mesh.len(){
		        vao.load_vertices(&self.mesh, self.usage);
	        }else if !self.mesh.is_empty(){
	            vao.update_vertices(&self.mesh);
	        }
		    vao.set_mode(self.mesh.primitive_type().to_gl());

	        if vao.len_indices() < self.mesh.indices().len(){
	            let _ = vao.load_indices(self.mesh.indices(), gl::STATIC_DRAW);
	        }else if !self.mesh.indices().is_empty(){
	            vao.update_indices(self.mesh.indices());
	        }
	    })
    }

    pub fn vao(&self) -> &glin::SimpleVao<T>{
    	self.update_vao();
        &self.vao
    }

    pub fn vao_mut(&mut self) -> &mut glin::SimpleVao<T>{
    	self.update_vao();
        &mut self.vao
    }
}

impl<'a, T:Clone + 'static> glin::VaoRange for &'a VaoMesh<T>{
    fn id(&self) -> GLuint{
        self.vao().id()
    }

    fn start(&self) -> usize{
        0
    }

    fn end(&self) -> usize{
        self.vao().deref().end()
    }

    fn count(&self) -> usize{
        self.vao().deref().count()
    }

    fn num_indices(&self) -> usize{
        self.vao().deref().num_indices()
    }

    fn num_vertices(&self) -> usize{
        self.vao().deref().num_vertices()
    }

    fn has_indices(&self) -> bool{
        self.vao().deref().num_indices() > 0
    }

    #[cfg(not(any(feature="gles", feature="webgl")))]
    fn base_vertex(&self) -> Option<i32>{
        self.vao().base_vertex()
    }

    #[cfg(not(any(feature="gles", feature="webgl")))]
    fn base_instance(&self) -> Option<u32>{
        self.vao().base_instance()
    }

    /*fn attribute_bindings(&self) -> HashMap<String,u32>{
        self.vao().attribute_bindings()
    }*/
}

impl<'a, T: Clone + 'static> VaoDraw for &'a VaoMesh<T>{
    fn mode(&self) -> GLenum{
        self.vao().mode()
    }
}


/*impl<'a, T:Vertex> glin::VaoRange for Ref<'a, VaoMesh<T>>{
    fn id(&self) -> GLuint{
        self.vao().id()
    }

    fn mode(&self) -> GLenum{
        self.vao().mode()
    }

    fn start(&self) -> usize{
        0
    }

    fn end(&self) -> usize{
        if self.vao().num_indices() > 0 { self.vao().num_indices() } else { self.vao().num_vertices() }
    }

    fn count(&self) -> usize{
        self.end() - self.start()
    }

    fn num_indices(&self) -> usize{
        self.vao().num_indices()
    }

    fn num_vertices(&self) -> usize{
        self.vao().num_vertices()
    }

    fn has_indices(&self) -> bool{
        self.vao().num_indices() > 0
    }
}*/


/*impl<'a, T:Clone + 'static> glin::VaoRange for &'a VaoMesh<T>{
    fn id(&self) -> GLuint{
        self.vao().deref().id()
    }

    fn mode(&self) -> GLenum{
        self.vao().deref().mode()
    }

    fn start(&self) -> usize{
        0
    }

    fn end(&self) -> usize{
        self.vao().deref().end()
    }

    fn count(&self) -> usize{
        self.vao().deref().count()
    }

    fn num_indices(&self) -> usize{
        self.vao().deref().num_indices()
    }

    fn num_vertices(&self) -> usize{
        self.vao().deref().num_vertices()
    }

    fn has_indices(&self) -> bool{
        self.vao().deref().num_indices() > 0
    }

    /*fn attribute_bindings(&self) -> HashMap<String,u32>{
        self.vao().attribute_bindings()
    }*/
}*/