#define GLFW_INCLUDE_NONE
#define GLFW_INCLUDE_VULKAN

#include <cstring>
#include <cstdio>
#include <vector>
#include <cassert>

#include "window.hpp"

#define NELEMS(x)  (sizeof(x) / sizeof((x)[0]))

GLFWwindow *window = nullptr;
VkInstance vkInstance = nullptr;
VkPhysicalDevice vkPhysicalDevice = nullptr;
VkSurfaceKHR vkSurfaceKHR = nullptr;
VkDebugReportCallbackEXT vkDebugReport = nullptr;

const bool ENABLE_VALIDATION_LAYERS = true;
const bool VULKAN_DEBUG_REPORT = true;

const std::vector<const char *> REQUIRED_EXTENSIONS = std::vector<const char *> {
	VK_KHR_SWAPCHAIN_EXTENSION_NAME
};

VkBool32 UserDebugCallback(
		VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
		VkDebugUtilsMessageTypeFlagsEXT messageType,
		const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData) {
	printf("Validation Layer: %s\n", pCallbackData->pMessage);
	return VK_FALSE;
}

static VKAPI_ATTR VkBool32 VKAPI_CALL DebugReport(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, unsigned long object, size_t location, int messageCode, const char *pLayerPrefix, const char *pMessage, void *pUserData) {
	(void)flags;
	(void)object;
	(void)location;
	(void)messageCode;
	(void)pUserData;
	(void)pLayerPrefix; // Unused arguments
	fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n", objectType, pMessage);
	return VK_FALSE;
}

unsigned int FindQueueFamilyIndex(VkPhysicalDevice device, short hasPresentSupport = -1, VkQueueFlagBits includeBits = (VkQueueFlagBits)0U, VkQueueFlagBits excludeBits = (VkQueueFlagBits)0U) {

	if (hasPresentSupport == -1 && includeBits == 0 && excludeBits == 0) {
		return 0U;
	}

	unsigned int queueFamilyPropertyCount = 0U;
	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, nullptr);
	std::vector<VkQueueFamilyProperties> queueFamilyProperties(queueFamilyPropertyCount);
	vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyPropertyCount, queueFamilyProperties.data());

	for (unsigned int i = 0; i < queueFamilyProperties.size(); i++) {
		if (includeBits != 0 && (queueFamilyProperties[i].queueFlags & includeBits) == 0) {
			continue;
		}
		if (excludeBits != 0 && (queueFamilyProperties[i].queueFlags & excludeBits) != 0) {
			continue;
		}
		if (hasPresentSupport != -1) {
			VkBool32 presentSupport;
			vkGetPhysicalDeviceSurfaceSupportKHR(device, i, vkSurfaceKHR, &presentSupport);
			if (presentSupport != hasPresentSupport) {
				continue;
			}
		}
		return i;
	}

	return 0xFFFFFFFF;
}

void InitVulkan() {

	if (ENABLE_VALIDATION_LAYERS) {
		unsigned int layerCount;
		vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
		std::vector<VkLayerProperties> availableLayers(layerCount);
		vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
		printf("Available Layers:\n");
		for (const auto &layerProperties : availableLayers) {
			printf("\t%s\n", layerProperties.layerName);
		}
	}

	VkApplicationInfo appInfo{};
	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	appInfo.apiVersion = VK_API_VERSION_1_3;
	appInfo.pApplicationName = "pikul";
	appInfo.pEngineName = "pikul";
	appInfo.applicationVersion = 1;
	appInfo.engineVersion = 1;

	VkInstanceCreateInfo createInfo{};
	createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	createInfo.pApplicationInfo = &appInfo;
	createInfo.enabledLayerCount = 0;

	std::vector<const char *> enabledLayerNames(1);
	enabledLayerNames[0] = "VK_LAYER_KHRONOS_validation";
	printf("Requested Layers:\n");
	for (const char *s : enabledLayerNames) {
		printf("\t%s\n", s);
	}
	VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
	debugCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
	if (ENABLE_VALIDATION_LAYERS) {
		createInfo.enabledLayerCount = enabledLayerNames.size();
		createInfo.ppEnabledLayerNames = enabledLayerNames.data();
		
		debugCreateInfo.messageSeverity = 
    	VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
    	VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
    	VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
		debugCreateInfo.messageType = 
    	VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
    	VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
    	VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
		debugCreateInfo.pfnUserCallback = UserDebugCallback;
		debugCreateInfo.pUserData = nullptr;
		debugCreateInfo.pNext = nullptr;
		createInfo.pNext = &debugCreateInfo;
	}

	std::vector<const char *> allGlfwExtensions;
	{
		unsigned int extensionCount = 0;
		const char **glfwExtensions = glfwGetRequiredInstanceExtensions(&extensionCount);
		allGlfwExtensions.reserve(extensionCount + 2);
		copy(&glfwExtensions[0], &glfwExtensions[extensionCount], back_inserter(allGlfwExtensions));

		if (ENABLE_VALIDATION_LAYERS) {
			allGlfwExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
			allGlfwExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
		}
		createInfo.ppEnabledExtensionNames = allGlfwExtensions.data();
		createInfo.enabledExtensionCount = allGlfwExtensions.size();
	}
	printf("Required Extensions:\n");
	for (const auto &ext : allGlfwExtensions) {
		printf("\t%s\n", ext);
	}

	if (ENABLE_VALIDATION_LAYERS) {
		unsigned int extensionCount = 0;
		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
		std::vector<VkExtensionProperties> extensions(extensionCount);
		vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
		printf("Available Extensions:\n");
		for (const auto &extension : extensions) {
			printf("\t%s\n", extension.extensionName);
		}
	}

	auto result = vkCreateInstance(&createInfo, nullptr, &vkInstance); 
	if (result != VK_SUCCESS) {
		printf("Failed to create VkInstance! : %d\n", result);
		throw result;
	}

	if (VULKAN_DEBUG_REPORT) {
		PFN_vkCreateDebugReportCallbackEXT func = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(vkInstance, "vkCreateDebugReportCallbackEXT");
		assert(func != nullptr && "vkCreateDebugReportCallbackEXT ProcAddr was nullptr");

		VkDebugReportCallbackCreateInfoEXT debugReportCallbackCreateInfo{};
		debugReportCallbackCreateInfo.flags =
			VK_DEBUG_REPORT_ERROR_BIT_EXT |
			VK_DEBUG_REPORT_WARNING_BIT_EXT |
			VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
		debugReportCallbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
		debugReportCallbackCreateInfo.pfnCallback = DebugReport;
		debugReportCallbackCreateInfo.pUserData = nullptr;

		VkResult result = func(vkInstance, &debugReportCallbackCreateInfo, nullptr, &vkDebugReport);

		if (result != VK_SUCCESS) {
			fprintf(stderr, "%s\n", "Failed to create debug report!");
		}
	}

	// create surface
	if (glfwCreateWindowSurface(vkInstance, window, nullptr, &vkSurfaceKHR) != VK_SUCCESS) {
		throw "Failed to create window surface";
	}

	// pick physical device
	unsigned int physicalDeviceCount = 0;
	vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, nullptr);
	assert(physicalDeviceCount > 0);
	std::vector<VkPhysicalDevice> physicalDevices(physicalDeviceCount);
	vkEnumeratePhysicalDevices(vkInstance, &physicalDeviceCount, physicalDevices.data());
	for (const auto &device : physicalDevices)
	{
		// check queue families
		auto graphicsFamilyIndex = FindQueueFamilyIndex(device, -1, VK_QUEUE_GRAPHICS_BIT);
		auto presentFamilyIndex = FindQueueFamilyIndex(device, 1);
		if (graphicsFamilyIndex == 0xFFFFFFFF || presentFamilyIndex == 0xFFFFFFFF) {
			continue;
		}

		// check device extension support
		std::vector<const char *> requiredExtensions(REQUIRED_EXTENSIONS.begin(), REQUIRED_EXTENSIONS.end());
		unsigned int extensionCount = 0;
		vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
		std::vector<VkExtensionProperties> extensionProperties(extensionCount);
		vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, extensionProperties.data());
		for (const auto &property : extensionProperties) {
			auto it = requiredExtensions.begin();
			while (it != requiredExtensions.end()) {
				if (strcmp(*it.base(), property.extensionName)) {
					requiredExtensions.erase(it);
				} else {
					it++;
				}
			}
		}
		if (requiredExtensions.empty() == false) {
			continue;
		}

		// surface formats
		unsigned int surfaceCount = 0;
		vkGetPhysicalDeviceSurfaceFormatsKHR(device, vkSurfaceKHR, &surfaceCount, nullptr);
		if (surfaceCount == 0) {
			continue;
		}

		// check present modes
		unsigned int presentModeCount = 0;
		vkGetPhysicalDeviceSurfacePresentModesKHR(device, vkSurfaceKHR, &presentModeCount, nullptr);
		if (presentModeCount == 0) {
			continue;
		}

		vkPhysicalDevice = device;
		break;
	}
	assert(vkPhysicalDevice != nullptr && "Failed to find suitable physical device");

}

void CreateWindow(PKEWindowProperties *wp) {
	if (vkInstance != nullptr) return;
	glfwInit();
	glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
	window = glfwCreateWindow(wp->width, wp->height, "Pikul", nullptr, nullptr);
	InitVulkan();
}

void DestroyWindow() {
	if (VULKAN_DEBUG_REPORT) {
		auto vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(vkInstance, "vkDestroyDebugReportCallbackEXT");
		vkDestroyDebugReportCallbackEXT(vkInstance, vkDebugReport, nullptr);
	}
	if (vkInstance != nullptr) return;
	PFN_vkDestroyInstance(vkInstance);
	glfwDestroyWindow(window);
	glfwTerminate();
}