module;

#include <iostream>
#include <algorithm>
#include <vulkan/vulkan.h>
#include <fstream>
#include <cstdint>
#include <vector>
#include <array>

export module Crafter.Graphics:VulkanShader;
import :VulkanDevice;

namespace Crafter {
    export template<size_t N>
    struct StringLiteral {
        constexpr StringLiteral(const char (&str)[N]) {
            std::copy_n(str, N, value);
        }
        
        char value[N];
    };

    export struct DescriptorBinding {
        VkDescriptorType type;
        std::uint32_t slot;
    };

    export template <
        StringLiteral path, 
        StringLiteral entrypoint, 
        VkShaderStageFlagBits stage, 
        std::uint32_t DescriptorCount, 
        std::array<DescriptorBinding, DescriptorCount> Descriptors
    >
    class VulkanShader {
    public:
        inline static VkShaderModule shader;
        constexpr static std::uint32_t descriptorCount = DescriptorCount;
        constexpr static std::array<DescriptorBinding, DescriptorCount> descriptors = Descriptors;
        constexpr static StringLiteral _entrypoint = entrypoint;
        constexpr static VkShaderStageFlagBits _stage = stage;
        static void CreateShader() {
            std::ifstream file(path.value, std::ios::binary);
            if (!file) {
                std::cerr << "Error: Could not open file " << path.value << std::endl;
            }
    
            // Move to the end of the file to determine its size
            file.seekg(0, std::ios::end);
            std::streamsize size = file.tellg();
            file.seekg(0, std::ios::beg);
    
            std::vector<std::uint32_t> spirv(size / sizeof(std::uint32_t));
    
            // Read the data into the vector
            if (!file.read(reinterpret_cast<char*>(spirv.data()), size)) {
                std::cerr << "Error: Could not read data from file" << std::endl;
            }
    
            file.close();
    
            VkShaderModuleCreateInfo module_info{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
            module_info.codeSize = spirv.size() * sizeof(uint32_t);
            module_info.pCode    = spirv.data();
        
            VkShaderModule shader_module;
            VulkanDevice::CHECK_VK_RESULT(vkCreateShaderModule(VulkanDevice::device, &module_info, nullptr, &shader));
        }
    };
}