#include "SDL.h"
#include "SDL_vulkan.h"
#include <vulkan/vulkan.h>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600

const char * validationLayers[1] = {"VK_LAYER_KHRONOS_validiation"};
#ifdef NDEBUG
    const int enableValidationLayers = 0;
#else
    const int enableValidationLayers = 1;
#endif

int checkValidationLayerSupport()
{
  uint32_t layerCount;
  vkEnumerateInstanceLayerProperties(&layerCount, 0);
  VkLayerProperties* availableLayers = malloc(sizeof(VkLayerProperties *) * layerCount);
  vkEnumerateInstanceLayerProperties(&layerCount,availableLayers);
  int layerFound = 0;
  for (int i=0; i < layerCount; i++ )
  {
    VkLayerProperties  props = availableLayers[i];
    if (strcmp(validationLayers[0],props.layerName) == 0)
    {
      layerFound = 1;
      break;
    }
  }
  if (!layerFound) return 0;
  return 1;
}

void createInstance()
{
  if (enableValidationLayers && !checkValidationLayerSupport())
  {
     return;
  }

}

int main(int argc, char ** argv) {
  /* Declare window and renderer */
  SDL_Window * window;
  // SDL_Renderer * renderer;

  /* Initialize SDL */
  SDL_Init(SDL_INIT_EVERYTHING);
  window = SDL_CreateWindow("sdlvulkan",
                            SDL_WINDOWPOS_CENTERED,
                            SDL_WINDOWPOS_CENTERED,
                            WINDOW_WIDTH, WINDOW_HEIGHT,
                            SDL_WINDOW_VULKAN | SDL_WINDOW_SHOWN);

  VkInstance instance  = VK_NULL_HANDLE;

  VkApplicationInfo app_info = { 0 };
  app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
  app_info.apiVersion = VK_API_VERSION_1_3;
  app_info.pApplicationName = "test-app";
  app_info.applicationVersion = VK_MAKE_API_VERSION(1, 0, 0, 0);
  app_info.pEngineName = "test-engine";
  app_info.engineVersion = VK_MAKE_API_VERSION(1, 0, 0, 0);

  VkInstanceCreateInfo instance_info = { 0 };
  instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
  instance_info.pApplicationInfo = &app_info;
  instance_info.enabledLayerCount = 0;
  instance_info.ppEnabledLayerNames = NULL;

  unsigned int count = 0;
  SDL_Vulkan_GetInstanceExtensions(window, &count, NULL);
  const char** extensions = malloc(sizeof(char*) * count);
  SDL_Vulkan_GetInstanceExtensions(window, &count, extensions);
  instance_info.enabledExtensionCount = count;
  instance_info.ppEnabledExtensionNames = extensions;
  VkResult result = vkCreateInstance(&instance_info, NULL, &instance) ;



  VkSurfaceKHR surface = VK_NULL_HANDLE;
  SDL_Vulkan_CreateSurface(window, instance, &surface);
  uint32_t n;
  vkEnumeratePhysicalDevices(instance, &n, 0);
  VkPhysicalDevice * devices = malloc(sizeof(VkPhysicalDevice)*n);
  vkEnumeratePhysicalDevices(instance, &n, devices);

  VkPhysicalDevice physicalDevice = devices[0];
  float priorities[1] = {0.0};

  VkDeviceQueueCreateInfo queueCreateInfo = {};
  queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
  queueCreateInfo.queueFamilyIndex = 0;
  queueCreateInfo.queueCount = 1;
  queueCreateInfo.pQueuePriorities = priorities;
  queueCreateInfo.pNext = NULL;

  VkPhysicalDeviceFeatures deviceFeatures;

  VkDeviceCreateInfo createInfo = {};
  createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
  createInfo.pNext = NULL;
  createInfo.pQueueCreateInfos = &queueCreateInfo;
  createInfo.queueCreateInfoCount = 1;
  createInfo.pEnabledFeatures = &deviceFeatures;
  VkDevice device;
  vkCreateDevice(physicalDevice,&createInfo,0,&device);
  VkQueue graphicsQueue;
  vkGetDeviceQueue(device,0,0,&graphicsQueue);



  while (    !SDL_QuitRequested()) {
    // SD    L_RenderClear(renderer);
    // /*     Place your simulation code and rendering code here */
    // SDL_RenderPresent(renderer);
  }

  // /* Deinitialize everything */
  // SDL_DestroyRenderer(renderer);
  SDL_DestroyWindow(window);
   SDL_Quit();

  return 0;
}