#include "vulkan/vulkan.h"

import Crafter.Graphics;
using namespace Crafter;
import std;
import Crafter.Event;
import Crafter.Math;


int main() {
    VulkanDevice::CreateDevice();
    WindowVulkan window(1280, 720, "HelloVulkan");
    VkCommandBuffer cmd = window.StartInit();

    std::vector<VkDescriptorSetLayoutBinding> bindings {
        {
            .binding = 0,
            .descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
            .descriptorCount = 1,
            .stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
        },
        {
            .binding = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .descriptorCount = 1,
            .stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
        }
    };
    DescriptorSetLayoutVulkan layout(std::move(bindings));

    std::array<VkDescriptorSetLayout, 1> layouts {{layout.layout}};

    DescriptorPool pool;
    pool.sets.resize(1);
    pool.BuildPool(DescriptorPool::GetPoolSizes({layout}), layouts);

    std::array<VulkanShader, 3> shaders{{
        {"raygen.spv", "main", VK_SHADER_STAGE_RAYGEN_BIT_KHR},
        {"miss.spv", "main", VK_SHADER_STAGE_MISS_BIT_KHR},
        {"closesthit.spv", "main", VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR}
    }};

    ShaderBindingTableVulkan shaderTable;
    shaderTable.Init(shaders);

    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> raygenGroups {{
        {
            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
            .generalShader = 0,
            .closestHitShader = VK_SHADER_UNUSED_KHR,
            .anyHitShader = VK_SHADER_UNUSED_KHR,
            .intersectionShader = VK_SHADER_UNUSED_KHR,
        },
    }};
    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> missGroups {{
        {
            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
            .generalShader = 1,
            .closestHitShader = VK_SHADER_UNUSED_KHR,
            .anyHitShader = VK_SHADER_UNUSED_KHR,
            .intersectionShader = VK_SHADER_UNUSED_KHR,
        },
    }};
    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> hitGroups {{
        {
            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
            .generalShader = VK_SHADER_UNUSED_KHR,
            .closestHitShader = 2,
            .anyHitShader = VK_SHADER_UNUSED_KHR,
            .intersectionShader = VK_SHADER_UNUSED_KHR,
        },
    }};

    PipelineRTVulkan pipeline;
    pipeline.Init(cmd, layouts, raygenGroups, missGroups, hitGroups, shaderTable);

    Mesh triangleMesh;
    std::array<Vector<float, 3, 3>, 3> verts {{{-150, -150, 100}, {0, 150, 100}, {150, -150, 100}}};
    std::array<std::uint32_t, 3> index {{2,1,0}};
    triangleMesh.Build(verts, index, cmd);
    RenderingElement3DVulkan renderer = {
        .instance = {
            .instanceCustomIndex                    = 0,
            .mask                                   = 0xFF,
            .instanceShaderBindingTableRecordOffset = 0,
            .flags                                  = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
            .accelerationStructureReference         = triangleMesh.blasAddr
        }
    };
    MatrixRowMajor<float, 4, 3, 1> transform = MatrixRowMajor<float, 4, 3, 1>::Identity();
    std::memcpy(renderer.instance.transform.matrix, transform.m, sizeof(transform.m));
    RenderingElement3DVulkan::tlases.resize(1);
    RenderingElement3DVulkan::elements.push_back(&renderer);
    RenderingElement3DVulkan::BuildTLAS(cmd, 0);

    VkDescriptorImageInfo imageInfo = {
        .imageView = window.imageViews[0],
        .imageLayout = VK_IMAGE_LAYOUT_GENERAL
    };

    VkWriteDescriptorSetAccelerationStructureKHR writeDescriptorSetAccelerationStructure {
        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
        .accelerationStructureCount = 1,
        .pAccelerationStructures = &RenderingElement3DVulkan::tlases[0].accelerationStructure
    };

    VkWriteDescriptorSet write[2] = {
        {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .pNext = &writeDescriptorSetAccelerationStructure,
            .dstSet = pool.sets[0],
            .dstBinding = 0,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
        },
        {
            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet = pool.sets[0],
            .dstBinding = 1,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
            .pImageInfo = &imageInfo
        }
    };
    vkUpdateDescriptorSets(VulkanDevice::device, 2, write, 0, nullptr);

    window.SetPipelineRT(pipeline);
    window.descriptorsRt = pool.sets;

    window.FinishInit();
    window.Render();
    window.StartSync();
}