#include "Instance.hpp"

#include <stdexcept>

#include "Core/CoreInstance.hpp"
#include "DeviceFunctions/DeviceFunctions.hpp"
#include "Log/Log.hpp"

namespace VkObjects
{
#ifdef _DEBUG
    VkBool32 Instance::debugCallback(
        VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT messageType,
        const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
        void* pUserData) {

        std::string msg = "validation layer: ";
        msg += pCallbackData->pMessage;
        Loging::Log(msg);

        return VK_FALSE;
    }

    VkResult Instance::enable_layer_validation(const VkDebugUtilsMessengerCreateInfoEXT* create_info)
    {
        PFN_vkCreateDebugUtilsMessengerEXT debug_creator = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(vkGetInstanceProcAddr(instance_, "vkCreateDebugUtilsMessengerEXT"));
        return debug_creator(instance_, create_info, nullptr, &debug_messenger_);
    }
#endif

    std::vector<const char*> Instance::get_required_extensions()
    {
        uint32_t extensions_count = 0;
        const char** glfw_extension = glfwGetRequiredInstanceExtensions(&extensions_count);
        std::vector<const char*> extensions(glfw_extension, glfw_extension + extensions_count);

#ifdef _DEBUG
        extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
#endif
        return extensions;
    }

    Instance::Instance(CoreInstance& core)
    {
        std::vector<const char*> extensions = get_required_extensions();

        VkApplicationInfo app_info{};
        app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        app_info.apiVersion = VK_API_VERSION_1_0;
        app_info.applicationVersion = VK_MAKE_VERSION(0, 0, 0);
        app_info.pApplicationName = core.getGameName().c_str();
        app_info.pEngineName = "UwU Engine";
        app_info.engineVersion = VK_MAKE_VERSION(0, 0, 0);
        
        
        VkInstanceCreateInfo instance_create_info{};
        instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        instance_create_info.pApplicationInfo = &app_info;
        instance_create_info.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
        instance_create_info.ppEnabledExtensionNames = extensions.data();
#ifdef _DEBUG
        const std::vector<const char*> layers_validation = {
            "VK_LAYER_KHRONOS_validation"
        };
        instance_create_info.enabledLayerCount = static_cast<uint32_t>(layers_validation.size());
        instance_create_info.ppEnabledLayerNames = layers_validation.data();
        VkDebugUtilsMessengerCreateInfoEXT debug_messenger_create_info{};
        debug_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
        debug_messenger_create_info.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;
        debug_messenger_create_info.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;
        debug_messenger_create_info.pfnUserCallback = &Instance::debugCallback;
        instance_create_info.pNext = &debug_messenger_create_info;
#endif
        VK_CHECK(vkCreateInstance(&instance_create_info, nullptr, &instance_))
    #ifdef _DEBUG
        VK_CHECK(enable_layer_validation(&debug_messenger_create_info))
    #endif
    }

    Instance::~Instance()
    {
#ifdef _DEBUG
        if (debug_messenger_ != nullptr && instance_ != nullptr) {
            PFN_vkDestroyDebugUtilsMessengerEXT destroyer_messenger = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(vkGetInstanceProcAddr(instance_, "vkDestroyDebugUtilsMessengerEXT"));
            destroyer_messenger(instance_, debug_messenger_, nullptr);
        }
#endif
        if(instance_ != nullptr)
            vkDestroyInstance(instance_, nullptr);
    }
}