use glium::index::{
    NoIndices,
    PrimitiveType
};
use glium::{
    Program,
    Display,
    VertexBuffer,
    Frame,
};

use model::{Model, Vertex};

pub struct Renderer<'a> {
    display: Display,
    program: Program,
    models: Vec<(&'a Model, Vec<VertexBuffer<Vertex>>)>,
}

impl<'a> Renderer<'a> {
    pub fn new(display: Display) -> Renderer<'a> {

        let program = Program::from_source(
            &display,
            include_str!("../assets/shaders/shader.vert"),
            include_str!("../assets/shaders/shader.frag"),
            None
        ).unwrap();

        Renderer {
            display: display,
            program: program,
            models: vec![],
        }
    }

    pub fn add_model(&mut self, model: &'a Model) {
        let mut buffers = vec![];

        for part in &model.parts {
            let shape = part.build_shape(&model.vertices, &model.texture_coordinates, &model.normals);
            buffers.push(VertexBuffer::new(&self.display, &shape).unwrap());
        }

        self.models.push((model, buffers));
    }

    pub fn draw(&self) -> Frame {
        self.display.draw()
    }

    pub fn render(&self, target: &mut Frame) {
        use glium::Surface;
        target.clear_color(0.0, 0.0, 0.0, 1.0);

        for &(_, ref buffers) in &self.models {
            for buffer in buffers {
                target.draw(
                    buffer,
                    NoIndices(PrimitiveType::TrianglesList),
                    &self.program,
                    &uniform!(),
                    &Default::default(),
                ).unwrap();
            }
        }
    }
}