#![deny(unsafe_code)]
use crate::error::*;
use crate::graphics::{ Permanent, Render };
use crate::graphics::util::init_buffer;
use crate::linear_algebra::{ Vec3, Vec4, Transformation };
use crate::shader_data::{ Vertex, VertexPushBlock };

use vulkanalia::{ Device, Instance };
use vulkanalia::vk::{ self, DeviceV1_0 };


#[derive(Debug)]
pub struct Model {
  pub vertex_buffer: vk::Buffer,
  vertex_buffer_memory: vk::DeviceMemory,

  pub index_buffer: vk::Buffer,
  index_buffer_memory: vk::DeviceMemory,
  pub index_count: usize,
}


impl Model {
  pub fn new(vertices: Vec<Vertex<f32>>, indices: Vec<u32>,
             permanent: &Permanent)
      -> Result<Self>
  {
    let device = &permanent.device;
    let instance = &permanent.instance;
    let graphics_queue = &permanent.graphics_queue;
    let transient_command_pool = &permanent.transient_command_pool;

    let index_count = indices.len();

    let (vertex_buffer, vertex_buffer_memory)
            = init_vertex_buffer(vertices, instance, device, graphics_queue,
                                 &transient_command_pool)?;
    let (index_buffer, index_buffer_memory)
            = init_index_buffer(indices, instance, device, graphics_queue,
                                &transient_command_pool)?;

    Ok(Model {
      vertex_buffer,
      vertex_buffer_memory,
      index_buffer,
      index_buffer_memory,
      index_count,
    })
  }

  #[allow(unsafe_code)]
  pub fn destroy(self, device: &Device) {
    unsafe { device.destroy_buffer(self.vertex_buffer, None) };
    unsafe { device.free_memory(self.vertex_buffer_memory, None) };

    unsafe { device.destroy_buffer(self.index_buffer, None) };
    unsafe { device.free_memory(self.index_buffer_memory, None) };
  }

  #[allow(unsafe_code)]
  pub fn make_active(&self, device: &Device, render: &Render,
                     command_buffer: &vk::CommandBuffer)
  {
    unsafe {
      device.cmd_bind_vertex_buffers(*command_buffer, 0,
                                     &[self.vertex_buffer], &[0])
    };

    unsafe {
      device.cmd_bind_index_buffer(*command_buffer, self.index_buffer,
                                   0, vk::IndexType::UINT32)
    };
  }

  #[allow(unsafe_code)]
  pub fn render(&self, device: &Device, render: &Render,
                command_buffer: &vk::CommandBuffer)
  {
    unsafe {
      device.cmd_draw_indexed(*command_buffer, self.index_count as u32,
                              1, 0, 0, 0)
    };
  }
}


fn init_vertex_buffer(vertices: Vec<Vertex<f32>>, instance: &Instance,
                      device: &Device, queue: &vk::Queue,
                      command_pool: &vk::CommandPool)
    -> Result<(vk::Buffer, vk::DeviceMemory)>
{
  init_buffer(instance, device, queue, command_pool,
              vk::BufferUsageFlags::VERTEX_BUFFER, &vertices)
}


fn init_index_buffer(indices: Vec<u32>, instance: &Instance, device: &Device,
                     queue: &vk::Queue, command_pool: &vk::CommandPool)
    -> Result<(vk::Buffer, vk::DeviceMemory)>
{
  init_buffer(instance, device, queue, command_pool,
              vk::BufferUsageFlags::INDEX_BUFFER, &indices)
}