module;
#define VK_NO_PROTOTYPES
#define VK_USE_PLATFORM_XLIB_KHR
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_core.h>
#include <vulkan/vulkan_xlib.h>

export module renderer.backend.vk.library_wrapper;
import std;
// import renderer.backend.vk.library_loader;

namespace lt::renderer::vk {

class Device
{
public:
	struct CreateInfo
	{
		std::vector<VkDeviceQueueCreateInfo> queue_create_infos;

		std::vector<std::string> layers;

		std::vector<std::string> extensions;

		VkPhysicalDeviceFeatures2 features;
	};

	Device() = default;

	Device(CreateInfo info)
	{
	}

	~Device()
	{
		if (m_device)
		{
			vk_destroy_device(m_device, nullptr);
		}
	}

private:
	VkDevice m_device {};
};

}; // namespace lt::renderer::vk

export namespace lt::renderer::vk {

using Version_T = uint32_t;

struct ApplicationInfo
{
	std::string_view name;

	Version_T version;

	std::string_view *engine_name;

	Version_T engine_version;

	Version_T api_version;
};

[[nodiscard]]
auto enumerate_instance_extension_properties() -> std::vector<VkExtensionProperties>
{
	auto count = 0u;
	vkc(vk_enumerate_instance_extension_properties(nullptr, &count, nullptr));

	auto extensions = std::vector<VkExtensionProperties>(count);
	std::memset(extensions.data(), 0, extensions.size() * sizeof(VkExtensionProperties));
	vkc(vk_enumerate_instance_extension_properties(nullptr, &count, extensions.data()));

	return extensions;
}

struct VkInstanceCreateInfo
{
	VkInstanceCreateFlags flags;

	ApplicationInfo application_info;

	std::vector<const char **> layers;

	std::vector<const char **> extensions;

	const void *next;
};

class Instance
{
};

[[nodiscard]] auto create_instance() -> VkInstance
{
	return VkInstanceCreateInfo
	{
	}
}

} // namespace lt::renderer::vk