#ifndef LEARN_VULKAN_VULKANCOMMON_H
#define LEARN_VULKAN_VULKANCOMMON_H

#include <vadefs.h>
#include <vulkan/vulkan.h>
#include <cstdio>
#include <vector>
#include <array>
#include <fstream>

#define VK_ALLOC nullptr
#define APP_NAME "Learn Vulkan"

typedef struct
{
    const char      *name;
    bool			validationOnly;
    bool			required;
} DriverFeature;

static const char*
vk_error_string(VkResult result) {
    switch (result) {
        case VK_SUCCESS:
            return "VK_SUCCESS";
        case VK_NOT_READY:
            return "VK_NOT_READY";
        case VK_TIMEOUT:
            return "VK_TIMEOUT";
        case VK_EVENT_SET:
            return "VK_EVENT_SET";
        case VK_EVENT_RESET:
            return "VK_EVENT_RESET";
        case VK_INCOMPLETE:
            return "VK_INCOMPLETE";
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            return "VK_ERROR_OUT_OF_HOST_MEMORY";
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
        case VK_ERROR_INITIALIZATION_FAILED:
            return "VK_ERROR_INITIALIZATION_FAILED";
        case VK_ERROR_DEVICE_LOST:
            return "VK_ERROR_DEVICE_LOST";
        case VK_ERROR_MEMORY_MAP_FAILED:
            return "VK_ERROR_MEMORY_MAP_FAILED";
        case VK_ERROR_LAYER_NOT_PRESENT:
            return "VK_ERROR_LAYER_NOT_PRESENT";
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            return "VK_ERROR_EXTENSION_NOT_PRESENT";
        case VK_ERROR_FEATURE_NOT_PRESENT:
            return "VK_ERROR_FEATURE_NOT_PRESENT";
        case VK_ERROR_INCOMPATIBLE_DRIVER:
            return "VK_ERROR_INCOMPATIBLE_DRIVER";
        case VK_ERROR_TOO_MANY_OBJECTS:
            return "VK_ERROR_TOO_MANY_OBJECTS";
        case VK_ERROR_FORMAT_NOT_SUPPORTED:
            return "VK_ERROR_FORMAT_NOT_SUPPORTED";
        case VK_ERROR_SURFACE_LOST_KHR:
            return "VK_ERROR_SURFACE_LOST_KHR";
        case VK_SUBOPTIMAL_KHR:
            return "VK_SUBOPTIMAL_KHR";
        case VK_ERROR_OUT_OF_DATE_KHR:
            return "VK_ERROR_OUT_OF_DATE_KHR";
        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
            return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
            return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
        case VK_ERROR_VALIDATION_FAILED_EXT:
            return "VK_ERROR_VALIDATION_FAILED_EXT";
        default: {
            if (result == VK_ERROR_INVALID_SHADER_NV) {
                return "VK_ERROR_INVALID_SHADER_NV";
            }
            return "unknown";
        }
    }
}

typedef enum {
    DBG,
    INF,
    WRN,
    ERR,
    TRACE
} LOG_LEVEL;

#define NONE                  "\e[0m"           //清除颜色，即之后的打印为正常输出，之前的不受影响
#define BLACK                 "\e[0;30m"        //深黑
#define L_BLACK               "\e[1;30m"        //亮黑，偏灰褐
#define RED                   "\e[0;31m"        //深红，暗红
#define L_RED                 "\e[1;31m"        //鲜红
#define GREEN                 "\e[0;32m"        //深绿，暗绿
#define L_GREEN               "\e[1;32m"        //鲜绿
#define BROWN                 "\e[0;33m"        //深黄，暗黄
#define YELLOW                "\e[1;33m"        //鲜黄
#define BLUE                  "\e[0;34m"        //深蓝，暗蓝
#define L_BLUE                "\e[1;34m"        //亮蓝，偏白灰
#define PURPLE                "\e[0;35m"        //深粉，暗粉，偏暗紫
#define L_PURPLE              "\e[1;35m"        //亮粉，偏白灰
#define CYAN                  "\e[0;36m"        //暗青色
#define L_CYAN                "\e[1;36m"        //鲜亮青色
#define GRAY                  "\e[0;37m"        //灰色
#define WHITE                 "\e[1;37m"        //白色，字体粗一点，比正常大，比bold小
#define BOLD                  "\e[1m"           //白色，粗体
#define UNDERLINE             "\e[4m"           //下划线，白色，正常大小
#define BLINK                 "\e[5m"           //闪烁，白色，正常大小
#define REVERSE               "\e[7m"           //反转，即字体背景为白色，字体为黑色
#define HIDE                  "\e[8m"           //隐藏
#define CLEAR                 "\e[2J"           //清除
#define CLRLINE               "\r\e[K"          //清除行

static const int buffsize = 1024;
static char buff[buffsize];

static void
my_debug(LOG_LEVEL level, const char *format, ...)
{
    va_list va;
    va_start(va, format);
#ifdef _WIN32
    vsprintf_s(buff, buffsize, format, va);
#else
    vsprintf(buff, format, va);
#endif
    va_end(va);

    if(level == ERR){
        printf(RED "%s\n", buff);
    } else if(level == WRN){
        printf(BROWN "%s\n", buff);
    } else {
        printf(NONE "%s\n", buff);
    }
    fflush(stdout);
}

#ifndef Print
#define Print(...) ((void)my_debug(DBG, __VA_ARGS__))
#endif

#ifndef Warn
#define Warn(...) ((void)my_debug(WRN, __VA_ARGS__))
#endif

#ifndef Error
#define Error(...) ((void)my_debug(ERR, __VA_ARGS__))
#endif

static void
vk_check_errors(VkResult result, const char *file_name, const int line_number, const char *function){
    if(VK_SUCCESS != result){
        Error( "[%s, %d]: %s: %s\n", file_name, line_number, function, vk_error_string( result ) );
    }
}

/**
 * 层/扩展验证
 * @param label 提示名，用作日志输出使用
 * @param validationEnabled 是否启用验证，如果为否，直接跳过
 * @param extensions 是否属于扩展验证，层验证时为false，扩展验证时为true
 * @param requested 待验证列表
 * @param requestedCount 待验证数量
 * @param available 全部的功能列表，从vkEnumerateXxxLayerProperties或vkEnumerateXxxExtensionProperties获取
 * @param availableCount 全部功能数量
 * @param enabledNames 输出的可用功能名称数组
 * @param enabledCount 输出的可用功能数量
 * @return 操作是否成功
 */
static bool
checkFeatures(const char *label, const bool validationEnabled, const bool extensions,
                   const DriverFeature *requested, const uint32_t requestedCount,
                   const void *available, const uint32_t availableCount,
                   const char *enabledNames[], uint32_t *enabledCount){

#if 1
    Print("%s available: ", label);
    for(int i = 0; i < availableCount; i++){
        const char * name = extensions ? ((const VkExtensionProperties *)available)[i].extensionName : ((const VkLayerProperties *)available)[i].layerName;
        Print("%s", name);
    }
#endif
    bool foundAllRequired = true;
    *enabledCount = 0;
    for ( uint32_t i = 0; i < requestedCount; i++ )
    {
        bool found = false;
        const char *result = requested[i].required ? "(required, not found)" : "(not found)";
        for ( uint32_t j = 0; j < availableCount; j++ )
        {
            const char * name = extensions ? ((const VkExtensionProperties *)available)[j].extensionName :
                                ((const VkLayerProperties *)available)[j].layerName;
            if ( strcmp( requested[i].name, name ) == 0 )
            {
                found = true;
                if ( requested[i].validationOnly && !validationEnabled )
                {
                    result = "(not enabled)";
                    break;
                }
                enabledNames[(*enabledCount)++] = requested[i].name;
                result = requested[i].required ? "(required, enabled)" : "(enabled)";
                break;
            }
        }
        foundAllRequired &= ( found || !requested[i].required );
        Print( "%-21s%c %s %s", ( i == 0 ? label : "" ), ( i == 0 ? ':' : ' ' ), requested[i].name, result );
    }
    return foundAllRequired;
}

#define CALL_VK(func) vk_check_errors(func, __FILE__, __LINE__, #func);
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#endif //LEARN_VULKAN_VULKANCOMMON_H