#include <iostream>
#include <vector>
#include "vulkan/vulkan.h"

int main() {
    VkApplicationInfo appinfo; // general app info
    appinfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appinfo.pNext = nullptr;
    appinfo.pApplicationName = "Test Vulkan";
    appinfo.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
    appinfo.pEngineName = "volukanEngine";
    appinfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
    appinfo.apiVersion = VK_API_VERSION_1_1;


    uint32_t amountOfLayers = 0;
    vkEnumerateInstanceLayerProperties(&amountOfLayers, NULL);
    VkLayerProperties *layers = new VkLayerProperties[amountOfLayers];
    vkEnumerateInstanceLayerProperties(&amountOfLayers, layers);

    std::cout << "amount of instance layers: " << amountOfLayers << std::endl;
    for (int i = 0; i < amountOfLayers; i++) {
        std::cout << "Name: " << layers[i].layerName << std::endl;
        std::cout << "Spec Version: " << layers[i].specVersion << std::endl;
        std::cout << "Description: " << layers[i].description << std::endl << std::endl;
    }

    const std::vector<const char *> validationLayers = {
            "VK_LAYER_NV_optimus"
    };

    VkInstanceCreateInfo instanceInfo;
    instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    instanceInfo.pNext = nullptr;
    instanceInfo.flags = 0;
    instanceInfo.pApplicationInfo = &appinfo;
    instanceInfo.enabledLayerCount = validationLayers.size();
    instanceInfo.ppEnabledLayerNames = validationLayers.data();
    instanceInfo.enabledExtensionCount = 0;
    instanceInfo.ppEnabledExtensionNames = nullptr;

    VkInstance instance;
    // create vulkan instance
    if (vkCreateInstance(&instanceInfo, nullptr, &instance) != VK_SUCCESS) {
        std::cout << "error on creating vkinstance" << std::endl;
    }

    std::cout << "detecting gpus." << std::endl;

    uint32_t physicaldevicesnumber = 0;
    if (vkEnumeratePhysicalDevices(instance, &physicaldevicesnumber, nullptr) != VK_SUCCESS) {
        std::cout << "error getting graphics number" << std::endl;
    }
    std::cout << "found " << physicaldevicesnumber << " GPUs" << std::endl;

    std::vector<VkPhysicalDevice> physicalDevices;
    physicalDevices.resize(physicaldevicesnumber);

//    VkPhysicalDevice *physicalDevice = new VkPhysicalDevice[physicaldevicesnumber];
    if (vkEnumeratePhysicalDevices(instance, &physicaldevicesnumber, physicalDevices.data()) != VK_SUCCESS) {
        std::cout << "error  getting graphics cards" << std::endl;
    }

    VkPhysicalDeviceProperties properties;
    for (int i = 0; i < physicaldevicesnumber; i++) {
        vkGetPhysicalDeviceProperties(physicalDevices.at(i), &properties);
        std::cout << "Device name: " << properties.deviceName << std::endl;
        std::cout << "API Version: " << VK_VERSION_MAJOR(properties.apiVersion) << "."
                  << VK_VERSION_MINOR(properties.apiVersion) << "." << VK_VERSION_PATCH(properties.apiVersion)
                  << std::endl;
        std::cout << "Driver Version: " << VK_VERSION_MAJOR(properties.driverVersion) << "."
                  << VK_VERSION_MINOR(properties.driverVersion) << "." << VK_VERSION_PATCH(properties.driverVersion)
                  << std::endl;

        std::cout << std::endl;
    }

    uint32_t amountOfExtensions = 0;
    vkEnumerateInstanceExtensionProperties(NULL, &amountOfExtensions, NULL);
    VkExtensionProperties *extensions = new VkExtensionProperties[amountOfExtensions];
    vkEnumerateInstanceExtensionProperties(NULL, &amountOfExtensions, extensions);
    std::cout << "found " << amountOfExtensions << " extensions" << std::endl;

    for (int i = 0; i < amountOfExtensions; i++) {
        std::cout << "Name: " << extensions[i].extensionName << std::endl;
    }


    VkDeviceQueueCreateInfo deviceQueueCreateInfo;
    deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    deviceQueueCreateInfo.pNext = nullptr;
    deviceQueueCreateInfo.flags = 0;
    deviceQueueCreateInfo.queueFamilyIndex = 0; // todo choose best queue family index
    deviceQueueCreateInfo.queueCount = 4; // todo check if 4 supported
    float queuePrios[] = {1.0f, 1.0f, 1.0f, 1.0f};
    deviceQueueCreateInfo.pQueuePriorities = queuePrios;
    VkPhysicalDeviceFeatures usedFeatures = {};
    // set features here

    VkDeviceCreateInfo deviceCreateInfo;
    deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    deviceCreateInfo.pNext = nullptr;
    deviceCreateInfo.flags = 0;
    deviceCreateInfo.queueCreateInfoCount = 1;
    deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
    deviceCreateInfo.enabledLayerCount = 0;
    deviceCreateInfo.ppEnabledLayerNames = nullptr;
    deviceCreateInfo.enabledExtensionCount = 0;
    deviceCreateInfo.ppEnabledExtensionNames = nullptr;
    deviceCreateInfo.pEnabledFeatures = &usedFeatures;

    std::cout << "creating logical device" << std::endl;
    VkDevice device;
    if (vkCreateDevice(physicalDevices.at(0), &deviceCreateInfo, NULL, &device) !=
        VK_SUCCESS) { // todo select right physicaldevice
        std::cout << "create logical device failed." << std::endl;
    }

    // stop jobs
    vkDeviceWaitIdle(device); // waits until any work has finished
    vkDestroyDevice(device, nullptr);
    vkDestroyInstance(instance, nullptr);

    delete[] layers;
    delete[] extensions;

    return 0;
}