#include <Orange/Core/Array.h>
#include <Orange/Core/FileSystem.h>
#include <Orange/Core/Result.h>
#include <Orange/Core/Span.h>
#include <Orange/Core/Time.h>
#include <Orange/Core/Variant.h>
#include <Orange/Core/Vector.h>
#include <Orange/Graphics/Camera.h>
#include <Orange/Graphics/Mesh.h>
#include <Orange/Math/Matrix.h>
#include <Orange/Math/Transformation.h>
#include <Orange/Math/Vector.h>
#include <Orange/Render/RenderContext.h>
#include <Orange/Render/Swapchain.h>
#include <Orange/Render/VulkanHelpers.h>
#include <Orange/Render/Window.h>
#include <Orange/Formats/KeyValues.h>

#include <vs_Mesh.h>
#include <vs_Fullscreen.h>
#include <fs_DebugVertColor.h>
#include <fs_Mesh.h>
#include <fs_SkyGradient.h>
#include <fs_Red.h>

#include <iostream>
#include <spng.h>
#include <iomanip>

using namespace orange;

struct MiniPipelineInfo
{
    VkShaderModule vs;
    VkShaderModule fs;

    VkPipelineLayout pipelineLayout;

    VkFormat colorFormat;
    VkFormat depthFormat;

    bool enableDepthTest;
    bool enableDepthWrites;

    Span<const VkVertexInputAttributeDescription> vertexAttributes;
};

static VulkanResult<VkPipeline> CreateGraphicsPipeline(VkDevice device, const MiniPipelineInfo& info)
{
    VkPipelineShaderStageCreateInfo stages[] =
    {
        {
            .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage  = VK_SHADER_STAGE_VERTEX_BIT,
            .module = info.vs,
            .pName  = "main",
        },
        {
            .sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage  = VK_SHADER_STAGE_FRAGMENT_BIT,
            .module = info.fs,
            .pName  = "main",
        },
    };

    Array<VkDynamicState, 2> dynamicStates =
    {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR,
    };

    VkPipelineDynamicStateCreateInfo dynamicStateInfo =
    {
        .sType             = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .dynamicStateCount = uint32_t(dynamicStates.size()),
        .pDynamicStates    = dynamicStates.data(),
    };

    VkVertexInputBindingDescription inputBindingDescription =
    {
        .binding   = 0,
        .stride    = sizeof(StaticVertex),
        .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
    };

    VkPipelineVertexInputStateCreateInfo vertexInputInfo =
    {
        .sType                           = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
        .vertexBindingDescriptionCount   = info.vertexAttributes.size ? 1u : 0u,
        .pVertexBindingDescriptions      = &inputBindingDescription,
        .vertexAttributeDescriptionCount = uint32_t(info.vertexAttributes.size),
        .pVertexAttributeDescriptions    = info.vertexAttributes.data,
    };

    VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo =
    {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .topology               = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
        .primitiveRestartEnable = VK_FALSE,
    };

    VkPipelineViewportStateCreateInfo viewportStateInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .viewportCount = 1,
        .scissorCount  = 1,
    };

    VkPipelineRasterizationStateCreateInfo rasterizationInfo =
    {
        .sType     = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .cullMode  = VK_CULL_MODE_BACK_BIT,
        .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
        .lineWidth = 1.0f,
    };

    VkPipelineMultisampleStateCreateInfo multisampleInfo =
    {
        .sType                = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
    };

    VkPipelineDepthStencilStateCreateInfo depthStencilInfo =
    {
        .sType            = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .depthTestEnable  = info.enableDepthTest,
        .depthWriteEnable = info.enableDepthWrites,
        .depthCompareOp   = VK_COMPARE_OP_LESS,
        .minDepthBounds   = 0.0f,
        .maxDepthBounds   = 1.0f,
    };

    VkPipelineColorBlendAttachmentState attachmentBlendState =
    {
        .colorWriteMask =  VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                           VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
    };

    VkPipelineColorBlendStateCreateInfo colorBlendStateInfo =
    {
        .sType           = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .attachmentCount = 1,
        .pAttachments    = &attachmentBlendState,
    };

    VkPipelineRenderingCreateInfo renderingInfo =
    {
        .sType                   = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
        .viewMask                = 0u,
        .colorAttachmentCount    = 1u,
        .pColorAttachmentFormats = &info.colorFormat,
        .depthAttachmentFormat   = info.depthFormat,
    };

    VkGraphicsPipelineCreateInfo pipelineInfo =
    {
        .sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .pNext               = &renderingInfo,
        .stageCount          = Size(stages),
        .pStages             = stages,
        .pVertexInputState   = &vertexInputInfo,
        .pInputAssemblyState = &inputAssemblyInfo,
        .pViewportState      = &viewportStateInfo,
        .pRasterizationState = &rasterizationInfo,
        .pMultisampleState   = &multisampleInfo,
        .pDepthStencilState  = &depthStencilInfo,
        .pColorBlendState    = &colorBlendStateInfo,
        .pDynamicState       = &dynamicStateInfo,
        .layout              = info.pipelineLayout,
    };

    VkPipeline pipeline = VK_NULL_HANDLE;
    VkResult res = VK_SUCCESS;
    if ((res = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline)) != VK_SUCCESS)
        return VulkanResult<VkPipeline>::Error(res);

    return VulkanResult<VkPipeline>::Success(pipeline);
}

struct alignas(16) Mesh
{
    uint32_t textureIdx;
    uint32_t vertexOffset; // in sizeof(Vertex)
    uint32_t indexOffset;  // in sizeof(IndexType)
    uint32_t indexCount;
    AABB     bounds;
};

struct alignas(16) Renderable
{
    mat4     transform;
    uint32_t meshIdx;
    vec3     color; // should replace with something more interesting lmao
};

// look at moving me if binary is big
SmallVector<Mesh, 1024> g_meshes;
SmallVector<Renderable, 1024> g_renderables;

int main(int argc, char** argv)
{
    (void)argc; (void)argv;

    auto r_window = Window::Create();
    if (!r_window)
        return 1;

    auto r_renderContext = RenderContext::Create("Cube Test");
    if (!r_renderContext)
        return 1;

    auto r_surface = r_window->CreateSurface(r_renderContext->Instance());
    if (!r_surface)
        return 1;

    auto r_swapchain = Swapchain::Create(*r_renderContext, *r_surface);
    if (!r_swapchain)
        return 1;

    //auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/gman.obj");
    //auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/chair.obj");
    auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/frog.obj");
    //auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/deck.obj");
    //auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/cube.obj");
    if (!r_objData)
        return 1;

    auto r_buffer = r_renderContext->CreateBuffer(256 * 1024 * 1024);
    if (!r_buffer)
        return 1;
    auto pooler = MemoryPool{ *r_buffer };

    auto r_vsMesh = r_renderContext->CreateShader(vs_Mesh);
    if (!r_vsMesh) return 1;
    auto r_vsFullscreen = r_renderContext->CreateShader(vs_Fullscreen);
    if (!r_vsFullscreen) return 1;
    auto r_fsMesh = r_renderContext->CreateShader(fs_Mesh);
    if (!r_fsMesh) return 1;
    auto r_fsRed = r_renderContext->CreateShader(fs_Red);
    if (!r_fsRed) return 1;
    auto r_fsSky = r_renderContext->CreateShader(fs_SkyGradient);
    if (!r_fsSky) return 1;

    auto r_mesh = ParseOBJ(*r_objData);

#if 0
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
    for (auto& vertex : r_mesh->vertexData.GetStaticVertices()) {
        std::cout << std::hexfloat;
        std::cout << "{ ";

        std::cout << "{ " << std::setw(16) << vertex.pos[0] << ", " << std::setw(16) << vertex.pos[1] << ", " << std::setw(16) << vertex.pos[2] << " }, ";
        std::cout << "{ " << std::setw(16) << vertex.uv[0] << ", " << std::setw(16) << vertex.uv[1] << " }, ";
        std::cout << "{ " << std::setw(16) << vertex.normal[0] << ", " << std::setw(16) << vertex.normal[1] << ", " << std::setw(16) << vertex.normal[2]  << " } ";

        std::cout << "},";
        std::cout << std::endl;
    }
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
#endif

#if 0
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
    int count = 0;
    for (auto& index : r_mesh->indices) {
        std::cout << std::setw(4) << index << "u, ";
        count++;
        if (count >= 16) {
            std::cout << std::endl;
            count = 0;
        }
    }
    std::cout << std::endl;
    std::cout << std::endl;
    std::cout << std::endl;
#endif

    auto newVertexSlice = *pooler.AllocSlice(sizeof(StaticVertex) * r_mesh->vertexData.VertexCount(), sizeof(StaticVertex));
    auto newIndexSlice  = *pooler.AllocSlice(sizeof(IndexType)    * r_mesh->indices.size(),           sizeof(IndexType));
    r_mesh->vertexData.GetStaticVertices().copy((uint8_t*)(r_buffer->ptr) + newVertexSlice.offset);
    r_mesh->indices.copy                       ((uint8_t*)(r_buffer->ptr) + newIndexSlice.offset);

    uint32_t meshIdx = uint32_t(g_meshes.emplace_back(Mesh
    {
        .textureIdx = 0,
        .vertexOffset = uint32_t(newVertexSlice.offset / sizeof(StaticVertex)),
        .indexOffset  = uint32_t(newIndexSlice.offset  / sizeof(IndexType)),
        .indexCount   = uint32_t(r_mesh->indices.size()),
        .bounds       = r_mesh->bounds,
    }));

    g_renderables.emplace_back(Renderable
    {
        .transform = mat4{},
        .meshIdx   = meshIdx,
        .color     = 16_vec3,
    });

    g_renderables.emplace_back(Renderable
    {
        .transform = Math::translate(32_vec3),
        .meshIdx   = meshIdx,
        .color     = 1_vec3,
    });

    g_renderables.emplace_back(Renderable
    {
        .transform = Math::translate(-32_vec3),
        .meshIdx   = meshIdx,
        .color     = 1_vec3,
    });

    //

#pragma region "make descriptor n shit"
    VkSamplerCreateInfo samplerInfo =
    {
        .sType            = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        .magFilter        = VK_FILTER_LINEAR,
        .minFilter        = VK_FILTER_LINEAR,
        .mipmapMode       = VK_SAMPLER_MIPMAP_MODE_LINEAR,
        .addressModeU     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .addressModeV     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .addressModeW     = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
        .mipLodBias       = 0.0f,
        .anisotropyEnable = VK_TRUE,
        .maxAnisotropy    = 16.0f,
        .minLod           = -FLT_MAX,
        .maxLod           = FLT_MAX,
    };
    VkSampler sampler = VK_NULL_HANDLE;
    vkCreateSampler(r_renderContext->Device(), &samplerInfo, nullptr, &sampler);

    constexpr uint32_t MaxBindlessResources = 32768;
    VkDescriptorPoolSize bindlessPoolSizes[] =
    {
        { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,         2u},
        { VK_DESCRIPTOR_TYPE_SAMPLER,                1u},
        { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MaxBindlessResources },
    };

    VkDescriptorPoolCreateInfo poolInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
        .flags         = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
        .maxSets       = 1u,
        .poolSizeCount = uint32_t(Size(bindlessPoolSizes)),
        .pPoolSizes    = bindlessPoolSizes,
    };
    
    VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
    vkCreateDescriptorPool(r_renderContext->Device(), &poolInfo, nullptr, &descriptorPool);

    VkDescriptorSetLayoutBinding layoutBindings[] =
    {
        {
            .binding            = 0,
            .descriptorType     = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .descriptorCount    = 1,
            .stageFlags         = VK_SHADER_STAGE_ALL,
        },
        {
            .binding            = 1,
            .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLER,
            .descriptorCount    = 1,
            .stageFlags         = VK_SHADER_STAGE_FRAGMENT_BIT,
            .pImmutableSamplers = &sampler,
        },
        {
            .binding            = 2,
            .descriptorType     = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .descriptorCount    = 1,
            .stageFlags         = VK_SHADER_STAGE_ALL,
        },
        {
            .binding            = 3,
            .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
            .descriptorCount    = MaxBindlessResources,
            .stageFlags         = VK_SHADER_STAGE_FRAGMENT_BIT,
        },
    };

    constexpr VkDescriptorBindingFlags bindingFlags[] =
    {
        0,
        0,
        0,
        VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
    };

    Assert(Size(bindingFlags) == Size(layoutBindings));

    VkDescriptorSetLayoutBindingFlagsCreateInfo layoutBindingFlagsInfo =
    {
        .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
        .bindingCount  = Size(bindingFlags),
        .pBindingFlags = bindingFlags,
    };

    VkDescriptorSetLayoutCreateInfo layoutInfo =
    {
        .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
        .pNext        = &layoutBindingFlagsInfo,
        .flags        = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT,
        .bindingCount = Size(layoutBindings),
        .pBindings    = layoutBindings,
    };

    VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
    vkCreateDescriptorSetLayout(r_renderContext->Device(), &layoutInfo, nullptr, &descriptorSetLayout);

    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT descriptorCountAllocInfo =
    {
        .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
        .descriptorSetCount = 1,
        .pDescriptorCounts  = &MaxBindlessResources,
    };

    VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
    {
        .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
        .pNext              = &descriptorCountAllocInfo,
        .descriptorPool     = descriptorPool,
        .descriptorSetCount = 1,
        .pSetLayouts        = &descriptorSetLayout,
    };

    VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
    vkAllocateDescriptorSets(r_renderContext->Device(), &descriptorSetAllocInfo, &descriptorSet);

    struct PushConstants
    {
        uint32_t frameIdx;  
    };

    VkPushConstantRange pushConstantRange =
    {
        .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
        .offset     = 0,
        .size       = sizeof(PushConstants),
    };

    VkPipelineLayoutCreateInfo pipelineLayoutInfo =
    {
        .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .setLayoutCount         = 1,
        .pSetLayouts            = &descriptorSetLayout,
        .pushConstantRangeCount = 1,
        .pPushConstantRanges    = &pushConstantRange,
    };
    VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
    vkCreatePipelineLayout(r_renderContext->Device(), &pipelineLayoutInfo, nullptr, &pipelineLayout);

    //
    VkFormat depthFormat = *FindDepthFormat(r_renderContext->PhysicalDevice());
    auto pipeline = *CreateGraphicsPipeline(r_renderContext->Device(), MiniPipelineInfo
    {
        .vs                = *r_vsMesh,
        .fs                = *r_fsMesh,
        .pipelineLayout    = pipelineLayout,
        .colorFormat       = FormatToSrgbFormat(r_swapchain->Format()),
        .depthFormat       = depthFormat,
        .enableDepthTest   = true,
        .enableDepthWrites = true,
        .vertexAttributes  = Span<const VkVertexInputAttributeDescription>(StaticVertex::Attributes),
    });

    auto skyPipeline = *CreateGraphicsPipeline(r_renderContext->Device(), MiniPipelineInfo
    {
        .vs                = *r_vsFullscreen,
        .fs                = *r_fsSky,
        .pipelineLayout    = pipelineLayout,
        .colorFormat       = FormatToSrgbFormat(r_swapchain->Format()),
        .depthFormat       = depthFormat,
        .enableDepthTest   = false,
        .enableDepthWrites = false,
        .vertexAttributes  = Span<const VkVertexInputAttributeDescription>(nullptr),
    });
#pragma endregion

    struct ImageUpload
    {
        BufferSlice from;
        VkImage     to;
        VkExtent3D  extent;
    };
    Vector<ImageUpload> imageUploads;

    //auto r_pngData = fs::OpenFileIntoBuffer("/home/joshua/chair_color.png");
    auto r_pngData = fs::OpenFileIntoBuffer("/home/joshua/frog001.png");
    //auto r_pngData = fs::OpenFileIntoBuffer("/home/joshua/deck.png");
    if (!r_pngData)
        return 1;

    spng_ctx *ctx = spng_ctx_new(0);
    spng_set_png_buffer(ctx, r_pngData->data, r_pngData->size);
    size_t pngOutSize = 0zu;
    spng_decoded_image_size(ctx, SPNG_FMT_RGBA8, &pngOutSize);
    auto pngLinearSlice = *pooler.AllocSlice(pngOutSize, 16);
    spng_decode_image(ctx, pngLinearSlice.ptr, pngOutSize, SPNG_FMT_RGBA8, 0);
    struct spng_ihdr ihdr;
    spng_get_ihdr(ctx, &ihdr);
    spng_ctx_free(ctx);

    auto r_texture = r_renderContext->CreateImage(pooler, ihdr.width, ihdr.height, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
    auto r_textureView = r_renderContext->CreateImageView(*r_texture, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT);

    VkDescriptorImageInfo descriptorImageInfo =
    {
        .imageView   = *r_textureView,
        .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
    };

    VkWriteDescriptorSet writeImageDescriptorSet[] =
    {
        {
            .sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet          = descriptorSet,
            .dstBinding      = 3,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType  = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
            .pImageInfo      = &descriptorImageInfo,
        },
    };
    vkUpdateDescriptorSets(r_renderContext->Device(), Size(writeImageDescriptorSet), writeImageDescriptorSet, 0, nullptr);

    imageUploads.push_back(ImageUpload
    {
        .from   = pngLinearSlice,
        .to     = *r_texture,
        .extent = VkExtent3D{ ihdr.width, ihdr.height, 1u },
    });

    Camera camera;
    camera.transform.position = vec3{0.0f, 0.0f, 80.0f};
    camera.viewportAspectRatio = 16.0f / 9.0f;
    //camera.offsetOrientation(1_deg * Seconds(t2 - t1).count(), 0_deg);
    //camera.lookAt(vec3{40.0f, 40.0f, 0.0f});
    camera.transform.orientation = eulerAnglesToQuaternion(EulerAngles{ 0_deg, 0_deg, 0_deg });

    auto meshData = r_mesh->vertexData.View();
    auto r_depthImage = r_renderContext->CreateImage(pooler, 1280, 720, depthFormat, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
    auto depthImageView = *r_renderContext->CreateImageView(*r_depthImage, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT);

    struct FrameData
    {
        mat4 view_projection;
    };

    auto frameDataSlice = *pooler.AllocSlice(MaxFramesInFlight * sizeof(FrameData), 16);
    FrameData* frameData = reinterpret_cast<FrameData*>(frameDataSlice.ptr);

    VkDescriptorBufferInfo bufferInfo =
    {
        .buffer = r_buffer->buffer,
        .offset = frameDataSlice.offset,
        .range  = frameDataSlice.size,
    };

    VkWriteDescriptorSet writeDescriptorSet[] =
    {
        {
            .sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet          = descriptorSet,
            .dstBinding      = 0,
            .descriptorCount = 1,
            .descriptorType  = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .pBufferInfo     = &bufferInfo,
        },
    };
    vkUpdateDescriptorSets(r_renderContext->Device(), Size(writeDescriptorSet), writeDescriptorSet, 0, nullptr);

    struct Renderables
    {
        Renderable renderables[1024];
    };

    auto renderablesSlice = *pooler.AllocSlice(MaxFramesInFlight * sizeof(Renderables), 16);
    Renderables* gpuRenderables = reinterpret_cast<Renderables*>(renderablesSlice.ptr);

    VkDescriptorBufferInfo renderblesBufferInfo =
    {
        .buffer = r_buffer->buffer,
        .offset = renderablesSlice.offset,
        .range  = renderablesSlice.size,
    };

    VkWriteDescriptorSet renderablesWriteDescriptorSet[] =
    {
        {
            .sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
            .dstSet          = descriptorSet,
            .dstBinding      = 2,
            .descriptorCount = 1,
            .descriptorType  = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
            .pBufferInfo     = &renderblesBufferInfo,
        },
    };
    vkUpdateDescriptorSets(r_renderContext->Device(), Size(renderablesWriteDescriptorSet), renderablesWriteDescriptorSet, 0, nullptr);

    Input::InputHandler handler;

    r_window->EnableRelativeMouse(true);

    auto indirectBuffer = *pooler.AllocSlice(1024 * sizeof(VkDrawIndexedIndirectCommand), 256);
    auto indirectPtr    = reinterpret_cast<VkDrawIndexedIndirectCommand *>(indirectBuffer.ptr);
    for (size_t i = 0; i < g_renderables.size(); i++) {
        const auto& renderable = g_renderables[i];
        const uint32_t meshIdx = renderable.meshIdx;

        indirectPtr[i] = VkDrawIndexedIndirectCommand
        {
            .indexCount    = g_meshes[meshIdx].indexCount,
            .instanceCount = 1u,
            .firstIndex    = g_meshes[meshIdx].indexOffset,
            .vertexOffset  = int32_t(g_meshes[meshIdx].vertexOffset),
            .firstInstance = 0u,
        };
    }

    auto countBuffer    = *pooler.AllocSlice(sizeof(uint32_t), 16);
    auto countPtr       = reinterpret_cast<uint32_t*>(countBuffer.ptr);
    *countPtr = uint32_t(g_renderables.size());

    auto t1 = Time::now();
    while (r_window->Update(handler))
    {
        const auto t2 = Time::now();
        auto delta = t2 - t1;
        const float dt = Seconds(delta).count();
        t1 = t2;

        //char title[64];
        //stbsp_snprintf(title, sizeof(title), "CubeTest - %gfps", 1.0f / dt);
        //r_window->SetTitle(title);

        {
            auto mouseDelta = handler.getMouseMotionDelta();
            auto scrollDelta = handler.getMouseScrollDelta();
            //if (mouseDelta.x || mouseDelta.y)
            //{
            //    log::info("mouse: %d %d", mouseDelta.x, mouseDelta.y);
            //}

            const float sensitivity = 6.0f;

            camera.offsetOrientation(
                -sensitivity * dt * Radian( mouseDelta.x ),
                 sensitivity * dt * Radian( mouseDelta.y ));

            frameData[r_swapchain->CurrentFrame()] = FrameData
            {
                .view_projection = camera.projection() * camera.view(),
            };

            g_renderables.copy(gpuRenderables[r_swapchain->CurrentFrame()].renderables);

            const float movementSpeed = handler.get(Input::ButtonCodes::Key_LShift) ? 64.0f : 16.0f;

            if (scrollDelta.y)
            {
                camera.fieldOfView += Radian(5_deg) * -scrollDelta.y;
                camera.fieldOfView = Clamp(camera.fieldOfView, Radian(5_deg), Radian(175_deg));
            }

            if (handler.get(Input::ButtonCodes::Key_W))
                camera.transform.position += camera.forward() * movementSpeed * dt;
            else if (handler.get(Input::ButtonCodes::Key_S))
                camera.transform.position += camera.backward() * movementSpeed * dt;

            if (handler.get(Input::ButtonCodes::Key_A))
                camera.transform.position += camera.left() * movementSpeed * dt;
            else if (handler.get(Input::ButtonCodes::Key_D))
                camera.transform.position += camera.right() * movementSpeed * dt;
        }

        VkCommandBuffer cmdBuf = r_swapchain->CommandBuffer();
        r_renderContext->BeginCommandBuffer(cmdBuf);
        {
            for (auto& upload : imageUploads)
            {
                VkBufferImageCopy region =
                {
                    .bufferOffset = upload.from.offset,
                    .imageSubresource = 
                    {
                        .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
                        .mipLevel       = 0u,
                        .baseArrayLayer = 0u,
                        .layerCount     = 1u,
                    },
                    .imageExtent = upload.extent,
                };
                vkCmdCopyBufferToImage(cmdBuf, upload.from.buffer, upload.to, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 1, &region);
            }
            imageUploads.clear();

            VkViewport viewport =
            {
                .x        = 0.0f,
                .y        = 0.0f,
                .width    = float(r_swapchain->Extent().width),
                .height   = float(r_swapchain->Extent().height),
                .minDepth = 0.0f,
                .maxDepth = 1.0f,
            };

            VkRect2D scissor =
            {
                .offset = {0u, 0u},
                .extent = r_swapchain->Extent(),
            };

            vkCmdSetViewport(cmdBuf, 0, 1, &viewport);  
            vkCmdSetScissor(cmdBuf, 0, 1, &scissor);

            PushConstants pushConstants =
            {
                .frameIdx = r_swapchain->CurrentFrame(),
            };
            vkCmdPushConstants(cmdBuf, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(PushConstants), &pushConstants);

            vkCmdBindDescriptorSets(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
            VkDeviceSize zero = 0;
            VkDeviceSize wholeSize = VK_WHOLE_SIZE;
            VkDeviceSize validationBruhMoment = r_buffer->size;
            //vkCmdBindVertexBuffers2(cmdBuf, 0, 1, &r_buffer->buffer, &zero, &wholeSize, nullptr);
            vkCmdBindVertexBuffers2(cmdBuf, 0, 1, &r_buffer->buffer, &zero, &validationBruhMoment, nullptr);
            vkCmdBindIndexBuffer(cmdBuf, r_buffer->buffer, zero, VulkanIndexType);

            const VkImageMemoryBarrier undefinedToColorBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .dstAccessMask    = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout        = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                .image            = r_swapchain->Image(),
                .subresourceRange = FirstColorMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &undefinedToColorBarrier);

            const VkImageMemoryBarrier undefinedToDepthBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .dstAccessMask    = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_UNDEFINED,
                .newLayout        = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                .image            = *r_depthImage,
                .subresourceRange = FirstDepthMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &undefinedToDepthBarrier);

            const VkRenderingAttachmentInfoKHR colorAttachmentInfos[] =
            {
                {
                    .sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
                    .imageView   = r_swapchain->ImageView(),
                    .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
                    .loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR,
                    .storeOp     = VK_ATTACHMENT_STORE_OP_STORE,
                    .clearValue  = { .color = { .float32 = { 1.0f, 1.0f, 1.0f, 1.0f } } },
                },
            };

            const VkRenderingAttachmentInfoKHR depthAttachmentInfo =
            {
                .sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
                .imageView   = depthImageView,
                .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
                .loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR,
                .storeOp     = VK_ATTACHMENT_STORE_OP_STORE,
                .clearValue  = { .color = { .float32 = { 1.0f, 1.0f, 1.0f, 1.0f } } },
            };

            const VkRenderingInfo renderInfo =
            {
                .sType                = VK_STRUCTURE_TYPE_RENDERING_INFO,
                .renderArea           = { {}, r_swapchain->Extent() },
                .layerCount           = 1,
                .colorAttachmentCount = Size(colorAttachmentInfos),
                .pColorAttachments    = colorAttachmentInfos,
                .pDepthAttachment     = &depthAttachmentInfo,
            };
            vkCmdBeginRendering(cmdBuf, &renderInfo);
            {
                vkCmdBindPipeline(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, skyPipeline);
                vkCmdDraw(cmdBuf, 3, 1, 0, 0);

                vkCmdBindPipeline(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
                vkCmdDrawIndexedIndirectCount(cmdBuf, indirectBuffer.buffer, indirectBuffer.offset, countBuffer.buffer, countBuffer.offset, 1024u, sizeof(VkDrawIndexedIndirectCommand));
            }
            vkCmdEndRendering(cmdBuf);

            const VkImageMemoryBarrier colorToPresentBarrier =
            {
                .sType            = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
                .srcAccessMask    = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
                .oldLayout        = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                .newLayout        = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                .image            = r_swapchain->Image(),
                .subresourceRange = FirstColorMipSubresourceRange,
            };

            vkCmdPipelineBarrier(
                cmdBuf,
                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                0,
                0, nullptr,
                0, nullptr,
                1, &colorToPresentBarrier);
        }
        r_renderContext->EndCommandBuffer(cmdBuf);
        r_swapchain->Present();
    }

    return 0;
}