#![deny(unsafe_code)]
use crate::error::*;
use crate::graphics_permanent::{
  PermanentGraphicsState, GraphicsStateForReinit, QueueFamilyIndices
};
use crate::linear_algebra::{ Vertex, VERTICES };

use std::collections::BTreeSet;
use std::ptr;
use vulkanalia::{ Device, Instance };
use vulkanalia::vk::{ self, Handle, HasBuilder, InstanceV1_0, DeviceV1_0,
                      KhrSwapchainExtensionDeviceCommands };
use winit::window::Window;


// TODO: use VK_KHR_swapchain_maintenance1 to put a fence on the presentation
// operation. doing that will remove the requirement that we have more
// simultaneous frames than images.
pub const N_SIMULTANEOUS_FRAMES: usize = 5;


//   The WindowDressing collects the Vulkan graphics objects which need to be
// regenerated or modified when the window changes in certain ways, such as
// resizing. The ones which don't need that are collected above, in
// PermanentGraphicsState.
#[derive(Debug)]
pub struct WindowDressing {
  pub swapchain: Swapchain,

  render_pass: vk::RenderPass,

  pipeline: vk::Pipeline,
  pipeline_layout: vk::PipelineLayout,

  framebuffers: Vec<vk::Framebuffer>,

  vertex_buffer: vk::Buffer,
  vertex_buffer_memory: vk::DeviceMemory,

  command_pool: vk::CommandPool,
  pub command_buffers: Vec<vk::CommandBuffer>,

  pub concurrency: Concurrency,
}

//   A swapchain is the generalized facility that is used to implement
// double buffering, triple buffering, rendering passes that feed into each
// other, and other things of that nature. It's a first-class thing but for
// now, we use at most one of it. We also support running without one.
#[derive(Debug)]
pub struct Swapchain {
  pub swapchain: vk::SwapchainKHR,
  images: Vec<vk::Image>,
  image_views: Vec<vk::ImageView>,
  format: vk::Format,
  extent: vk::Extent2D,
}

#[derive(Debug)]
pub struct Concurrency {
  pub image_available_semaphores: Vec<vk::Semaphore>,
  pub rendering_finished_semaphores: Vec<vk::Semaphore>,

  //   Okay, the lifetime management on the fences is really subtle. There is
  // one fence for each frame, and frame_fences holds the authoritative
  // reference to it.
  //
  //   There is one entry in image_fences for each image. The number of images
  // is not directly related to the number of frames; it will likely be
  // larger, but may be smaller or the same. At the start of execution, the
  // entries are all nulls. Each time an image is acquired from the swapchain,
  // the corresponding entry in image_fences is overwritten with a duplicate
  // of the frame fence. This happens during rendering of the frame, so the
  // frame fence is in the "signaled" state. It will be reset right before
  // submitting the queue, then signaled again when the submission completes.
  pub frame_fences: Vec<vk::Fence>,
  pub image_fences: Vec<vk::Fence>,
}


impl WindowDressing {
  pub fn new(permanent: &PermanentGraphicsState,
             for_reinit: &GraphicsStateForReinit)
      -> Result<Self>
  {
    let window = &permanent.window;
    let instance = &permanent.instance;
    let surface = &permanent.surface;
    let device = &permanent.device;
    let physical_device = &for_reinit.physical_device;
    let indices = &for_reinit.indices;

    let swapchain = init_swapchain(
            window, instance, surface, &physical_device, device, &indices)?;

    let render_pass = init_render_pass(device, &swapchain.format)?;

    let (pipeline_layout, pipeline)
            = init_pipeline(device, &swapchain.extent, &render_pass)?;

    let framebuffers = init_framebuffers(
            device, &swapchain.extent, &swapchain.image_views, &render_pass)?;

    let (vertex_buffer, vertex_buffer_memory)
            = init_vertex_buffer(instance, physical_device, device)?;

    let command_pool = init_command_pool(device, indices)?;
    let command_buffers = init_commands(device, &swapchain.extent,
                                        &framebuffers, &render_pass,
                                        &pipeline, &vertex_buffer,
                                        &command_pool)?;

    let concurrency = init_concurrency(device, &swapchain.images)?;

    Ok(WindowDressing {
      swapchain,
      render_pass,
      pipeline,
      pipeline_layout,
      framebuffers,
      vertex_buffer,
      vertex_buffer_memory,
      command_pool,
      command_buffers,
      concurrency,
    })
  }


  #[allow(unsafe_code)]
  pub fn reinit(&mut self, permanent: &PermanentGraphicsState,
                for_reinit: &GraphicsStateForReinit)
      -> Result<()>
  {
    let window = &permanent.window;
    let instance = &permanent.instance;
    let surface = &permanent.surface;
    let device = &permanent.device;
    let physical_device = &for_reinit.physical_device;
    let indices = &for_reinit.indices;

    unsafe { device.device_wait_idle() }.unwrap();

    self.destroy_replaceable(device);

    let swapchain = init_swapchain(
            window, instance, surface, &physical_device, device, &indices)?;

    let render_pass = init_render_pass(device, &swapchain.format)?;

    let (pipeline_layout, pipeline)
            = init_pipeline(device, &swapchain.extent, &render_pass)?;

    let framebuffers = init_framebuffers(
            device, &swapchain.extent, &swapchain.image_views, &render_pass)?;

    // Notice that we reused the command pool.
    let command_buffers = init_commands(
            device, &swapchain.extent, &framebuffers, &render_pass,
            &pipeline, &self.vertex_buffer, &self.command_pool)?;

    self.concurrency.image_fences.resize(swapchain.images.len(),
                                         vk::Fence::null());

    self.swapchain = swapchain;
    self.render_pass = render_pass;
    self.pipeline = pipeline;
    self.pipeline_layout = pipeline_layout;
    self.framebuffers = framebuffers;
    self.command_buffers = command_buffers;

    Ok(())
  }


  //   This relies on its caller to have already waited for the device to be
  // idle.
  #[allow(unsafe_code)]
  pub fn destroy(mut self, device: &Device) {
    self.destroy_replaceable(device);

    unsafe { device.destroy_buffer(self.vertex_buffer, None) };
    unsafe { device.free_memory(self.vertex_buffer_memory, None) };

    for semaphore in self.concurrency.image_available_semaphores {
      unsafe { device.destroy_semaphore(semaphore, None) };
    }

    for semaphore in self.concurrency.rendering_finished_semaphores {
      unsafe { device.destroy_semaphore(semaphore, None) };
    }

    for fence in self.concurrency.frame_fences {
      unsafe { device.destroy_fence(fence, None) };
    }

    // Notice that destroy_replaceable freed the pool, but did not destroy it.
    unsafe { device.destroy_command_pool(self.command_pool, None) };
  }


  #[allow(unsafe_code)]
  fn destroy_replaceable(&mut self, device: &Device) {
    for framebuffer in &self.framebuffers {
      unsafe { device.destroy_framebuffer(*framebuffer, None) };
    }

    // Notice that we free the pool, but do not destroy it.
    unsafe {
      device.free_command_buffers(self.command_pool, &self.command_buffers)
    };

    unsafe { device.destroy_pipeline(self.pipeline, None) };
    unsafe { device.destroy_pipeline_layout(self.pipeline_layout, None) };
    unsafe { device.destroy_render_pass(self.render_pass, None) };

    for view in &self.swapchain.image_views {
      unsafe { device.destroy_image_view(*view, None) };
    }

    unsafe { device.destroy_swapchain_khr(self.swapchain.swapchain, None) };
  }
}


#[allow(unsafe_code)]
fn init_swapchain(window: &Window, instance: &Instance,
                  surface: &vk::SurfaceKHR,
                  physical_device: &vk::PhysicalDevice, device: &Device,
                  indices: &QueueFamilyIndices)
    -> Result<Swapchain>
{
  let (capabilities, formats, presentation_modes)
          = PermanentGraphicsState::find_device_swapchain_features(
                instance, surface, physical_device)?.require()?;

  let format = pick_surface_format(&formats)?;

  let presentation_mode
          = pick_presentation_mode(&presentation_modes)?;
  let extent = pick_image_extent(window, capabilities)?;

  let mut image_count = capabilities.min_image_count + 1;
  if capabilities.max_image_count != 0 {
    image_count
        = image_count.clamp(0, capabilities.max_image_count);
  }

  let mut unique_queue_family_indices = BTreeSet::new();
  unique_queue_family_indices.insert(indices.graphics);
  unique_queue_family_indices.insert(indices.presentation);

  //   If there's only one queue, we use exclusive sharing mode, which
  // will allow things to work without locks. Otherwise we use concurrent
  // mode.
  let (ordered_indices, sharing_mode)
          = if unique_queue_family_indices.len() < 2
  {
    (vec![indices.graphics], vk::SharingMode::EXCLUSIVE)
  } else {
    (vec![indices.graphics, indices.presentation],
     vk::SharingMode::CONCURRENT)
  };

  let swapchain_info = vk::SwapchainCreateInfoKHR::builder()
          .surface(*surface)
          .min_image_count(image_count)
          .image_format(format.format)
          .image_color_space(format.color_space)
          .image_extent(extent)
          .image_array_layers(1)
          .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
          .image_sharing_mode(sharing_mode)
          .queue_family_indices(&ordered_indices)
          .pre_transform(capabilities.current_transform)
          .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
          .present_mode(presentation_mode)
          .clipped(true)
          .old_swapchain(vk::SwapchainKHR::null());

  let swapchain = unsafe {
    device.create_swapchain_khr(&swapchain_info, None)
  }?;

  let images = unsafe {
    device.get_swapchain_images_khr(swapchain)
  }?;

  let mut image_views = Vec::new();
  for image in &images {
    let components = vk::ComponentMapping::builder()
                         .r(vk::ComponentSwizzle::IDENTITY)
                         .g(vk::ComponentSwizzle::IDENTITY)
                         .b(vk::ComponentSwizzle::IDENTITY)
                         .a(vk::ComponentSwizzle::IDENTITY);

    let subresource_range = vk::ImageSubresourceRange::builder()
                                .aspect_mask(vk::ImageAspectFlags::COLOR)
                                .base_mip_level(0)
                                .level_count(1)
                                .base_array_layer(0)
                                .layer_count(1);

    let view_info = vk::ImageViewCreateInfo::builder()
                        .image(*image)
                        .view_type(vk::ImageViewType::_2D)
                        .format(format.format)
                        .components(components)
                        .subresource_range(subresource_range);

    let view = unsafe {
      device.create_image_view(&view_info, None)
    }?;

    image_views.push(view);
  }

  Ok(Swapchain {
    swapchain, images, image_views,
    format: format.format,
    extent
  })
}


#[allow(unsafe_code)]
fn init_render_pass(device: &Device, format: &vk::Format)
    -> Result<vk::RenderPass>
{
  let color_attachment
          = vk::AttachmentDescription::builder()
                .format(*format)
                .samples(vk::SampleCountFlags::_1)
                .load_op(vk::AttachmentLoadOp::CLEAR)
                .store_op(vk::AttachmentStoreOp::STORE)
                .stencil_load_op(vk::AttachmentLoadOp::DONT_CARE)
                .stencil_store_op(vk::AttachmentStoreOp::DONT_CARE)
                .initial_layout(vk::ImageLayout::UNDEFINED)
                .final_layout(vk::ImageLayout::PRESENT_SRC_KHR);

  let color_attachment_reference
          = vk::AttachmentReference::builder()
                .attachment(0)
                .layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);

  let subpass_attachments = [color_attachment_reference];
  let subpass = vk::SubpassDescription::builder()
                    .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
                    .color_attachments(&subpass_attachments);

  let dependency
        = vk::SubpassDependency::builder()
              .src_subpass(vk::SUBPASS_EXTERNAL)
              .src_stage_mask(
                   vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT)
              .src_access_mask(vk::AccessFlags::empty())
              .dst_subpass(0)
              .dst_stage_mask(
                   vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT)
              .dst_access_mask(vk::AccessFlags::COLOR_ATTACHMENT_WRITE);

  let render_attachments = [color_attachment];
  let subpasses = [subpass];
  let dependencies = [dependency];
  let render_pass_info = vk::RenderPassCreateInfo::builder()
                             .attachments(&render_attachments)
                             .subpasses(&subpasses)
                             .dependencies(&dependencies);

  let render_pass = unsafe {
    device.create_render_pass(&render_pass_info, None)
  }?;

  Ok(render_pass)
}


#[allow(unsafe_code)]
fn init_pipeline(device: &Device, extent: &vk::Extent2D,
                 render_pass: &vk::RenderPass)
    -> Result<(vk::PipelineLayout, vk::Pipeline)>
{
  let vertex_binary = include_bytes!(
          concat!(env!("OUT_DIR"), "/shader.vert.spv"));
  let fragment_binary = include_bytes!(
          concat!(env!("OUT_DIR"), "/shader.frag.spv"));

  let vertex_module = PermanentGraphicsState::load_spirv_shader_module(
          device, vertex_binary)?;
  let fragment_module = PermanentGraphicsState::load_spirv_shader_module(
          device, fragment_binary)?;

  let vertex_stage_info = vk::PipelineShaderStageCreateInfo::builder()
                              .stage(vk::ShaderStageFlags::VERTEX)
                              .module(vertex_module)
                              .name(b"main\0");

  let fragment_stage_info = vk::PipelineShaderStageCreateInfo::builder()
                                .stage(vk::ShaderStageFlags::FRAGMENT)
                                .module(fragment_module)
                                .name(b"main\0");

  let binding_descriptions = [Vertex::<f32>::binding_description()];
  let attribute_descriptions = Vertex::<f32>::attribute_descriptions();
  let vertex_input_state_info
          = vk::PipelineVertexInputStateCreateInfo::builder()
                .vertex_binding_descriptions(&binding_descriptions)
                .vertex_attribute_descriptions(&attribute_descriptions);

  let input_assembly_state_info
          = vk::PipelineInputAssemblyStateCreateInfo::builder()
                .topology(vk::PrimitiveTopology::TRIANGLE_LIST)
                .primitive_restart_enable(false);

  let viewport = vk::Viewport::builder()
                     .x(0.0)
                     .y(0.0)
                     .width(extent.width as f32)
                     .height(extent.height as f32)
                     .min_depth(0.0)
                     .max_depth(1.0);
  let viewports = [viewport];

  let scissor = vk::Rect2D::builder()
                     .offset(vk::Offset2D { x: 0, y: 0 })
                     .extent(*extent);
  let scissor_list = [scissor];

  let viewport_state_info = vk::PipelineViewportStateCreateInfo::builder()
                     .viewports(&viewports)
                     .scissors(&scissor_list);

  let rasterizer_state_info
          = vk::PipelineRasterizationStateCreateInfo::builder()
                .depth_clamp_enable(false)
                .rasterizer_discard_enable(false)
                .polygon_mode(vk::PolygonMode::FILL)
                .line_width(1.0)
                .cull_mode(vk::CullModeFlags::BACK)
                .front_face(vk::FrontFace::CLOCKWISE)
                .depth_bias_enable(false);

  let multisample_state_info
          = vk::PipelineMultisampleStateCreateInfo::builder()
                .sample_shading_enable(false)
                .rasterization_samples(vk::SampleCountFlags::_1);

  let blend_attachment_info
          = vk::PipelineColorBlendAttachmentState::builder()
                .color_write_mask(vk::ColorComponentFlags::all())
                .blend_enable(false)
                .src_color_blend_factor(vk::BlendFactor::ONE)
                .dst_color_blend_factor(vk::BlendFactor::ZERO)
                .color_blend_op(vk::BlendOp::ADD)
                .src_alpha_blend_factor(vk::BlendFactor::ONE)
                .dst_alpha_blend_factor(vk::BlendFactor::ZERO)
                .alpha_blend_op(vk::BlendOp::ADD);
  let blend_attachments = [blend_attachment_info];

  let blend_info = vk::PipelineColorBlendStateCreateInfo::builder()
                       .logic_op_enable(false)
                       .logic_op(vk::LogicOp::COPY)
                       .attachments(&blend_attachments)
                       .blend_constants([0.0, 0.0, 0.0, 0.0]);

  let pipeline_layout_info = vk::PipelineLayoutCreateInfo::builder();

  let pipeline_layout = unsafe {
    device.create_pipeline_layout(&pipeline_layout_info, None)
  }?;

  let stages = [vertex_stage_info, fragment_stage_info];
  let pipeline_info
          = vk::GraphicsPipelineCreateInfo::builder()
                .stages(&stages)
                .vertex_input_state(&vertex_input_state_info)
                .input_assembly_state(&input_assembly_state_info)
                .viewport_state(&viewport_state_info)
                .rasterization_state(&rasterizer_state_info)
                .multisample_state(&multisample_state_info)
                .color_blend_state(&blend_info)
                .layout(pipeline_layout)
                .render_pass(*render_pass)
                .subpass(0);

  let pipeline = unsafe {
    device.create_graphics_pipelines(vk::PipelineCache::null(),
                                     &[pipeline_info], None)
  }?.0[0];

  unsafe {
    device.destroy_shader_module(vertex_module, None);
    device.destroy_shader_module(fragment_module, None);
  };

  Ok((pipeline_layout, pipeline))
}


#[allow(unsafe_code)]
fn init_framebuffers(device: &Device, extent: &vk::Extent2D,
                     swapchain_image_views: &Vec<vk::ImageView>,
                     render_pass: &vk::RenderPass)
    -> Result<Vec<vk::Framebuffer>>
{
  let mut framebuffers = Vec::new();

  for image_view in swapchain_image_views {
    let attachments = [*image_view];

    let framebuffer_info = vk::FramebufferCreateInfo::builder()
                               .render_pass(*render_pass)
                               .attachments(&attachments)
                               .width(extent.width)
                               .height(extent.height)
                               .layers(1);

    let framebuffer = unsafe {
      device.create_framebuffer(&framebuffer_info, None)
    }?;

    framebuffers.push(framebuffer);
  }

  Ok(framebuffers)
}


#[allow(unsafe_code)]
fn init_vertex_buffer(instance: &Instance,
                      physical_device: &vk::PhysicalDevice, device: &Device)
    -> Result<(vk::Buffer, vk::DeviceMemory)>
{
  let size = (size_of::<Vertex<f32>>() * VERTICES.len()) as u64;
  let usage = vk::BufferUsageFlags::VERTEX_BUFFER;
  let memory_flags = vk::MemoryPropertyFlags::HOST_COHERENT
                     | vk::MemoryPropertyFlags::HOST_VISIBLE;
  let (buffer, device_memory) = init_buffer(instance, physical_device, device,
                                            size, usage, memory_flags)?;

  let host_memory = unsafe {
    device.map_memory(device_memory, 0, size, vk::MemoryMapFlags::empty())
  }?;

  unsafe {
    ptr::copy_nonoverlapping(VERTICES.as_ptr(), host_memory.cast(),
                             VERTICES.len())
  };

  unsafe { device.unmap_memory(device_memory) };

  Ok((buffer, device_memory))
}


#[allow(unsafe_code)]
fn init_buffer(instance: &Instance,
               physical_device: &vk::PhysicalDevice, device: &Device,
               size: vk::DeviceSize, usage: vk::BufferUsageFlags,
               memory_flags: vk::MemoryPropertyFlags)
    -> Result<(vk::Buffer, vk::DeviceMemory)>
{
  let buffer_info = vk::BufferCreateInfo::builder()
                        .size(size)
                        .usage(usage)
                        .sharing_mode(vk::SharingMode::EXCLUSIVE);

  let buffer = unsafe { device.create_buffer(&buffer_info, None) }?;

  //   The requirements are mostly what you'd think: size and alignment. The
  // bits field is something special; see pick_memory_type() for the
  // explanation. Despite the simplicity of this data, Vulkan wants to be the
  // one to tell us about it, and we let it.
  let requirements = unsafe { device.get_buffer_memory_requirements(buffer) };

  let type_index = pick_memory_type(instance, physical_device,
                                    &memory_flags, &requirements)?;


  let memory_info = vk::MemoryAllocateInfo::builder()
                        .allocation_size(requirements.size)
                        .memory_type_index(type_index);

  let device_memory = unsafe { device.allocate_memory(&memory_info, None) }?;

  unsafe { device.bind_buffer_memory(buffer, device_memory, 0) }?;

  Ok((buffer, device_memory))
}


#[allow(unsafe_code)]
fn init_command_pool(device: &Device, indices: &QueueFamilyIndices)
    -> Result<vk::CommandPool>
{
  let command_pool_info = vk::CommandPoolCreateInfo::builder()
                              .flags(vk::CommandPoolCreateFlags::empty())
                              .queue_family_index(indices.graphics);

  Ok(unsafe {
    device.create_command_pool(&command_pool_info, None)
  }?)
}


#[allow(unsafe_code)]
fn init_commands(device: &Device,
                 extent: &vk::Extent2D,
                 framebuffers: &Vec<vk::Framebuffer>,
                 render_pass: &vk::RenderPass,
                 pipeline: &vk::Pipeline,
                 vertex_buffer: &vk::Buffer,
                 command_pool: &vk::CommandPool)
    -> Result<Vec<vk::CommandBuffer>>
{
  let command_buffer_allocation_info
          = vk::CommandBufferAllocateInfo::builder()
                .command_pool(*command_pool)
                .level(vk::CommandBufferLevel::PRIMARY)
                .command_buffer_count(framebuffers.len() as u32);
  let command_buffers = unsafe {
    device.allocate_command_buffers(&command_buffer_allocation_info)
  }?;

  for (index, framebuffer) in framebuffers.iter().enumerate() {
    let command_buffer = command_buffers[index];

    let inheritance_info = vk::CommandBufferInheritanceInfo::builder();

    let command_buffer_begin_info
            = vk::CommandBufferBeginInfo::builder()
                  .flags(vk::CommandBufferUsageFlags::empty())
                  .inheritance_info(&inheritance_info);

    unsafe {
      device.begin_command_buffer(command_buffer,
                                  &command_buffer_begin_info)
    }?;

    let render_area = vk::Rect2D::builder()
                          .offset(vk::Offset2D::default())
                          .extent(*extent);

    let clear_value = vk::ClearValue {
      color: vk::ClearColorValue {
        float32: [0.0, 0.0, 0.0, 1.0]
      }
    };
    let clear_values = [clear_value];

    let begin_pass_info = vk::RenderPassBeginInfo::builder()
                              .render_pass(*render_pass)
                              .framebuffer(*framebuffer)
                              .render_area(render_area)
                              .clear_values(&clear_values);

    unsafe {
      device.cmd_begin_render_pass(command_buffer, &begin_pass_info,
                                   vk::SubpassContents::INLINE)
    };

    unsafe {
      device.cmd_bind_pipeline(command_buffer,
                               vk::PipelineBindPoint::GRAPHICS,
                               *pipeline)
    };

    unsafe {
      device.cmd_bind_vertex_buffers(command_buffer, 0,
                                     &[*vertex_buffer], &[0])
    };

    unsafe {
      device.cmd_draw(command_buffer, VERTICES.len() as u32, 1, 0, 0)
    };

    unsafe { device.cmd_end_render_pass(command_buffer) };

    unsafe { device.end_command_buffer(command_buffer) }?;
  }

  Ok(command_buffers)
}


#[allow(unsafe_code)]
fn init_concurrency(device: &Device,
                    swapchain_images: &Vec<vk::Image>)
    -> Result<Concurrency>
{
  let semaphore_info = vk::SemaphoreCreateInfo::builder();
  let fence_info = vk::FenceCreateInfo::builder()
                       .flags(vk::FenceCreateFlags::SIGNALED);

  let mut image_available_semaphores = Vec::new();
  let mut rendering_finished_semaphores = Vec::new();
  let mut frame_fences = Vec::new();
  for _ in 0 .. N_SIMULTANEOUS_FRAMES {
    image_available_semaphores.push(unsafe {
      device.create_semaphore(&semaphore_info, None)
    }?);

    rendering_finished_semaphores.push(unsafe {
      device.create_semaphore(&semaphore_info, None)
    }?);

    frame_fences.push(unsafe {
      device.create_fence(&fence_info, None)
    }?);
  }

  let mut image_fences = Vec::new();
  for _ in 0 .. swapchain_images.len() {
    image_fences.push(vk::Fence::null());
  }

  Ok(Concurrency {
    image_available_semaphores,
    rendering_finished_semaphores,
    frame_fences,
    image_fences: image_fences,
  })
}


fn pick_surface_format(available_formats: &Vec<vk::SurfaceFormatKHR>)
    -> Result<vk::SurfaceFormatKHR>
{
  for format in available_formats {
    if format.format == vk::Format::B8G8R8A8_SRGB
       && format.color_space == vk::ColorSpaceKHR::SRGB_NONLINEAR
    {
      return Ok(format.clone());
    }
  }

  return Ok(available_formats[0].clone());
}


fn pick_presentation_mode(_available_modes: &Vec<vk::PresentModeKHR>)
    -> Result<vk::PresentModeKHR>
{
  // It's guaranteed to have this one.
  return Ok(vk::PresentModeKHR::FIFO);
}


fn pick_image_extent(window: &Window,
                     capabilities: vk::SurfaceCapabilitiesKHR)
    -> Result<vk::Extent2D>
{
  if capabilities.current_extent.width != u32::MAX
     && capabilities.current_extent.height != u32::MAX
  {
    Ok(capabilities.current_extent)
  } else {
    let window_size = window.inner_size();

    let width = window_size.width
                           .clamp(capabilities.min_image_extent.width,
                                  capabilities.max_image_extent.width);
    let height = window_size.height
                            .clamp(capabilities.min_image_extent.height,
                                   capabilities.max_image_extent.height);

    Ok(vk::Extent2D::builder().width(width).height(height).build())
  }
}


#[allow(unsafe_code)]
fn pick_memory_type(instance: &Instance,
                    physical_device: &vk::PhysicalDevice,
                    properties: &vk::MemoryPropertyFlags,
                    requirements: &vk::MemoryRequirements)
    -> Result<u32>
{
  let memory_map = unsafe {
    instance.get_physical_device_memory_properties(*physical_device)
  };

  //   So. The memory_type_bits field is a map of which indices are suitable,
  // based on the buffer our caller passed to
  // get_buffer_memory_requirements(). Yes, that means there's a hard cap on
  // how many memory types there can be, based on the size of the bitfield.
  for index in 0 .. memory_map.memory_type_count {
    if requirements.memory_type_bits & (1 << index) == 0 {
      continue;
    }

    let memory_type = memory_map.memory_types[index as usize];

    if memory_type.property_flags.contains(*properties) {
      return Ok(index);
    }
  }

  Err(Error {
    message: "The system has no suitable memory for a buffer.".to_string()
  })
}