#include "external/vulkan.h"
#include "com/Window.h"
#include "01 Instance and Devices/03 Connecting with a Vulkan Loader library.h"
#include "01 Instance and Devices/05 Loading function exported from a Vulkan Loader library.h"
#include "01 Instance and Devices/06 Loading global-level functions.h"
#include "01 Instance and Devices/07 Checking available Instance extensions.h"
#include "02 Image Presentation/02 Creating a presentation surface.h"
#include "02 Image Presentation/01 Creating a Vulkan Instance with WSI extensions enabled.h"
#include "02 Image Presentation/03 Selecting a queue family that supports presentation to a given surface.h"
#include <01 Instance and Devices/10 Enumerating available physical devices.h>
#include <01 Instance and Devices/09 Loading instance-level functions.h>
#include <02 Image Presentation/04 Creating a logical device with WSI extensions enabled.h>
#include <02 Image Presentation/05 Selecting a desired presentation mode.h>
#include <02 Image Presentation/06 Getting capabilities of a presentation surface.h>
#include <02 Image Presentation/07 Selecting a number of swapchain images.h>
#include <02 Image Presentation/08 Choosing a size of swapchain images.h>
#include <02 Image Presentation/09 Selecting desired usage scenarios of swapchain images.h>
#include <02 Image Presentation/10 Selecting a transformation of swapchain images.h>
#include <02 Image Presentation/11 Selecting a format of swapchain images.h>
#include <02 Image Presentation/12 Creating a swapchain.h>

using namespace VulkanCookbook;
WindowParameters createWindow() {
	WindowParameters   window_parameters{};
	const char* name = "hello window";
	window_parameters.HInstance = WindowClass::GetInstance();
	// create window & get hWnd
	auto hWnd = CreateWindow(
		WindowClass::GetName(), name,
		WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
		CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
		nullptr, nullptr, WindowClass::GetInstance(), nullptr
	);
	window_parameters.HWnd = hWnd;
	return window_parameters;
}
int main() {
	//加载dll
	LIBRARY_TYPE vulkan_library;
	ConnectWithVulkanLoaderLibrary(vulkan_library);

	//加载vulkan接口
	LoadFunctionExportedFromVulkanLoaderLibrary(vulkan_library);

	//调用vulkan接口，加载全局函数指针
	LoadGlobalLevelFunctions();
	{
		//调用全局函数指针，检查实例扩展
		std::vector<VkExtensionProperties> available_extensions;
		CheckAvailableInstanceExtensions(available_extensions);
	}

	std::vector<char const*> desired_extensions;
	char* application_name = "hello world";
	VkInstance instance;
	CreateVulkanInstanceWithWsiExtensionsEnabled(desired_extensions, application_name,  instance);

	//调用vulkan接口，加载实例函数指针
	LoadInstanceLevelFunctions(instance, desired_extensions);
	//调用实例接口，获取物理设备列表
	std::vector<VkPhysicalDevice> available_devices;
	EnumerateAvailablePhysicalDevices(instance, available_devices);
	VkPhysicalDevice physical_device = available_devices[0];

	//调用实例接口，创建逻辑设备，并且检查是否支持交换链
	VkDevice logical_device;
	std::vector< QueueInfo >    queue_infos;
	VkPhysicalDeviceFeatures desired_features;
	CreateLogicalDeviceWithWsiExtensionsEnabled(physical_device, queue_infos, desired_extensions, &desired_features, logical_device);

	WindowParameters&& window_parameters = createWindow();
	VkSurfaceKHR presentation_surface;
	//调用实例接口，创建图像显示设备，需要传递窗口,并启用对应扩展
	CreatePresentationSurface(instance, window_parameters, presentation_surface);

	//调用实例接口，寻找支持与图像显示设备通信的命令队列
	uint32_t queue_family_index;
	SelectQueueFamilyThatSupportsPresentationToGivenSurface(physical_device, presentation_surface, queue_family_index);
	
	//调用实例接口，查询图像显示设备的显示模式
	VkPresentModeKHR   desired_present_mode{}, present_mode{};
	SelectDesiredPresentationMode(physical_device, presentation_surface, desired_present_mode, present_mode);
	
	//调用实例接口，查询图像显示设备的显示能力
	VkSurfaceCapabilitiesKHR surface_capabilities;
	GetCapabilitiesOfPresentationSurface(physical_device, presentation_surface, surface_capabilities);


	uint32_t number_of_images;
	SelectNumberOfSwapchainImages(surface_capabilities, number_of_images);

	VkExtent2D size_of_images;
	ChooseSizeOfSwapchainImages(surface_capabilities, size_of_images);

	VkImageUsageFlags     desired_usages{}, image_usage;
	SelectDesiredUsageScenariosOfSwapchainImages(surface_capabilities, desired_usages, image_usage);

	VkSurfaceTransformFlagBitsKHR    desired_transform{}, surface_transform;
	SelectTransformationOfSwapchainImages(surface_capabilities, desired_transform, surface_transform);

	VkFormat image_format;
	VkColorSpaceKHR image_color_space;
	VkSurfaceFormatKHR   desired_surface_format{};
	SelectFormatOfSwapchainImages(physical_device, presentation_surface, desired_surface_format, image_format, image_color_space);
	
	return 1;
}