#if OS_WINDOWS

#define VK_PLATFORM_SURFACE_EXTENSION VK_KHR_WIN32_SURFACE_EXTENSION_NAME

static void *Vk_LoadLibrary() {
	void *result = LoadLibraryA("vulkan-1.dll");

	if (result != 0) {
		vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) GetProcAddress(result, "vkGetInstanceProcAddr");
	}

	return result;
}

static void Vk_CreateSurface(SDL_Window *window) {
	SDL_PropertiesID prop_id = SDL_GetWindowProperties(window);

	VkWin32SurfaceCreateInfoKHR create_info = { 0 };
	create_info.sType     = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
	create_info.hinstance = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER, 0);
	create_info.hwnd      = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WIN32_HWND_POINTER, 0);

	vk.err = vk.CreateWin32SurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
}

#elif OS_LINUX

#define VK_PLATFORM_SURFACE_EXTENSION \
	VK_KHR_XLIB_SURFACE_EXTENSION_NAME, \
	VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME

static void *Vk_LoadLibrary() {
	void *result = dlopen("libvulkan.so", RTLD_LAZY);

	if (result != 0) {
		vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) dlsym(result, "vkGetInstanceProcAddr");
	}

	return result;
}

static void Vk_CreateSurface(SDL_Window *window) {
	SDL_PropertiesID prop_id = SDL_GetWindowProperties(window);

	struct wl_display *wl_display = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER, 0);
	if (wl_display == 0) {
		// Assume we are running via X11 if there isn't a vaild Wayland display
		//
		VkXlibSurfaceCreateInfoKHR create_info = { 0 };
		create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
		create_info.dpy    = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_X11_DISPLAY_POINTER, 0);
		create_info.window = SDL_GetNumberProperty(prop_id, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);

		vk.err = vk.CreateXlibSurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
	}
	else {
		VkWaylandSurfaceCreateInfoKHR create_info = { 0 };
		create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
		create_info.display = wl_display;
		create_info.surface = SDL_GetPointerProperty(prop_id, SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, 0);

		vk.err = vk.CreateWaylandSurfaceKHR(vk.instance, &create_info, 0, &vk.surface);
	}
}

#endif

Vk_Context vk;

bool Vk_Setup(SDL_Window *window) {
	bool result = false;

	vk.lib = Vk_LoadLibrary();

	// Create instance
	//
	if (vk.err == VK_SUCCESS) {
		vk.CreateInstance = (PFN_vkCreateInstance) vk.GetInstanceProcAddr(0, "vkCreateInstance");

		const char *extensions[] = {
			VK_KHR_SURFACE_EXTENSION_NAME,
			VK_PLATFORM_SURFACE_EXTENSION,

			#if !LD_RELEASE
				VK_EXT_DEBUG_UTILS_EXTENSION_NAME
			#endif
		};

		const char *layers[] = {
			"VK_LAYER_KHRONOS_validation"
		};

		U32 n_layers = LD_RELEASE ? 0 : ArraySize(layers);

		VkApplicationInfo app = { 0 };
		app.sType      = VK_STRUCTURE_TYPE_APPLICATION_INFO;
		app.apiVersion = VK_API_VERSION_1_3; // I know 1.4 is out

		VkInstanceCreateInfo create_info = { 0 };
		create_info.sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
		create_info.pApplicationInfo        = &app;
		create_info.ppEnabledExtensionNames = extensions;
		create_info.enabledExtensionCount   = ArraySize(extensions);
		create_info.ppEnabledLayerNames     = layers;
		create_info.enabledLayerCount       = n_layers;

		vk.err = vk.CreateInstance(&create_info, 0, &vk.instance);
	}

	// Load instance level functions and create window surface
	//
	if (vk.err == VK_SUCCESS) {
		#define VK_INSTANCE_FUNCTIONS
		#define VK_FUNC(x) vk.x = (PFN_vk##x) vk.GetInstanceProcAddr(vk.instance, Stringify(Glue(vk, x)))
			#include "functions.h"
		#undef VK_FUNC

		Vk_CreateSurface(window);
	}

	// Select GPU
	//
	if (vk.err == VK_SUCCESS) {
		VkPhysicalDevice devices[8] = { 0 };
		U32 n_devices;

		vk.EnumeratePhysicalDevices(vk.instance, &n_devices, 0);
		vk.EnumeratePhysicalDevices(vk.instance, &n_devices, devices);

		vk.gpu = devices[0];

		for (U32 it = 0; it < n_devices; ++it) {
			VkPhysicalDeviceProperties props;
			vk.GetPhysicalDeviceProperties(devices[it], &props);

			if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
				vk.gpu = devices[it];
				break;
			}
		}

		if (vk.gpu != VK_NULL_HANDLE) {
			VkQueueFamilyProperties qprops[32] = { 0 };
			U32 n_qprops = 0;

			vk.GetPhysicalDeviceQueueFamilyProperties(vk.gpu, &n_qprops, 0);
			vk.GetPhysicalDeviceQueueFamilyProperties(vk.gpu, &n_qprops, qprops);

			for (U32 it = 0; it < n_qprops; ++it) {
				if (qprops[it].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
					// Assumed combined graphics-present queue, this is the case on all desktop class
					// gpus
					vk.queue.family = it;
					break;
				}
			}
		}
	}
	else {
		printf("[Error] :: Failed to create instance\n");
	}

	// Create logical device
	//
	if (vk.gpu != VK_NULL_HANDLE) {
		const char *extensions[] = {
			VK_KHR_SWAPCHAIN_EXTENSION_NAME
		};

		VkPhysicalDeviceVulkan11Features features11 = { 0 };
		features11.sType                              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
		features11.storageBuffer16BitAccess           = VK_TRUE;
		features11.uniformAndStorageBuffer16BitAccess = VK_TRUE;

		VkPhysicalDeviceVulkan12Features features12 = { 0 };
		features12.sType                             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
		features12.pNext                             = &features11;
		features12.shaderFloat16                     = VK_TRUE;
		features12.shaderInt8                        = VK_TRUE;
		features12.storageBuffer8BitAccess           = VK_TRUE;
		features12.uniformAndStorageBuffer8BitAccess = VK_TRUE;
		features12.descriptorIndexing                = VK_TRUE;

		// @Todo: we will probably need to enable some of the 'nonuniform' indexing features

		VkPhysicalDeviceVulkan13Features features13 = { 0 };
		features13.sType            = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
		features13.pNext            = &features12;
		features13.synchronization2 = VK_TRUE;
		features13.dynamicRendering = VK_TRUE;

		F32 priority = 1.0f;

		VkDeviceQueueCreateInfo queue_info = { 0 };
		queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
		queue_info.queueFamilyIndex = vk.queue.family;
		queue_info.queueCount       = 1;
		queue_info.pQueuePriorities = &priority;

		VkDeviceCreateInfo create_info = { 0 };
		create_info.sType                   = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
		create_info.pNext                   = &features13;
		create_info.queueCreateInfoCount    = 1;
		create_info.pQueueCreateInfos       = &queue_info;
		create_info.enabledExtensionCount   = ArraySize(extensions);
		create_info.ppEnabledExtensionNames = extensions;
		create_info.pEnabledFeatures        = 0;

		vk.err = vk.CreateDevice(vk.gpu, &create_info, 0, &vk.device);
	}
	else {
		printf("[Error] :: Failed to find suitable GPU\n");
		vk.err = VK_ERROR_DEVICE_LOST;
	}

	if (vk.err == VK_SUCCESS) {
		// Load device level functions and acquire the device queue
		#define VK_DEVICE_FUNCTIONS
		#define VK_FUNC(x) vk.x = (PFN_vk##x) vk.GetDeviceProcAddr(vk.device, Stringify(Glue(vk, x)))
			#include "functions.h"
		#undef VK_FUNC

		vk.GetDeviceQueue(vk.device, vk.queue.family, 0, &vk.queue.handle);

		// Create swapchain
		U32 n_images = 2;
		{
			VkSurfaceCapabilitiesKHR caps;
			vk.GetPhysicalDeviceSurfaceCapabilitiesKHR(vk.gpu, vk.surface, &caps);

			if (caps.currentExtent.width == -1) {
				int w, h;
				SDL_GetWindowSizeInPixels(window, &w, &h);

				vk.swapchain.width  = w;
				vk.swapchain.height = h;
			}
			else {
				vk.swapchain.width  = caps.currentExtent.width;
				vk.swapchain.height = caps.currentExtent.height;
			}

			n_images = Max(n_images, caps.minImageCount);
		}

		{
			VkSurfaceFormatKHR formats[32];
			U32 n_formats = 0;

			vk.GetPhysicalDeviceSurfaceFormatsKHR(vk.gpu, vk.surface, &n_formats, 0);
			vk.GetPhysicalDeviceSurfaceFormatsKHR(vk.gpu, vk.surface, &n_formats, formats);

			vk.swapchain.format = formats[0];

			for (U32 it = 0; it < n_formats; ++it) {
				VkSurfaceFormatKHR *fmt = &formats[it];

				if ((fmt->format == VK_FORMAT_B8G8R8A8_SRGB) ||
				    (fmt->format == VK_FORMAT_R8G8B8A8_SRGB))
				{
					if (fmt->colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
						vk.swapchain.format = formats[it];
						break;
					}
				}
			}
		}

		VkSwapchainCreateInfoKHR create_info = { 0 };
		create_info.sType            = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
		create_info.surface          = vk.surface;
		create_info.minImageCount    = n_images;
		create_info.imageFormat      = vk.swapchain.format.format;
		create_info.imageColorSpace  = vk.swapchain.format.colorSpace;
		create_info.imageExtent      = (VkExtent2D) { vk.swapchain.width, vk.swapchain.height };
		create_info.imageArrayLayers = 1;
		create_info.imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
		create_info.preTransform     = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
		create_info.compositeAlpha   = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
		create_info.presentMode      = VK_PRESENT_MODE_FIFO_KHR;
		create_info.clipped          = VK_TRUE;

		vk.err = vk.CreateSwapchainKHR(vk.device, &create_info, 0, &vk.swapchain.handle);

		vk.swapchain.n_images = n_images;
	}
	else {
		printf("[Error] :: Failed to create device\n");
	}

	if (vk.err == VK_SUCCESS) {
		// Get the swapchain images and create image views using them
		U32 n_images = 0;
		vk.GetSwapchainImagesKHR(vk.device, vk.swapchain.handle, &n_images, 0);
		vk.GetSwapchainImagesKHR(vk.device, vk.swapchain.handle, &n_images, vk.swapchain.images);

		vk.in_flight = n_images + 1;

		if (n_images != vk.swapchain.n_images) {
			printf("[Warn] :: Swapchain image count mismatch\n");
			vk.swapchain.n_images = n_images;
		}
		else if (n_images >= VK_MAX_FRAMES_IN_FLIGHT) {
			printf("[Warn] :: Min image count too high: %d\n", n_images);
			vk.in_flight = VK_MAX_FRAMES_IN_FLIGHT;
		}

		VkImageViewCreateInfo create_info = { 0 };
		create_info.sType    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
		create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
		create_info.format   = vk.swapchain.format.format;

		create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
		create_info.subresourceRange.levelCount = 1;
		create_info.subresourceRange.layerCount = 1;

		for (U32 it = 0; it < n_images && vk.err == VK_SUCCESS; ++it) {
			create_info.image = vk.swapchain.images[it];
			vk.err = vk.CreateImageView(vk.device, &create_info, 0, &vk.swapchain.views[it]);
		}
	}

	for (U32 it = 0; it < vk.in_flight && vk.err == VK_SUCCESS; ++it) {
		Vk_Frame *frame = &vk.frames[it];

		VkCommandPoolCreateInfo pool = { 0 };
		pool.sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
		pool.flags            = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
		pool.queueFamilyIndex = vk.queue.family;

		VkResult err = vk.CreateCommandPool(vk.device, &pool, 0, &frame->pool);

		VkCommandBufferAllocateInfo alloc = { 0 };
		alloc.sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
		alloc.commandBufferCount = 1;
		alloc.level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
		alloc.commandPool        = frame->pool;

		vk.AllocateCommandBuffers(vk.device, &alloc, &frame->cmd);

		VkSemaphoreCreateInfo semaphore = { 0 };
		semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire),  err);
		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);

		VkFenceCreateInfo fence = { 0 };
		fence.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
		fence.flags = VK_FENCE_CREATE_SIGNALED_BIT;

		err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->fence), err);

		vk.err = err;
	}

	result = (vk.err == VK_SUCCESS);
	return result;
}

Vk_Frame *Vk_FrameBegin(SDL_Window *window) {
	(void) window; // might need this for the resize later
	Vk_Frame *frame = &vk.frames[vk.n_frames % vk.in_flight];

	vk.WaitForFences(vk.device, 1, &frame->fence, VK_TRUE, UINT64_MAX);

	vk.ResetFences(vk.device, 1, &frame->fence);
	vk.ResetCommandPool(vk.device, frame->pool, 0);

	VkResult res = vk.AcquireNextImageKHR(vk.device, vk.swapchain.handle, UINT64_MAX, frame->acquire, 0, &frame->image);
	(void) res; // @Todo: check res to see if swapchain is out of date and rebuild

	VkCommandBufferBeginInfo begin_info = { 0 };
	begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

	vk.BeginCommandBuffer(frame->cmd, &begin_info);

	return frame;
}

void Vk_FrameEnd() {
	Vk_Frame *frame = &vk.frames[vk.n_frames % vk.in_flight];

	vk.EndCommandBuffer(frame->cmd);

	VkPipelineStageFlags stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;

	VkSubmitInfo submit = { 0 };
	submit.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submit.waitSemaphoreCount   = 1;
	submit.pWaitSemaphores      = &frame->acquire;
	submit.pWaitDstStageMask    = &stage;
	submit.commandBufferCount   = 1;
	submit.pCommandBuffers      = &frame->cmd;
	submit.signalSemaphoreCount = 1;
	submit.pSignalSemaphores    = &frame->complete;

	vk.QueueSubmit(vk.queue.handle, 1, &submit, frame->fence);

	VkPresentInfoKHR present = { 0 };
	present.sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
	present.waitSemaphoreCount = 1;
	present.pWaitSemaphores    = &frame->complete;
	present.swapchainCount     = 1;
	present.pSwapchains        = &vk.swapchain.handle;
	present.pImageIndices      = &frame->image;

	vk.QueuePresentKHR(vk.queue.handle, &present);

	vk.n_frames += 1;
}