#ifndef _VKSETUP_H
#define _VKSETUP_H
/* Start header file */

/**
  vulkan setup and basic vector math

  Single header file with included implementation in the spirit of
  stb_*                          <https://github.com/nothings/stb>

  ASSUMPTIONS:
  ~~~~~~~~~~~~
  - Using SDL2 for the window
  - Using cglm for maths
  - Using shaderc for compiling glsl
  - Using vulkan(!)

  This is not meant to be a generic werapper around vulkan. It is actively
  paired and chaned by the currently in development application, whatever that
  might be. Think of it as the vulkan setup configuratior and helper.

  USAGE:
  ~~~~~~
   Do this:
      #define VKSETUP_IMPLEMENTATION
   before you include this file in *one* C or C++ file to create the implementation.

   // i.e. it should look like this:
   #include ...
   #include ...
   #include ...
   #define VKSETUP_IMPLEMENTATION
   #include "vksetup.h"

 */

#include <vulkan/vulkan_core.h>
#define SDL_MAIN_HANDLED
#define VK_USE_PLATFORM_XCB_KHR
#include <stdarg.h>

#include <SDL2/SDL.h>
#include <SDL2/SDL_vulkan.h>

#include <vulkan/vulkan.h>
#include <vulkan/vk_enum_string_helper.h> // for string_VkResult

#include <shaderc/shaderc.h>

#include "../lib/cglm/include/cglm/cglm.h"

#define VK_ARRAY_LEN(arr) sizeof((arr))/sizeof((arr)[0])

#ifdef __clang__
#define __FILENAME__ __FILE_NAME__
#else
#define __FILENAME__ __FILE__
#endif

#define VK_CHECK(x)                                   \
do {                                                  \
  VkResult err = x;                                   \
  if (err < 0) {                                      \
    fprintf(stderr, "src/%s:%d:0: vulkan error: %s   \n", \
    __FILENAME__, __LINE__, string_VkResult(err));        \
    abort();                                          \
  }                                                   \
} while (0)

typedef enum {
  VK_INFO = 0,
  VK_WARN,
  VK_ERROR,
} log_type;

static inline void
_vk_log(log_type t, const char * f, ...)
{
#ifdef VKDEBUG
  va_list args;
  va_start(args, f);
  switch (t) {
  case VK_INFO:
    printf("INFO: ");
    vprintf(f, args);
    break;
  case VK_WARN:
    fprintf(stderr, "WARN: ");
    vfprintf(stderr, f, args);
    break;
  case VK_ERROR:
    fprintf(stderr, "ERROR: ");
    vfprintf(stderr, f, args);
    break;
  }
  va_end(args);
#else
  return;
#endif
}

#ifdef VKDEBUG
#define vk_log(t, ...) do {                                \
  fprintf(t == VK_INFO ? stdout : stderr, "src/%s:%d:0: ", \
  __FILENAME__, __LINE__);                                 \
  _vk_log(t, __VA_ARGS__);                                 \
} while(0)
#else
#define vk_log(t, ...)
#endif

/**********/
/* config */
/**********/

const char *const validation_layers[] = {
  "VK_LAYER_KHRONOS_validation"
};
const uint32_t validation_layer_count = VK_ARRAY_LEN(validation_layers);

const char *const device_extensions[] = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
};
const uint32_t deviceExtensionCount = VK_ARRAY_LEN(device_extensions);

#ifdef VKDEBUG
    const bool enableValidationLayers = true;
#else
    const bool enableValidationLayers = false;
#endif



#ifdef __cplusplus
extern "C" {
#endif

#ifndef VKSDEF
#ifdef VKS_STATIC
#define VKSDEF static
#else
#define VKSDEF extern
#endif
#endif

// TODO Create structs for vulkan data

typedef struct vks_swapchain {
  VkSwapchainKHR handle;

  VkFormat image_format;
  VkExtent2D extent;

  uint32_t image_count;
  VkImage images[5];
  VkImageView image_views[5]; // 5 for some reason
} vks_swapchain;

typedef struct vks_buffer {
  VkBuffer handle;
  VkDeviceMemory memory;
} vks_buffer;

typedef struct vks_image {
  VkImage handle;
  VkDeviceMemory memory;
  VkImageView view;
} vks_image;

typedef struct vks_pipeline {
  VkPipeline handle;
  VkPipelineLayout layout;
} vks_pipeline;

typedef struct vks_context {
  VkInstance instance;
  VkPhysicalDevice physical_device;
  VkDevice device;

  SDL_Window *window;
  VkSurfaceKHR surface;

  vks_swapchain swapchain;
} vks_context;

typedef struct vks_frame_data {
  VkCommandBuffer vk_command_buffer;

  VkSemaphore image_available_semaphore;
  VkSemaphore render_finished_semaphore;
  VkFence in_flight_fence;

  vks_buffer uniform_buffer;
  void * uniform_buffer_mapped;

  VkDescriptorSet vk_descriptor_set;
} vks_frame_data;

/* Info structs  */
typedef struct vks_command_info
{
  vks_context   vk;
  VkCommandPool pool;
  VkQueue       queue;
} vks_command_info;

typedef struct vks_transition_image_layout_info
{
  /* command */
  vks_command_info     cmd_info;
  /* image */
  VkImage              image;
  VkFormat             format;
  VkAccessFlags        srcAccessMask;
  VkAccessFlags        dstAccessMask;
  VkPipelineStageFlags srcStageMask;
  VkPipelineStageFlags dstStageMask;
  VkImageLayout        oldLayout;
  VkImageLayout        newLayout;
  uint32_t             mipLevels;
} vks_transition_image_layout_info;


/* Exported API */
VKSDEF VkInstance vks_create_instance         (bool validation_layers_toggle, const char * const validation_layers[], uint32_t validation_layer_count, SDL_Window *window);
VKSDEF void       vks_create_buffer           (const vks_context vk, const VkDeviceSize size, const VkBufferUsageFlags usage, const VkMemoryPropertyFlags properties, vks_buffer *buffer);
VKSDEF void       vks_create_image            (const vks_context vk, const uint32_t width, const uint32_t height, const uint32_t mipLevels, const VkFormat format, const VkImageTiling tiling, const VkImageUsageFlags usage, const VkMemoryPropertyFlags properties, const VkSampleCountFlagBits numSamples, vks_image *image);
VKSDEF void       vks_transition_image_layout (const vks_transition_image_layout_info *info);
VKSDEF void       vks_copy_buffer             (const vks_command_info *cmd_info, const VkBuffer src_buffer, VkBuffer dst_buffer, const VkDeviceSize size);
VKSDEF void       vks_copy_buffer_to_image    (const vks_command_info* cmd_info, const VkBuffer buffer, VkImage  image, const uint32_t width, const uint32_t height);
VKSDEF void       vks_generate_mipmaps        (const vks_command_info* cmd_info, VkImage  image, const VkFormat imageFormat, const int32_t  texWidth, const int32_t  texHeight, const uint32_t mipLevels);

/* VKSDEF void vulkan_create_surface(); */
/* VKSDEF void vulkan_pick_physical_device(); */
/* VKSDEF void vulkan_create_logical_device(); */
/* VKSDEF void vulkan_create_swap_chain(); */
/* VKSDEF void vulkan_create_image_views(); */
/* VKSDEF void vulkan_create_descriptor_set_layout(); */
/* VKSDEF void vulkan_create_graphics_pipeline(); */
/* VKSDEF void vulkan_create_command_pool(); */
/* VKSDEF void vulkan_create_depth_resources(); */
/* VKSDEF void vulkan_create_texture_image(); */
/* VKSDEF void vulkan_create_texture_image_view(); */
/* VKSDEF void vulkan_create_texture_sampler(); */
/* VKSDEF void vulkan_create_vertex_buffer(); */
/* VKSDEF void vulkan_create_index_buffer(); */
/* VKSDEF void vulkan_create_uniform_buffers(); */
/* VKSDEF void vulkan_create_descriptor_pool(); */
/* VKSDEF void vulkan_create_descriptor_sets(); */
/* VKSDEF void vulkan_create_command_buffer(); */
/* VKSDEF void vulkan_create_sync_objects(); */

#ifdef __cplusplus
}
#endif

/* End header file */
#endif  /* _VKSETUP_H */

#ifdef VKSETUP_IMPLEMENTATION

#include <stddef.h>
#include <stdlib.h>
#include <time.h>

/* Vks helpers */

bool
vks_check_validation_layer_support(const char* const validation_layers[],
                                   uint32_t          validation_layer_count)
{
  uint32_t layerCount;
  vkEnumerateInstanceLayerProperties(&layerCount, NULL);

  VkLayerProperties availableLayers[layerCount];
  vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);

  bool layerFound = false;
  for (uint32_t i = 0; i < validation_layer_count; i++) {
    for (uint32_t j = 0; j < layerCount; j++) {
      if (strcmp(validation_layers[i], availableLayers[j].layerName) == 0) {
        layerFound = true;
        break;
      }
    }
  }

  return layerFound;
}

uint32_t
find_memory_type(const vks_context           vk,
                 const uint32_t              typeFilter,
                 const VkMemoryPropertyFlags properties)
{
  VkPhysicalDeviceMemoryProperties mem_properties;
  vkGetPhysicalDeviceMemoryProperties(vk.physical_device, &mem_properties);

  for (uint32_t i = 0; i < mem_properties.memoryTypeCount; i++) {
    if ((typeFilter & (1 << i)) &&
        (mem_properties.memoryTypes[i].propertyFlags & properties) ==
          properties) {
      return i;
    }
  }

  vk_log(VK_ERROR, "failed to find suitable memory type!\n");
  return 9999;
}

VkCommandBuffer
begin_single_time_commands(const vks_command_info *info)
{
  VkCommandBufferAllocateInfo allocInfo = {0};
  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
  allocInfo.commandPool = info->pool;
  allocInfo.commandBufferCount = 1;

  VkCommandBuffer commandBuffer;
  VK_CHECK(vkAllocateCommandBuffers(info->vk.device, &allocInfo, &commandBuffer));

  VkCommandBufferBeginInfo beginInfo = {0};
  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
  beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;

  VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));

  return commandBuffer;
}

void
end_single_time_commands(const vks_command_info *info, VkCommandBuffer command_buffer)
{
  VK_CHECK(vkEndCommandBuffer(command_buffer));

  VkSubmitInfo submitInfo = {0};
  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
  submitInfo.commandBufferCount = 1;
  submitInfo.pCommandBuffers = &command_buffer;

  VK_CHECK(vkQueueSubmit(info->queue, 1, &submitInfo, VK_NULL_HANDLE));
  VK_CHECK(vkQueueWaitIdle(info->queue));

  vkFreeCommandBuffers(info->vk.device, info->pool, 1, &command_buffer);
}

int
has_stencil_component(VkFormat format)
{
  return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
}

/* Vks API implementation */
VKSDEF void
vks_generate_mipmaps(const vks_command_info* cmd_info,
                     VkImage  image,
                     const VkFormat imageFormat,
                     const int32_t  texWidth,
                     const int32_t  texHeight,
                     const uint32_t mipLevels)
{
  VkCommandBuffer command_buffer = begin_single_time_commands(cmd_info);

  VkImageMemoryBarrier barrier = {0};
  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
  barrier.image = image;
  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  barrier.subresourceRange.baseArrayLayer = 0;
  barrier.subresourceRange.layerCount = 1;
  barrier.subresourceRange.levelCount = 1;

  int32_t mipWidth = texWidth;
  int32_t mipHeight = texHeight;

  for (uint32_t i = 1; i < mipLevels; i++) {
    barrier.subresourceRange.baseMipLevel = i - 1;
    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
    barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;

    vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                         VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1,
                         &barrier);

    VkImageBlit blit = {0};
    blit.srcOffsets[0] = (VkOffset3D){ 0, 0, 0 };
    blit.srcOffsets[1] = (VkOffset3D){ mipWidth, mipHeight, 1 };
    blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    blit.srcSubresource.mipLevel = i - 1;
    blit.srcSubresource.baseArrayLayer = 0;
    blit.srcSubresource.layerCount = 1;
    blit.dstOffsets[0] = (VkOffset3D){ 0, 0, 0 };
    blit.dstOffsets[1] = (VkOffset3D){ mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, 1 };
    blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    blit.dstSubresource.mipLevel = i;
    blit.dstSubresource.baseArrayLayer = 0;
    blit.dstSubresource.layerCount = 1;

    vkCmdBlitImage(command_buffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                   image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
                   VK_FILTER_LINEAR);

    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
    barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
    barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

    vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                         VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0,
                         NULL, 1, &barrier);

    if (mipWidth > 1) mipWidth /= 2;
    if (mipHeight > 1) mipHeight /= 2;
  }

  end_single_time_commands(cmd_info, command_buffer);
}

VKSDEF void
vks_copy_buffer_to_image(const vks_command_info* cmd_info,
                         const VkBuffer buffer,
                         VkImage  image,
                         const uint32_t width,
                         const uint32_t height)
{
  VkCommandBuffer command_buffer = begin_single_time_commands(cmd_info);

  VkBufferImageCopy region = {0};
  region.bufferOffset = 0;
  region.bufferRowLength = 0;
  region.bufferImageHeight = 0;

  region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  region.imageSubresource.mipLevel = 0;
  region.imageSubresource.baseArrayLayer = 0;
  region.imageSubresource.layerCount = 1;

  region.imageOffset = (VkOffset3D){0, 0, 0};
  region.imageExtent = (VkExtent3D){width, height, 1};

  vkCmdCopyBufferToImage(command_buffer,
                         buffer,
                         image,
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                         1,
                         &region
                         );

  end_single_time_commands(cmd_info, command_buffer);
}

VKSDEF void
vks_copy_buffer(const vks_command_info *cmd_info, const VkBuffer src_buffer, VkBuffer dst_buffer, const VkDeviceSize size)
{
  VkCommandBuffer command_buffer = begin_single_time_commands(cmd_info);

  VkBufferCopy copy_region = {0};
  copy_region.srcOffset = 0; // Optional
  copy_region.dstOffset = 0; // Optional
  copy_region.size = size;
  vkCmdCopyBuffer(command_buffer, src_buffer, dst_buffer, 1, &copy_region);

  end_single_time_commands(cmd_info, command_buffer);
}

VKSDEF void
vks_transition_image_layout(const vks_transition_image_layout_info *info)
{
  VkCommandBuffer command_buffer = begin_single_time_commands(&info->cmd_info);

  VkImageMemoryBarrier barrier = { 0 };
  barrier.sType                = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
  barrier.srcAccessMask        = info->srcAccessMask;
  barrier.dstAccessMask        = info->dstAccessMask;
  barrier.oldLayout            = info->oldLayout;
  barrier.newLayout            = info->newLayout;
  barrier.srcQueueFamilyIndex  = VK_QUEUE_FAMILY_IGNORED;
  barrier.dstQueueFamilyIndex  = VK_QUEUE_FAMILY_IGNORED;
  barrier.image                = info->image;

  // barrier.subresourceRange.aspectMask =
  if (info->newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;

    if (has_stencil_component(info->format)) {
      barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
    }
  } else {
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  }

  barrier.subresourceRange.baseMipLevel   = 0;
  barrier.subresourceRange.levelCount     = info->mipLevels;
  barrier.subresourceRange.baseArrayLayer = 0;
  barrier.subresourceRange.layerCount     = 1;

  vkCmdPipelineBarrier(command_buffer,
                       info->srcStageMask,
                       info->dstStageMask,
                       0,
                       0,
                       NULL,
                       0,
                       NULL,
                       1,
                       &barrier);

  end_single_time_commands(&info->cmd_info, command_buffer);
}

VKSDEF void
vks_create_image(const vks_context           vk,
                 const uint32_t              width,
                 const uint32_t              height,
                 const uint32_t              mipLevels,
                 const VkFormat              format,
                 const VkImageTiling         tiling,
                 const VkImageUsageFlags     usage,
                 const VkMemoryPropertyFlags properties,
                 const VkSampleCountFlagBits numSamples,
                 vks_image*                  image)
{
  VkImageCreateInfo imageInfo = { 0 };
  imageInfo.sType             = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
  imageInfo.imageType         = VK_IMAGE_TYPE_2D;
  imageInfo.extent.width      = width;
  imageInfo.extent.height     = height;
  imageInfo.extent.depth      = 1;
  imageInfo.mipLevels         = mipLevels;
  imageInfo.arrayLayers       = 1;
  imageInfo.format            = format;
  imageInfo.tiling            = tiling;
  imageInfo.initialLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
  imageInfo.usage             = usage;
  imageInfo.samples           = numSamples;
  imageInfo.sharingMode       = VK_SHARING_MODE_EXCLUSIVE;

  VK_CHECK(vkCreateImage(vk.device, &imageInfo, NULL, &image->handle));

  VkMemoryRequirements memRequirements;
  vkGetImageMemoryRequirements(vk.device, image->handle, &memRequirements);

  VkMemoryAllocateInfo allocInfo = { 0 };
  allocInfo.sType                = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  allocInfo.allocationSize       = memRequirements.size;
  allocInfo.memoryTypeIndex =
    find_memory_type(vk, memRequirements.memoryTypeBits, properties);

  // TODO: group allocations etc... (allocations limited by hardware)
  VK_CHECK(vkAllocateMemory(vk.device, &allocInfo, NULL, &image->memory));

  vkBindImageMemory(vk.device, image->handle, image->memory, 0);
}

VKSDEF void
vks_create_buffer(const vks_context           vk,
                  const VkDeviceSize          size,
                  const VkBufferUsageFlags    usage,
                  const VkMemoryPropertyFlags properties,
                  vks_buffer*                 buffer)
{
  VkBufferCreateInfo bufferInfo = { 0 };
  bufferInfo.sType              = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  bufferInfo.size               = size;
  bufferInfo.usage              = usage;
  bufferInfo.sharingMode        = VK_SHARING_MODE_EXCLUSIVE;

  VK_CHECK(vkCreateBuffer(vk.device, &bufferInfo, NULL, &buffer->handle));

  VkMemoryRequirements mem_requirements;
  vkGetBufferMemoryRequirements(vk.device, buffer->handle, &mem_requirements);

  VkMemoryAllocateInfo allocInfo = { 0 };
  allocInfo.sType                = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  allocInfo.allocationSize       = mem_requirements.size;
  allocInfo.memoryTypeIndex =
    find_memory_type(vk, mem_requirements.memoryTypeBits, properties);

  // TODO: group allocations etc... (allocations limited by hardware)
  VK_CHECK(vkAllocateMemory(vk.device, &allocInfo, NULL, &buffer->memory));
  VK_CHECK(vkBindBufferMemory(vk.device, buffer->handle, buffer->memory, 0));
}

VKSDEF VkInstance
vks_create_instance(bool              validation_layers_toggle,
                    const char* const validation_layers[],
                    uint32_t          validation_layer_count,
                    SDL_Window*       window)
{
  if (validation_layers_toggle &&
      !vks_check_validation_layer_support(validation_layers,
                                          validation_layer_count)) {
    vk_log(VK_ERROR, "validation layers requested, but not available!\n");
    abort();
  }

  uint32_t instanceVersion;
  VkResult result = vkEnumerateInstanceVersion(&instanceVersion);
  if (result == VK_SUCCESS) {
    if (instanceVersion < VK_MAKE_API_VERSION(0, 1, 3, 0)) {
      vk_log(VK_ERROR, "Vulkan version 1.3 or greater required!\n");
      exit(1);
    }
    vk_log(VK_INFO,
           "Vulkan version found (%d) %d.%d.%d\n",
           VK_API_VERSION_VARIANT(instanceVersion),
           VK_API_VERSION_MAJOR(instanceVersion),
           VK_API_VERSION_MINOR(instanceVersion),
           VK_API_VERSION_PATCH(instanceVersion));
  } else {
    vk_log(VK_ERROR,
           "Failed to retrieve vulkan version, is vulkan supported in this "
           "system?\n");
    exit(1);
  }

  // Load Vulkan and create instance
  VkApplicationInfo appInfo = {
    .sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO,
    .pApplicationName   = "Vulkan Application",
    .applicationVersion = VK_MAKE_API_VERSION(0, 1, 3, 0),
    .pEngineName        = NULL,
    .engineVersion      = VK_MAKE_API_VERSION(0, 1, 3, 0),
    .apiVersion         = VK_MAKE_API_VERSION(0, 1, 3, 0),
  };

  uint32_t sdlExtensionCount = 0;

  if (SDL_Vulkan_GetInstanceExtensions(window, &sdlExtensionCount, NULL) ==
      SDL_FALSE) {
    vk_log(VK_ERROR,
           "SDL_Vulkan_GetInstanceExtensions failed: %s\n",
           SDL_GetError());
    abort();
  }

  // make space for debug extenetion
  if (validation_layers_toggle) {
    sdlExtensionCount++;
  }

  const char* sdlExtensions[sdlExtensionCount];

  if (SDL_Vulkan_GetInstanceExtensions(
        window, &sdlExtensionCount, sdlExtensions) == SDL_FALSE) {
    vk_log(VK_ERROR,
           "SDL_Vulkan_GetInstanceExtensions failed: %s\n",
           SDL_GetError());
    abort();
  }

  // add debug extenetion
  if (validation_layers_toggle) {
    sdlExtensions[sdlExtensionCount] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
  }

  vk_log(VK_INFO, "The sdl extensions:\n");
  for (uint32_t i = 0; i < sdlExtensionCount; i++) {
    vk_log(VK_INFO, "\t%s\n", sdlExtensions[i]);
  }

  VkInstanceCreateInfo createInfo = {
    .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
    .pApplicationInfo        = &appInfo,
    .enabledExtensionCount   = sdlExtensionCount,
    .ppEnabledExtensionNames = sdlExtensions,
    .enabledLayerCount       = 0,
  };

  if (validation_layers_toggle) {
    createInfo.enabledLayerCount   = validation_layer_count;
    createInfo.ppEnabledLayerNames = validation_layers;
  }

  VkInstance instance;

  if (vkCreateInstance(&createInfo, NULL, &instance) != VK_SUCCESS) {
    vk_log(VK_ERROR, "Can't start vulkan instance\n");
  }
  vk_log(VK_INFO, "Vulkan instance created\n");

  return instance;
}

#endif /* VKSETUP_IMPLEMENTATION */