/*
Crafter®.Graphics
Copyright (C) 2026 Catcrafts®
catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

module;
#ifdef CRAFTER_GRAPHICS_VULKAN
#include <vulkan/vulkan.h>
#endif
export module Crafter.Graphics:DescriptorLayoutVulkan;
#ifdef CRAFTER_GRAPHICS_VULKAN
import std;
import :VulkanDevice;
import :Types;

export namespace Crafter {
    struct DescriptorEntry {
        VkDescriptorType type;
        bool occured = true;
    };

    template <typename... Shaders>
    class DescriptorLayoutVulkan {
        public:
        inline static VkDescriptorSetLayout descriptorSetLayout[sizeof...(Shaders)];

        template <typename Shader>
        consteval static void GetOccuringDescriptors(std::array<DescriptorEntry, 20>& types) {
            for (const DescriptorBinding& binding : Shader::descriptors) {
                for (DescriptorEntry& type : types) {
                    if (type.type == binding.type) {
                        type.occured = true;
                    }
                }
            }
        }

        consteval static std::uint32_t GetUniqueDiscriptorCount() {
            std::array<DescriptorEntry, 20> types = {{{VK_DESCRIPTOR_TYPE_SAMPLER, 0},{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0},{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 0},{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 0},{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0},{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 0},{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 0},{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 0},{VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 0},{VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, 0},{VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 0},{VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, 0},{VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, 0},{VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, 0},{VK_DESCRIPTOR_TYPE_MUTABLE_EXT, 0},{VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV, 0},{VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, 0},{VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, 0}}};
    
            (GetOccuringDescriptors<Shaders>(types), ... );
    
            std::uint32_t size = 0;
            for(DescriptorEntry& type : types) {
                if(type.occured) {
                    size++;
                }
            }
    
            return size;
        }
        constexpr static std::uint32_t uniqueDescriptorCount = GetUniqueDiscriptorCount();
    
        consteval static std::array<VkDescriptorPoolSize, uniqueDescriptorCount> GetPoolSizes() {
            std::array<VkDescriptorPoolSize, uniqueDescriptorCount> types = {};
            for(std::uint32_t i = 0; i < uniqueDescriptorCount; i++){
                types[i].descriptorCount = 12345;
            }

            ([&] {
                    for (const DescriptorBinding& binding : Shaders::descriptors) {
                        bool found = false;
                        for(VkDescriptorPoolSize& type : types) {
                            if(type.type == binding.type && type.descriptorCount != 12345) {
                                type.descriptorCount += 1;
                                found = true;
                            }
                        }
                        if(!found) {
                            for(std::uint32_t i = 0; i < uniqueDescriptorCount; i++){
                                if(types[i].descriptorCount == 12345) {
                                    types[i].type = binding.type;
                                    types[i].descriptorCount = 1;
                                    break;
                                }
                            }
                        }
                    }
                }(), 
            ...);
    
            return types;
        }

        template <typename Shader>
		consteval static std::array<VkDescriptorSetLayoutBinding, Shader::descriptorCount> GetDescriptorSet() {
			std::array<VkDescriptorSetLayoutBinding, Shader::descriptorCount> set;

			for(std::uint32_t i = 0; i < Shader::descriptors.size(); i++) {
				set[i] = {Shader::descriptors[i].slot, Shader::descriptors[i].type, 1, Shader::_stage, nullptr};
			}

			return set;
		}

        public:
        static void Init() {
            std::uint32_t shaderIndex = 0;

            ([&] {
                    constexpr std::array<VkDescriptorSetLayoutBinding, Shaders::descriptorCount> setLayoutBindingsMesh = GetDescriptorSet<Shaders>();
                    VkDescriptorSetLayoutCreateInfo descriptorLayoutInfoMesh = {
                        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
                        .bindingCount = Shaders::descriptorCount,
                        .pBindings = setLayoutBindingsMesh.data()
                    };
                    VulkanDevice::CheckVkResult(vkCreateDescriptorSetLayout(VulkanDevice::device, &descriptorLayoutInfoMesh, nullptr, &descriptorSetLayout[shaderIndex++]));
                }(), 
            ...);
        }
    };
}

#endif