VkCommandBufferAllocateInfo vk_cmd_buffers_alloc_info_init(VkCommandPool cmd_pool, uint32_t cmd_buffer_count)
{
    VkCommandBufferAllocateInfo alloc_info =
    {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .pNext = NULL,
        .commandPool = cmd_pool,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = cmd_buffer_count
    };

    return alloc_info;
}

VkCommandBufferBeginInfo vk_cmd_buffers_begin_info_init(VkCommandBufferUsageFlags flags)
{
    VkCommandBufferBeginInfo begin_info =
    {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .pNext = NULL,
        .flags = flags,
        .pInheritanceInfo = NULL
    };

    return begin_info;
}

static VkRenderPassBeginInfo vk_cmd_buffers_render_pass_begin_info_init(vk_swapchain *s, uint32_t img_index, VkRenderPass render_pass)
{
    VkRenderPassBeginInfo render_pass_begin_info =
    {
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
        .pNext = NULL,
        .renderPass = render_pass,
        .framebuffer = s->framebuffers[img_index],
        .renderArea.offset = {0, 0},
        .renderArea.extent = s->img_extent,
        .clearValueCount = 2,
        .pClearValues = s->clear_values
    };

    return render_pass_begin_info;
}

void vk_cmd_buffers_init(vk_device *d, VkCommandBuffer *cmd_buffers)
{
    VkCommandBufferAllocateInfo alloc_info = vk_cmd_buffers_alloc_info_init(d->graphics_cmd_pool, MAX_FRAMES_IN_FLIGHT);

    if (vkAllocateCommandBuffers(d->device, &alloc_info, cmd_buffers) != VK_SUCCESS)
    {
        printf("Failed to allocate command buffers\n");
    }
}

void vk_compute_cmds_record(VkPipeline compute, VkPipelineLayout compute_layout, VkCommandBuffer compute_cmds, VkDescriptorSet *sets)
{
    VkCommandBufferBeginInfo compute_cmds_begin_info = vk_cmd_buffers_begin_info_init(0);

    if (vkBeginCommandBuffer(compute_cmds, &compute_cmds_begin_info)!= VK_SUCCESS)
    {
        printf("Failed to begin recording compute command buffer\n");
    }

    vkCmdBindPipeline(compute_cmds, VK_PIPELINE_BIND_POINT_COMPUTE, compute);

    galaxy_params g =
    {
        .particle_count = STAR_COUNT,
        .max_rad = 3500.0,
        .bulge_rad = 1250.0,
        .angle = 6.28,
        .eccentricity = 0.85,
        .base_height = 300.0,
        .height = 250.0,
        .dust_temp = 4000.0,
        .min_star_opacity = 0.1,
        .max_star_opacity = 0.5,
        .min_dust_opacity = 0.01,
        .max_dust_opacity = 0.05,
        .speed = 10.0
    };

    uint32_t offset = 0;
    vkCmdBindDescriptorSets(compute_cmds, VK_PIPELINE_BIND_POINT_COMPUTE, compute_layout, 0, 1, sets, 1, &offset);
    vkCmdPushConstants(compute_cmds, compute_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(g), &g);

    vkCmdDispatch(compute_cmds, PARTICLE_COUNT / PARTICLE_DISPATCH_SIZE, 1, 1);

    if (vkEndCommandBuffer(compute_cmds) != VK_SUCCESS)
    {
        printf("Failed to record compute command buffer\n");
    }
}

void vk_galaxy_cmds_record(VkPipeline galaxy, VkPipelineLayout galaxy_layout, VkCommandBuffer cmd_buffers, VkDescriptorSet *sets)
{
    uint32_t offset = 0;
    vkCmdBindPipeline(cmd_buffers, VK_PIPELINE_BIND_POINT_GRAPHICS, galaxy);
    vkCmdBindDescriptorSets(cmd_buffers, VK_PIPELINE_BIND_POINT_GRAPHICS, galaxy_layout, 0, 1, sets, 1, &offset);

    galaxy_info info =
    {
        .star_count = STAR_COUNT,
        .time = glfwGetTime(),
        .min_temp = 3.60,
        .max_temp = 100.0,
        .star_size = 10.0,
        .dust_size = 500.0,
        .h2size = 150.0,
        .h2dist = 300.0
    };

    vkCmdPushConstants(cmd_buffers, galaxy_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(info), &info);
    vkCmdDraw(cmd_buffers, 6 * PARTICLE_COUNT, 1, 0, 0);
}

void vk_cmd_buffers_record(vk_swapchain *s, VkPipeline galaxy, VkPipelineLayout galaxy_layout, VkDescriptorSet *galaxy_sets, VkRenderPass render_pass, VkCommandBuffer cmd_buffers, uint32_t img_index)
{
    VkCommandBufferBeginInfo cmd_buffers_begin_info = vk_cmd_buffers_begin_info_init(0);

    if (vkBeginCommandBuffer(cmd_buffers, &cmd_buffers_begin_info)!= VK_SUCCESS)
    {
        printf("Failed to begin recording graphics command buffer\n");
    }

    VkRenderPassBeginInfo render_pass_begin_info = vk_cmd_buffers_render_pass_begin_info_init(s, img_index, render_pass);

    vkCmdBeginRenderPass(cmd_buffers, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);

    vk_galaxy_cmds_record(galaxy, galaxy_layout, cmd_buffers, galaxy_sets);

    vkCmdEndRenderPass(cmd_buffers);

    if (vkEndCommandBuffer(cmd_buffers) != VK_SUCCESS)
    {
        printf("Failed to record graphics command buffer\n");
    }
}