#include "hk21/game/gpu.hpp"

#include <asl/buffer.hpp>
#include <asl/log/log.hpp>
#include <asl/format.hpp>

#include <SDL3/SDL_vulkan.h>

#include "hk21/vulkan_loader/api.hpp"

#define VK_ALLOCATOR nullptr

[[maybe_unused]] static void AslFormat(asl::Formatter& formatter, VkResult res)
{
    switch (res) // NOLINT
    {
    case VK_SUCCESS: formatter.write("VK_SUCCESS"); break;
    case VK_NOT_READY: formatter.write("VK_NOT_READY"); break;
    case VK_TIMEOUT: formatter.write("VK_TIMEOUT"); break;
    case VK_EVENT_SET: formatter.write("VK_EVENT_SET"); break;
    case VK_EVENT_RESET: formatter.write("VK_EVENT_RESET"); break;
    case VK_INCOMPLETE: formatter.write("VK_INCOMPLETE"); break;
    case VK_ERROR_OUT_OF_HOST_MEMORY: formatter.write("VK_ERROR_OUT_OF_HOST_MEMORY"); break;
    case VK_ERROR_OUT_OF_DEVICE_MEMORY: formatter.write("VK_ERROR_OUT_OF_DEVICE_MEMORY"); break;
    case VK_ERROR_INITIALIZATION_FAILED: formatter.write("VK_ERROR_INITIALIZATION_FAILED"); break;
    case VK_ERROR_DEVICE_LOST: formatter.write("VK_ERROR_DEVICE_LOST"); break;
    case VK_ERROR_MEMORY_MAP_FAILED: formatter.write("VK_ERROR_MEMORY_MAP_FAILED"); break;
    case VK_ERROR_LAYER_NOT_PRESENT: formatter.write("VK_ERROR_LAYER_NOT_PRESENT"); break;
    case VK_ERROR_EXTENSION_NOT_PRESENT: formatter.write("VK_ERROR_EXTENSION_NOT_PRESENT"); break;
    case VK_ERROR_FEATURE_NOT_PRESENT: formatter.write("VK_ERROR_FEATURE_NOT_PRESENT"); break;
    case VK_ERROR_INCOMPATIBLE_DRIVER: formatter.write("VK_ERROR_INCOMPATIBLE_DRIVER"); break;
    case VK_ERROR_TOO_MANY_OBJECTS: formatter.write("VK_ERROR_TOO_MANY_OBJECTS"); break;
    case VK_ERROR_FORMAT_NOT_SUPPORTED: formatter.write("VK_ERROR_FORMAT_NOT_SUPPORTED"); break;
    case VK_ERROR_FRAGMENTED_POOL: formatter.write("VK_ERROR_FRAGMENTED_POOL"); break;
    case VK_ERROR_UNKNOWN: formatter.write("VK_ERROR_UNKNOWN"); break;
    case VK_ERROR_OUT_OF_POOL_MEMORY: formatter.write("VK_ERROR_OUT_OF_POOL_MEMORY"); break;
    case VK_ERROR_INVALID_EXTERNAL_HANDLE: formatter.write("VK_ERROR_INVALID_EXTERNAL_HANDLE"); break;
    case VK_ERROR_FRAGMENTATION: formatter.write("VK_ERROR_FRAGMENTATION"); break;
    case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: formatter.write("VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"); break;
    case VK_PIPELINE_COMPILE_REQUIRED: formatter.write("VK_PIPELINE_COMPILE_REQUIRED"); break;
    case VK_ERROR_NOT_PERMITTED: formatter.write("VK_ERROR_NOT_PERMITTED"); break;
    case VK_ERROR_SURFACE_LOST_KHR: formatter.write("VK_ERROR_SURFACE_LOST_KHR"); break;
    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: formatter.write("VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"); break;
    case VK_SUBOPTIMAL_KHR: formatter.write("VK_SUBOPTIMAL_KHR"); break;
    case VK_ERROR_OUT_OF_DATE_KHR: formatter.write("VK_ERROR_OUT_OF_DATE_KHR"); break;
    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: formatter.write("VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"); break;
    case VK_ERROR_VALIDATION_FAILED_EXT: formatter.write("VK_ERROR_VALIDATION_FAILED_EXT"); break;
    case VK_ERROR_INVALID_SHADER_NV: formatter.write("VK_ERROR_INVALID_SHADER_NV"); break;
    case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: formatter.write("VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"); break;
    case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: formatter.write("VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"); break;
    case VK_THREAD_IDLE_KHR: formatter.write("VK_THREAD_IDLE_KHR"); break;
    case VK_THREAD_DONE_KHR: formatter.write("VK_THREAD_DONE_KHR"); break;
    case VK_OPERATION_DEFERRED_KHR: formatter.write("VK_OPERATION_DEFERRED_KHR"); break;
    case VK_OPERATION_NOT_DEFERRED_KHR: formatter.write("VK_OPERATION_NOT_DEFERRED_KHR"); break;
    case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: formatter.write("VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR"); break;
    case VK_ERROR_COMPRESSION_EXHAUSTED_EXT: formatter.write("VK_ERROR_COMPRESSION_EXHAUSTED_EXT"); break;
    case VK_INCOMPATIBLE_SHADER_BINARY_EXT: formatter.write("VK_INCOMPATIBLE_SHADER_BINARY_EXT"); break;
    case VK_PIPELINE_BINARY_MISSING_KHR: formatter.write("VK_PIPELINE_BINARY_MISSING_KHR"); break;
    case VK_ERROR_NOT_ENOUGH_SPACE_KHR: formatter.write("VK_ERROR_NOT_ENOUGH_SPACE_KHR"); break;
    default: formatter.write("Unknown Vulkan error"); break;
    }
}

namespace gpu
{

class GpuImpl : public Gpu
{
    bool m_destroyed{};
    
    VkInstance     m_instance;
    VkSurfaceKHR   m_surface;

public:
    GpuImpl(VkInstance instance, VkSurfaceKHR surface)
        : m_instance{instance}
        , m_surface{surface}
    {}

    ASL_DELETE_COPY_MOVE(GpuImpl);

    ~GpuImpl() override
    {
        ASL_ASSERT(m_destroyed);
    }
    
    void destroy() override
    {
        ASL_ASSERT(!m_destroyed);
        m_destroyed = true;
        vkDestroySurfaceKHR(m_instance, m_surface, VK_ALLOCATOR);
        vkDestroyInstance(m_instance, VK_ALLOCATOR);
    }
};

static asl::status_or<VkInstance> create_instance()
{
    asl::buffer<const char*> instance_extensions;
    asl::buffer<const char*> layers;
    {
        uint32_t count = 0;
        const char* const* extensions = SDL_Vulkan_GetInstanceExtensions(&count);
        for (uint32_t i = 0; i < count; ++i)
        {
            instance_extensions.push(extensions[i]); // NOLINT(*-pointer-arithmetic)
        }
    }

    layers.push("VK_LAYER_KHRONOS_validation");
    layers.push("VK_LAYER_LUNARG_monitor");

    instance_extensions.push(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    
    auto vkGetInstanceProcAddr = asl::bit_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
    auto status = vulkan_loader::load_global(vkGetInstanceProcAddr);
    ASL_TRY(status);

    uint32_t version{};
    vkEnumerateInstanceVersion(&version);

    uint32_t vk_major = VK_API_VERSION_MAJOR(version); // NOLINT
    uint32_t vk_minor = VK_API_VERSION_MINOR(version); // NOLINT

    if (vk_major != 1 || vk_minor < 3)
    {
        return asl::runtime_error("Incompatible Vulkan version: {}.{}", vk_major, vk_minor);
    }
    
    VkApplicationInfo app_info{
        .sType                = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext                = nullptr,
        .pApplicationName     = "HK-21",
        .applicationVersion   = 0,
        .pEngineName          = "Custom",
        .engineVersion        = 0,
        .apiVersion           = VK_MAKE_API_VERSION(0, 1, 3, 0), // NOLINT
    };

    VkInstanceCreateInfo instance_create_info{
        .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext                   = nullptr,
        .flags                   = 0,
        .pApplicationInfo        = &app_info,
        .enabledLayerCount       = static_cast<uint32_t>(layers.size()),
        .ppEnabledLayerNames     = layers.data(),
        .enabledExtensionCount   = static_cast<uint32_t>(instance_extensions.size()),
        .ppEnabledExtensionNames = instance_extensions.data(),
    };

    VkInstance instance{};
    VkResult res = vkCreateInstance(&instance_create_info, VK_ALLOCATOR, &instance);
    if (res != VK_SUCCESS)
    {
        return asl::runtime_error("Couldn't create Vulkan instance: {}", res);
    }
    
    status = vulkan_loader::load_instance(vkGetInstanceProcAddr, instance);
    ASL_TRY(status);

    return instance;
}

static asl::status_or<VkSurfaceKHR> create_surface(SDL_Window* window, VkInstance instance)
{
    VkSurfaceKHR surface{};
    if (!SDL_Vulkan_CreateSurface(window, instance, VK_ALLOCATOR, &surface))
    {
        return asl::runtime_error("Couldn't create Vulkan surface");
    }

    return surface;
}

asl::status_or<asl::box<Gpu>> init(SDL_Window* window)
{
    auto instance = create_instance();
    ASL_TRY(instance);

    auto surface = create_surface(window, instance.value());
    ASL_TRY(surface);

    // asl::buffer<const char*> device_extensions;
    // device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);

    return asl::make_box<GpuImpl>(instance.value(), surface.value());
};

} // namespace gpu