vkutils.h

#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
#ifndef VKUTILS_H
#define VKUTILS_H
// This is just to put the verbose vulkan stuff in its own place
#include "readback_frame.h"
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <fstream>
#include <ios>
#include <spdlog/spdlog.h>
#include <stdexcept>
#include <string>
#include <sys/types.h>
#include <vector>
#include <volk.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <array>
#include <glm/glm.hpp>
#include <spdlog/fmt/fmt.h>

#define VK_CHECK(x)                                                            \
    do {                                                                       \
        VkResult err = x;                                                      \
        if (err) {                                                             \
            spdlog::error("Vulkan error: {} (0x{:x})",                         \
                          static_cast<int>(err),                               \
                          static_cast<uint32_t>(err));                         \
            throw std::logic_error("Got a runtime_error");                     \
        }                                                                      \
    } while (0);

inline constexpr size_t MAX_FRAME_SLOTS = 10;

namespace vkutils {
struct PushConstants {
    float iTime;
    uint32_t iFrame;
    glm::vec2 iResolution;
    glm::vec2 iMouse;
};

/* Helper structs so that we can pass around swapchain images
 * or image views on the stack without having to go to the heap
 * unnesicarily. I want to sometimes avoid vector
 */
struct SwapchainImages {
    std::array<VkImage, MAX_FRAME_SLOTS> images{};
    uint32_t count = 0;
};

struct SwapchainImageViews {
    std::array<VkImageView, MAX_FRAME_SLOTS> imageViews{};
    uint32_t count = 0;
};

struct CommandBuffers {
    std::array<VkCommandBuffer, MAX_FRAME_SLOTS> commandBuffers{};
    uint32_t count = 0;
};

struct Fences {
    std::array<VkFence, MAX_FRAME_SLOTS> fences{};
    uint32_t count = 0;
};

struct Semaphores {
    std::array<VkSemaphore, MAX_FRAME_SLOTS> semaphores{};
    uint32_t count = 0;
};

struct FrameBuffers {
    std::array<VkFramebuffer, MAX_FRAME_SLOTS> framebuffers{};
    uint32_t count = 0;
};

/*
 * Used to readback a buffer from GPU -> CPU.
 * eg. to dump a frame as part of testing
 *     or to encode frames in CPU with ffmpeg
 */
struct ReadbackBuffer {
    VkBuffer buffer = VK_NULL_HANDLE;
    VkDeviceMemory memory = VK_NULL_HANDLE;
    VkDeviceSize size = 0;
};

struct ReadbackFormatInfo {
    uint32_t bytesPerPixel = 0;
    bool swapRB = false;
};

[[nodiscard]] static std::vector<uint32_t>
loadSpvFile(const std::string &filename) {
    std::ifstream file(filename, std::ios::ate | std::ios::binary);

    if (!file.is_open())
        throw std::runtime_error("Failed to open file: " + filename);

    std::streamoff fileSize = file.tellg();
    if (fileSize % static_cast<std::streamoff>(sizeof(uint32_t)) != 0)
        throw std::runtime_error("SPIR-V file size is not a multiple of 4: " +
                                 filename);

    std::size_t byteSize = static_cast<std::size_t>(fileSize);
    std::vector<uint32_t> buffer(byteSize / sizeof(uint32_t));

    file.seekg(0);
    file.read(reinterpret_cast<char *>(buffer.data()),
              static_cast<std::streamsize>(byteSize));

    if (file.gcount() != static_cast<std::streamsize>(byteSize))
        throw std::runtime_error("Failed to read the complete file: " +
                                 filename);

    return buffer;
};

[[nodiscard]] inline ReadbackFormatInfo getReadbackFormatInfo(VkFormat format) {
    switch (format) {
    case VK_FORMAT_B8G8R8A8_UNORM:
    case VK_FORMAT_B8G8R8A8_SRGB:
        return {4, true};
    default:
        throw std::runtime_error(
            "Unsupported format for readback; expected BGRA8");
    }
}

/**
 * Initializes volk meta-loader to find Vulkan dynamically.
 * Must be called once before creating VkInstance.
 * Throws runtime_error if Vulkan loader not found.
 */
static void initVolk() {
    VkResult result = volkInitialize();
    if (result != VK_SUCCESS) {
        spdlog::error("Failed to initialize volk: Vulkan loader not found");
        spdlog::error("Please install Vulkan runtime:");
        spdlog::error("  macOS: brew install molten-vk");
        spdlog::error("  Linux: apt install libvulkan1");
        throw std::runtime_error("Failed to initialize Vulkan loader (volk)");
    }
    spdlog::debug("volk initialized successfully");
}

[[nodiscard]] static VkInstance setupVulkanInstance(bool offline = false) {
    // Initialize volk first (only runs once, thread-safe via static guard)
    initVolk();
    
    const VkApplicationInfo appInfo = {
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = nullptr,
        .pApplicationName = "Emerald",
        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
        .pEngineName = "Emerald Engine",
        .engineVersion = VK_MAKE_VERSION(1, 0, 0),
        .apiVersion = VK_API_VERSION_1_2,
    };
    spdlog::info("Size of push constants {}", sizeof(PushConstants));

    std::vector<const char *> extensions;
    if (!offline) {
        // Offline renders on GPU to an offscreen image for readback (future
        // ffmpeg encoding), so it has no GLFW surface and doesn't need
        // GLFW-provided instance extensions.
        uint32_t extensionCount = 0;
        const char **glfwExtensions =
            glfwGetRequiredInstanceExtensions(&extensionCount);
        extensions.assign(glfwExtensions, glfwExtensions + extensionCount);
    }

#ifdef __APPLE__
    extensions.push_back("VK_KHR_portability_enumeration");
#endif

    spdlog::debug("Using the following extensions: ");
    for (const auto &extension : extensions) {
        spdlog::debug("- {}", extension);
    }

    spdlog::debug("Creating vk instance...");

    // Query available validation layers
    uint32_t layerCount;
    vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
    std::vector<VkLayerProperties> availableLayers(layerCount);
    vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());

    spdlog::debug("Available validation layers:");
    for (const auto &layer : availableLayers) {
        spdlog::debug("- {}", layer.layerName);
    }

    const std::vector<const char *> desiredLayers = {
        "VK_LAYER_KHRONOS_validation",
    };

    std::vector<const char *> enabledLayers;
    for (const char *layerName : desiredLayers) {
        bool layerFound = false;
        for (const auto &layerProperties : availableLayers) {
            if (strcmp(layerName, layerProperties.layerName) == 0) {
                layerFound = true;
                break;
            }
        }
        if (layerFound) {
            enabledLayers.push_back(layerName);
        } else {
            spdlog::warn("Validation layer not found: {}", layerName);
        }
    }

    spdlog::debug("Enabling validation layers:");
    for (const auto &layer : enabledLayers) {
        spdlog::debug("- {}", layer);
    }

    VkInstanceCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext = nullptr,
#ifdef __APPLE__
        .flags = VkInstanceCreateFlagBits::
            VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR,
#else
        .flags = 0,
#endif
        .pApplicationInfo = &appInfo,
        .enabledLayerCount = static_cast<uint32_t>(enabledLayers.size()),
        .ppEnabledLayerNames = enabledLayers.data(),
        .enabledExtensionCount = static_cast<uint32_t>(extensions.size()),
        .ppEnabledExtensionNames = extensions.data(),
    };

    VkInstance instance;
    VK_CHECK(vkCreateInstance(&createInfo, nullptr, &instance));
    
    // Load instance-specific Vulkan functions
    volkLoadInstance(instance);
    
    return instance;
}

[[nodiscard]] static VkPhysicalDeviceProperties
getDeviceProperties(VkPhysicalDevice physicalDevice) {
    VkPhysicalDeviceProperties deviceProperties;
    vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
    return deviceProperties;
}

[[nodiscard]] static VkPhysicalDevice findGPU(VkInstance instance) {
    uint32_t deviceCount = 0;
    spdlog::debug("Enumerating devices...");
    VK_CHECK(vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr));

    if (deviceCount == 0) {
        spdlog::error("No devices found!");
        throw std::runtime_error("No devices found!");
    }

    spdlog::info("Found {} devices", deviceCount);
    std::vector<VkPhysicalDevice> devices(deviceCount);
    VK_CHECK(
        vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data()));

    for (uint32_t i = 0; i < deviceCount; i++) {
        VkPhysicalDeviceProperties deviceProperties;
        vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);
        spdlog::debug("Device {} has Vulkan version {}", i,
                      deviceProperties.apiVersion);
        spdlog::debug("Device {} has driver version {}", i,
                      deviceProperties.driverVersion);
        spdlog::debug("Device {} has vendor ID {}", i,
                      deviceProperties.vendorID);
        spdlog::debug("Device {} has device ID {}", i,
                      deviceProperties.deviceID);
        spdlog::debug("Device {} has device type {}", i,
                      static_cast<uint32_t>(deviceProperties.deviceType));
        spdlog::debug("Device {} has device name {}", i,
                      deviceProperties.deviceName);

        // Example of selecting a discrete GPU
        if (deviceProperties.deviceType ==
            VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
            spdlog::info("Selecting discrete GPU: {}",
                         deviceProperties.deviceName);
            return devices[i];
        }
    }
    // If no discrete GPU is found, fallback to the first device
    spdlog::debug("No discrete GPU found. Fallback to the first device.");
    return devices[0];
}

[[nodiscard]] static VkSurfaceKHR createVulkanSurface(VkInstance instance,
                                                      GLFWwindow *window) {
    spdlog::debug("Creating Vulkan surface...");
    VkSurfaceKHR surface;
    VkResult result =
        glfwCreateWindowSurface(instance, window, nullptr, &surface);
    if (result != VK_SUCCESS) {
        spdlog::error("Failed to create Vulkan surface");
        spdlog::error("Result: 0x{:x}", static_cast<int>(result));
        vkDestroyInstance(instance, nullptr);
        glfwTerminate();
        throw std::runtime_error("Failed to create Vulkan surface");
    }
    spdlog::debug("Created vulkan surface");
    return surface;
}

[[nodiscard]] static uint32_t
getVulkanGraphicsQueueIndexImpl(VkPhysicalDevice physicalDevice,
                                VkSurfaceKHR surface, bool requirePresent) {
    uint32_t queueFamilyCount;
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount,
                                             nullptr);

    if (queueFamilyCount == 0)
        throw std::runtime_error("No queue families found");

    spdlog::debug("Found {} queue families", queueFamilyCount);

    std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount,
                                             queueFamilies.data());

    // Print debug info for all queue families
    for (uint32_t i = 0; i < queueFamilyCount; i++) {
        spdlog::debug("Queue family {} has {} queues", i,
                      queueFamilies[i].queueCount);
        spdlog::debug("Queue family {} supports graphics: {} ", i,
                      queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT);
        spdlog::debug("Queue family {} supports compute: {} ", i,
                      queueFamilies[i].queueFlags & VK_QUEUE_COMPUTE_BIT);
        spdlog::debug("Queue family {} supports transfer: {} ", i,
                      queueFamilies[i].queueFlags & VK_QUEUE_TRANSFER_BIT);
        spdlog::debug("Queue family {} supports sparse binding: {} ", i,
                      queueFamilies[i].queueFlags &
                          VK_QUEUE_SPARSE_BINDING_BIT);
        spdlog::debug("Queue family {} supports protected: {} ", i,
                      queueFamilies[i].queueFlags & VK_QUEUE_PROTECTED_BIT);

        if (requirePresent) {
            VkBool32 supportsPresent;
            vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface,
                                                 &supportsPresent);
            spdlog::debug("Queue family {} supports present: {} ", i,
                          supportsPresent);
            if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT &&
                supportsPresent)
                return i;
        } else if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
            return i;
        }
    }

    throw std::runtime_error("Failed to find graphics queue");
}

[[nodiscard]] static uint32_t
getVulkanGraphicsQueueIndex(VkPhysicalDevice physicalDevice) {
    // For when present is not needed eg. for offline rendering of SDF
    // to encode with FFMPEG
    return getVulkanGraphicsQueueIndexImpl(physicalDevice, VK_NULL_HANDLE,
                                           false);
}

[[nodiscard]] static uint32_t
getVulkanGraphicsQueueIndex(VkPhysicalDevice physicalDevice,
                            VkSurfaceKHR surface) {
    return getVulkanGraphicsQueueIndexImpl(physicalDevice, surface, true);
}

[[nodiscard]] static VkDevice
createVulkanLogicalDevice(VkPhysicalDevice physicalDevice,
                          uint32_t graphicsQueueIndex, bool offline = false) {
    float queuePriority = 1.0f;

    spdlog::debug("Create a queue...");
    VkDeviceQueueCreateInfo queueInfo = {
        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
        .queueFamilyIndex = graphicsQueueIndex,
        .queueCount = 1,
        .pQueuePriorities = &queuePriority,
    };

    std::vector<const char *> requiredExtensions;
    if (!offline) {
        requiredExtensions.push_back("VK_KHR_swapchain");
    }
#ifdef __APPLE__
    requiredExtensions.push_back("VK_KHR_portability_subset");
#endif

    spdlog::debug("Create a logical device...");
    VkDevice device;

    VkPhysicalDeviceDynamicRenderingFeaturesKHR dynamicRenderingFeatures{
        .sType =
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR,
        .dynamicRendering = VK_TRUE,
    };

    VkDeviceCreateInfo deviceCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pNext = &dynamicRenderingFeatures,
        .queueCreateInfoCount = 1,
        .pQueueCreateInfos = &queueInfo,
        .enabledExtensionCount =
            static_cast<uint32_t>(requiredExtensions.size()),
        .ppEnabledExtensionNames =
            requiredExtensions.empty() ? nullptr : requiredExtensions.data(),
    };

    VK_CHECK(
        vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device));
    
    // Load device-specific Vulkan functions
    volkLoadDevice(device);
    
    spdlog::debug("Created logical device (offline = {})", offline);

    return device;
}

[[nodiscard]] static VkSurfaceCapabilitiesKHR
getSurfaceCapabilities(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface) {
    // Surface Capabilities
    spdlog::debug("Get surface capabilities");
    VkSurfaceCapabilitiesKHR surfaceCapabilities;
    VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
                                                       &surfaceCapabilities));
    return surfaceCapabilities;
}

[[nodiscard]] consteval auto getPreferredFormats() {
    return std::to_array({
        VK_FORMAT_B8G8R8A8_SRGB,
        VK_FORMAT_B8G8R8A8_UNORM,
    });
}

[[nodiscard]] static VkSurfaceFormatKHR
selectSwapchainFormat(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface) {
    // Get surface formats
    uint32_t surfaceFormatCount;
    VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(
        physicalDevice, surface, &surfaceFormatCount, nullptr));
    spdlog::debug("Surface format count: {}", surfaceFormatCount);

    if (surfaceFormatCount == 0) {
        throw std::runtime_error("Failed to find any surface formats.");
    }

    // NOTE: Would like to move to array but not sure of a good max
    std::vector<VkSurfaceFormatKHR> surfaceFormats(surfaceFormatCount);
    VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(
        physicalDevice, surface, &surfaceFormatCount, surfaceFormats.data()));

    // Handle the special case where the surface format is undefined.
    if (surfaceFormatCount == 1 &&
        surfaceFormats[0].format == VK_FORMAT_UNDEFINED) {
        spdlog::info("Surface format is undefined, selecting "
                     "VK_FORMAT_B8G8R8A8_SRGB as default.");
        return {VK_FORMAT_B8G8R8A8_SRGB, surfaceFormats[0].colorSpace};
    }

    static constexpr auto preferredFormatArray = getPreferredFormats();
    for (const auto &candidate : surfaceFormats) {
        if (std::find(preferredFormatArray.begin(), preferredFormatArray.end(),
                      candidate.format) != preferredFormatArray.end()) {
            return candidate;
        }
    }

    // Fallback: if no preferred formats are found, use first available format.
    spdlog::debug(
        "No preferred format found, using the first available format.");
    return surfaceFormats[0];
}

[[nodiscard]] static VkExtent2D
getSwapchainSize(GLFWwindow *window,
                 const VkSurfaceCapabilitiesKHR &surfaceCapabilities) {
    VkExtent2D swapchainSize;
    if (surfaceCapabilities.currentExtent.width == 0xFFFFFFFF) {
        int width, height;
        glfwGetFramebufferSize(window, &width, &height);
        swapchainSize = {static_cast<uint32_t>(width),
                         static_cast<uint32_t>(height)};
    } else {
        swapchainSize = surfaceCapabilities.currentExtent;
    }

    spdlog::debug("Swapchain size: {}x{}", swapchainSize.width,
                  swapchainSize.height);
    return swapchainSize;
}

struct SwapchainConfig {
    VkSurfaceKHR surface = VK_NULL_HANDLE;
    VkSurfaceCapabilitiesKHR surfaceCapabilities{};
    VkExtent2D extent{};
    VkSurfaceFormatKHR surfaceFormat{};
    VkSwapchainKHR oldSwapchain = VK_NULL_HANDLE;
    bool enableReadback = false;
};

[[nodiscard]] static VkSwapchainKHR
createSwapchain(VkPhysicalDevice physicalDevice, VkDevice device,
                const SwapchainConfig &config) {
    // Determine the number of VkImage's to use in the swapchain.
    // Ideally, we desire to own 1 image at a time, the rest of the images can
    // either be rendered to and/or being queued up for display.
    uint32_t desiredSwapchainImages =
        config.surfaceCapabilities.minImageCount + 1;
    if ((config.surfaceCapabilities.maxImageCount > 0) &&
        (desiredSwapchainImages > config.surfaceCapabilities.maxImageCount)) {
        // Application must settle for fewer images than desired.
        desiredSwapchainImages = config.surfaceCapabilities.maxImageCount;
    }
    spdlog::debug("Desired swapchain images: {}", desiredSwapchainImages);

    // Just set identity bit transform
    VkSurfaceTransformFlagBitsKHR preTransform =
        VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;

    // Query available present modes
    uint32_t presentModeCount = 0;
    vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, config.surface,
                                              &presentModeCount, nullptr);

    static constexpr uint32_t presentModeCountMax = 30; // Safe upper bound
    std::array<VkPresentModeKHR, presentModeCountMax> presentModes;

    // Fill only the first presentModeCount elements
    vkGetPhysicalDeviceSurfacePresentModesKHR(
        physicalDevice, config.surface, &presentModeCount, presentModes.data());

    // Log only the valid entries
    spdlog::info("Available present modes:");
    for (uint32_t i = 0; i < presentModeCount; i++) {
        spdlog::info("- {}", (int)presentModes[i]);
    }

    VkPresentModeKHR swapchainPresentMode =
        VK_PRESENT_MODE_FIFO_KHR; // safe default

    // Select mode (MAILBOX → IMMEDIATE → FIFO)
    for (uint32_t i = 0; i < presentModeCount; i++) {
        VkPresentModeKHR mode = presentModes[i];

        if (mode == VK_PRESENT_MODE_MAILBOX_KHR) {
            swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
            break;
        }
        if (mode == VK_PRESENT_MODE_IMMEDIATE_KHR) {
            swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
        }
    }

    VkCompositeAlphaFlagBitsKHR composite = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
    if (config.surfaceCapabilities.supportedCompositeAlpha &
        VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) {
        composite = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
    } else if (config.surfaceCapabilities.supportedCompositeAlpha &
               VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
        composite = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
    } else if (config.surfaceCapabilities.supportedCompositeAlpha &
               VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) {
        composite = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
    } else if (config.surfaceCapabilities.supportedCompositeAlpha &
               VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) {
        composite = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR;
    }

    spdlog::debug("Composite alpha: {}", static_cast<int>(composite));

    spdlog::debug("Selected surface format");
    spdlog::info("Surface format: {}",
                 static_cast<int>(config.surfaceFormat.format));
    spdlog::info("Color space: {}",
                 static_cast<int>(config.surfaceFormat.colorSpace));

    // Create a swapchain
    spdlog::debug("Create a swapchain");
    VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
    if (config.enableReadback) {
        imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
    }
    VkSwapchainCreateInfoKHR swapchainCreateInfo{
        .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
        .pNext = nullptr,
        .surface = config.surface,
        .minImageCount = desiredSwapchainImages,
        .imageFormat = config.surfaceFormat.format,
        .imageColorSpace = config.surfaceFormat.colorSpace,
        .imageExtent =
            {
                .width = config.extent.width,
                .height = config.extent.height,
            },
        .imageArrayLayers = 1,
        .imageUsage = imageUsage,
        .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .preTransform = preTransform,
        .compositeAlpha = composite,
        .presentMode = swapchainPresentMode,
        .clipped = VK_TRUE,
        .oldSwapchain = config.oldSwapchain,
    };

    VkSwapchainKHR swapchain;
    VK_CHECK(vkCreateSwapchainKHR(device, &swapchainCreateInfo, nullptr,
                                  &swapchain));

    return swapchain;
}

[[nodiscard]] static SwapchainImages
getSwapchainImages(VkDevice device, VkSwapchainKHR swapchain) {
    SwapchainImages swapchainImages;
    uint32_t swapchainImageCount;
    VK_CHECK(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount,
                                     nullptr));
    spdlog::debug("Swapchain image count: {}", swapchainImageCount);
    swapchainImages.count = swapchainImageCount;

    if (swapchainImageCount > MAX_FRAME_SLOTS) {
        throw std::runtime_error(fmt::format("Swapchain image count {} exceeds "
                                             "maximum images {}",
                                             swapchainImageCount,
                                             MAX_FRAME_SLOTS));
    }

    VK_CHECK(vkGetSwapchainImagesKHR(device, swapchain, &swapchainImageCount,
                                     swapchainImages.images.data()));
    for (uint32_t i = 0; i < swapchainImageCount; i++) {
        spdlog::debug("Swapchain image {}", i);
    }
    return swapchainImages;
}

[[nodiscard]] static SwapchainImageViews
createSwapchainImageViews(VkDevice device, VkSurfaceFormatKHR surfaceFormat,
                          const SwapchainImages &swapchainImages) {
    // Create image views
    SwapchainImageViews swapchainImageViews;
    swapchainImageViews.count = swapchainImages.count;
    for (uint32_t i = 0; i < swapchainImages.count; i++) {
        VkImageViewCreateInfo imageViewCreateInfo{
            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
            .flags = 0,
            .image = swapchainImages.images[i],
            .viewType = VK_IMAGE_VIEW_TYPE_2D,
            .format = surfaceFormat.format,
            .components =
                {
                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
                    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
                    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
                    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
                },
            .subresourceRange =
                {
                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                    .baseMipLevel = 0,
                    .levelCount = 1,
                    .baseArrayLayer = 0,
                    .layerCount = 1,
                },
        };
        imageViewCreateInfo.pNext = nullptr;

        VK_CHECK(vkCreateImageView(device, &imageViewCreateInfo, nullptr,
                                   &swapchainImageViews.imageViews[i]));
    }
    return swapchainImageViews;
}

[[nodiscard]] static VkCommandPool
createCommandPool(VkDevice device, uint32_t graphicsQueueIndex) {
    spdlog::debug("Create command pool");
    VkCommandPoolCreateInfo commandPoolCreateInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
        .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
        .queueFamilyIndex = graphicsQueueIndex,
    };
    VkCommandPool commandPool = VK_NULL_HANDLE;
    VK_CHECK(vkCreateCommandPool(device, &commandPoolCreateInfo, nullptr,
                                 &commandPool));
    return commandPool;
}

[[nodiscard]] static uint32_t
findMemoryTypeIndex(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
                    VkMemoryPropertyFlags properties) {
    VkPhysicalDeviceMemoryProperties memProperties;
    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);

    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
        if ((typeFilter & (1 << i)) &&
            (memProperties.memoryTypes[i].propertyFlags & properties) ==
                properties) {
            return i;
        }
    }
    throw std::runtime_error("Failed to find suitable memory type");
}

[[nodiscard]] static ReadbackBuffer
createReadbackBuffer(VkDevice device, VkPhysicalDevice physicalDevice,
                     VkDeviceSize size, VkBufferUsageFlags usage,
                     VkMemoryPropertyFlags properties) {
    ReadbackBuffer buffer{
        .size = size,
    };
    VkBufferCreateInfo bufferInfo{
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = size,
        .usage = usage,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
    };

    VK_CHECK(vkCreateBuffer(device, &bufferInfo, nullptr, &buffer.buffer));

    VkMemoryRequirements memRequirements;
    vkGetBufferMemoryRequirements(device, buffer.buffer, &memRequirements);

    VkMemoryAllocateInfo allocInfo{
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize = memRequirements.size,
        .memoryTypeIndex = findMemoryTypeIndex(
            physicalDevice, memRequirements.memoryTypeBits, properties),
    };

    VK_CHECK(vkAllocateMemory(device, &allocInfo, nullptr, &buffer.memory));
    VK_CHECK(vkBindBufferMemory(device, buffer.buffer, buffer.memory, 0));

    return buffer;
}

static void destroyReadbackBuffer(VkDevice device, ReadbackBuffer &buffer) {
    if (buffer.buffer != VK_NULL_HANDLE) {
        vkDestroyBuffer(device, buffer.buffer, nullptr);
    }
    if (buffer.memory != VK_NULL_HANDLE) {
        vkFreeMemory(device, buffer.memory, nullptr);
    }
    buffer.buffer = VK_NULL_HANDLE;
    buffer.memory = VK_NULL_HANDLE;
    buffer.size = 0;
}

[[nodiscard]] static VkDescriptorSetLayout
createDescriptorSetLayout(VkDevice device) {
    VkDescriptorSetLayoutBinding layoutBinding{
        .binding = 0,
        .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
        .descriptorCount = 1,
        .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
    };

    VkDescriptorSetLayoutCreateInfo layoutInfo{
        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
        .bindingCount = 1,
        .pBindings = &layoutBinding,
    };

    VkDescriptorSetLayout descriptorSetLayout;
    VK_CHECK(vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr,
                                         &descriptorSetLayout));
    return descriptorSetLayout;
}

[[nodiscard]] static VkDescriptorPool createDescriptorPool(VkDevice &device) {
    VkDescriptorPoolSize poolSize{};
    poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    poolSize.descriptorCount = 1;

    VkDescriptorPoolCreateInfo poolInfo{};
    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
    poolInfo.poolSizeCount = 1;
    poolInfo.pPoolSizes = &poolSize;
    poolInfo.maxSets = 1;

    VkDescriptorPool descriptorPool;
    VK_CHECK(
        vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool));
    return descriptorPool;
}

[[nodiscard]] static VkDescriptorSet
allocateDescriptorSet(VkDescriptorPool &descriptorPool, VkDevice &device,
                      VkDescriptorSetLayout &descriptorSetLayout) {
    VkDescriptorSetAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    allocInfo.descriptorPool = descriptorPool;
    allocInfo.descriptorSetCount = 1;
    allocInfo.pSetLayouts = &descriptorSetLayout;

    VkDescriptorSet descriptorSet;
    VK_CHECK(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
    return descriptorSet;
}

[[nodiscard]] static CommandBuffers
createCommandBuffers(VkDevice device, VkCommandPool commandPool,
                     uint32_t commandBufferCount) {
    CommandBuffers commandBuffers;
    commandBuffers.count = commandBufferCount;
    spdlog::info("Create command buffers");
    VkCommandBufferAllocateInfo commandBufferAllocateInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .pNext = nullptr,
        .commandPool = commandPool,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = commandBufferCount,
    };
    VK_CHECK(vkAllocateCommandBuffers(device, &commandBufferAllocateInfo,
                                      commandBuffers.commandBuffers.data()));
    return commandBuffers;
}

static void transitionImageLayout(VkDevice logicalDevice,
                                  VkCommandPool commandPool, VkQueue queue,
                                  VkImage image, VkImageLayout oldLayout,
                                  VkImageLayout newLayout) {
    VkCommandBufferAllocateInfo allocInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .commandPool = commandPool,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = 1,
    };

    VkCommandBuffer commandBuffer;
    VK_CHECK(
        vkAllocateCommandBuffers(logicalDevice, &allocInfo, &commandBuffer));

    VkCommandBufferBeginInfo beginInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    };
    VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));

    VkImageMemoryBarrier barrier{
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .oldLayout = oldLayout,
        .newLayout = newLayout,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .image = image,
        .subresourceRange =
            {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 1,
            },
    };

    VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
    VkPipelineStageFlags dstStage =
        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED &&
        newLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
        // No need to wait on prior writes; we don't care about old contents.
        barrier.srcAccessMask = 0;
        // Make color-attachment writes visible for subsequent render pass use.
        barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    } else {
        throw std::runtime_error("Unsupported image layout transition");
    }

    vkCmdPipelineBarrier(commandBuffer, srcStage, dstStage, 0, 0, nullptr, 0,
                         nullptr, 1, &barrier);

    VK_CHECK(vkEndCommandBuffer(commandBuffer));

    VkSubmitInfo submitInfo{
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .commandBufferCount = 1,
        .pCommandBuffers = &commandBuffer,
    };

    // Submit and wait so the image is ready before further use.
    VK_CHECK(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
    VK_CHECK(vkQueueWaitIdle(queue));
    vkFreeCommandBuffers(logicalDevice, commandPool, 1, &commandBuffer);
}

[[nodiscard]] static Fences createFences(VkDevice device, uint32_t count) {
    spdlog::info("Create fences");
    Fences fences;
    fences.count = count;
    for (uint32_t i = 0; i < count; i++) {
        VkFenceCreateInfo fenceCreateInfo{
            .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
            .flags = VK_FENCE_CREATE_SIGNALED_BIT,
        };
        VK_CHECK(vkCreateFence(device, &fenceCreateInfo, nullptr,
                               &fences.fences[i]));
    }
    return fences;
}

[[nodiscard]] static VkSemaphore createSemaphore(VkDevice device) {
    VkSemaphoreCreateInfo semaphoreCreateInfo{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    };
    VkSemaphore semaphore;
    VK_CHECK(
        vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphore));
    return semaphore;
}

[[nodiscard]] static Semaphores createSemaphores(VkDevice device,
                                                 uint32_t count) {
    Semaphores semaphores;
    semaphores.count = count;
    for (uint32_t i = 0; i < count; i++) {
        semaphores.semaphores[i] = createSemaphore(device);
    }
    return semaphores;
}

[[nodiscard]] static VkRenderPass
createRenderPass(VkDevice device, VkFormat format, bool offline = false) {
    spdlog::debug("Create render pass");
    VkAttachmentDescription colorAttachment{
        .format = format,
        .samples = VK_SAMPLE_COUNT_1_BIT,
        .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
        .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
        .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
        .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
        // Offline keeps the image in COLOR_ATTACHMENT_OPTIMAL between passes,
        // transitioning to TRANSFER_SRC_OPTIMAL only for readback.
        // Swapchain rendering discards old contents and transitions to PRESENT.
        .initialLayout = offline ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
                                 : VK_IMAGE_LAYOUT_UNDEFINED,
        .finalLayout = offline ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
                               : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
    };

    VkAttachmentReference colorAttachmentRef{
        .attachment = 0,
        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
    };

    VkSubpassDescription subpass{
        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
        .colorAttachmentCount = 1,
        .pColorAttachments = &colorAttachmentRef,
    };

    VkRenderPassCreateInfo renderPassInfo{
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
        .attachmentCount = 1,
        .pAttachments = &colorAttachment,
        .subpassCount = 1,
        .pSubpasses = &subpass,
    };

    VkRenderPass renderPass;
    VK_CHECK(vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass));

    return renderPass;
}

[[nodiscard]] static FrameBuffers
createFrameBuffers(VkDevice device, VkRenderPass renderPass, VkExtent2D extent,
                   const SwapchainImageViews &swapchainImageViews) {
    spdlog::info("Create framebuffers");
    FrameBuffers frameBuffers;
    frameBuffers.count = swapchainImageViews.count;
    for (uint32_t i = 0; i < swapchainImageViews.count; i++) {
        VkFramebufferCreateInfo framebufferInfo{
            .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
            .renderPass = renderPass,
            .attachmentCount = 1,
            .pAttachments = &swapchainImageViews.imageViews[i],
            .width = extent.width,
            .height = extent.height,
            .layers = 1,
        };

        VK_CHECK(vkCreateFramebuffer(device, &framebufferInfo, nullptr,
                                     &frameBuffers.framebuffers[i]));
    }
    return frameBuffers;
}

[[nodiscard]] static VkPipelineLayout createPipelineLayout(VkDevice device) {
    spdlog::info("Create pipeline layout");
    VkPushConstantRange pushConstantRange{
        .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
        .offset = 0,
        .size = sizeof(vkutils::PushConstants),
    };
    VkPipelineLayoutCreateInfo pipelineLayoutInfo{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .setLayoutCount = 0,
        .pushConstantRangeCount = 1,
        .pPushConstantRanges = &pushConstantRange,
    };

    VkPipelineLayout pipelineLayout;
    VK_CHECK(vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr,
                                    &pipelineLayout));
    return pipelineLayout;
}

[[nodiscard]] static VkShaderModule
createShaderModule(VkDevice device, const std::string &filename) {
    spdlog::info("Create shader module");
    VkShaderModule shaderModule;
    auto code = loadSpvFile(filename);
    VkShaderModuleCreateInfo createinfo{
        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .codeSize = code.size() * sizeof(uint32_t),
        .pCode = code.data(),
    };

    VK_CHECK(vkCreateShaderModule(device, &createinfo, nullptr, &shaderModule));
    return shaderModule;
}

[[nodiscard]] static VkShaderModule
createShaderModule(VkDevice device, const std::vector<uint32_t> &spirv) {
    spdlog::info("Create shader module from SPIR-V");
    VkShaderModule shaderModule;
    VkShaderModuleCreateInfo createinfo{
        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .codeSize = spirv.size() * sizeof(uint32_t),
        .pCode = spirv.data(),
    };

    VK_CHECK(vkCreateShaderModule(device, &createinfo, nullptr, &shaderModule));
    return shaderModule;
}

[[nodiscard]] static VkPipeline
createGraphicsPipeline(VkDevice device, VkRenderPass renderPass,
                       VkPipelineLayout pipelineLayout, VkExtent2D extent,
                       VkShaderModule vertShaderModule,
                       VkShaderModule fragShaderModule) {
    spdlog::info("Create graphics pipeline");
    VkPipeline pipeline;

    VkPipelineShaderStageCreateInfo shaderStages[2] = {
        // Note: This one would never change
        {
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage = VK_SHADER_STAGE_VERTEX_BIT,
            .module = vertShaderModule,
            .pName = "main",
        },
        {
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
            .module = fragShaderModule,
            .pName = "main",
        },
    };

    VkPipelineVertexInputStateCreateInfo vertexInputInfo{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
        .vertexBindingDescriptionCount = 0,
        .vertexAttributeDescriptionCount = 0,
    };

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

    VkViewport viewport{
        .x = 0.0f,
        .y = 0.0f,
        .width = static_cast<float>(extent.width),
        .height = static_cast<float>(extent.height),
        .minDepth = 0.0f,
        .maxDepth = 1.0f,
    };

    VkRect2D scissor{
        .offset = {0, 0},
        .extent = extent,
    };

    VkDynamicState dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT,
                                      VK_DYNAMIC_STATE_SCISSOR};
    VkPipelineDynamicStateCreateInfo dynamicStateInfo{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .dynamicStateCount = 2,
        .pDynamicStates = dynamicStates,
    };

    VkPipelineViewportStateCreateInfo viewportState{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .viewportCount = 1,
        .pViewports = &viewport,
        .scissorCount = 1,
        .pScissors = &scissor,
    };

    VkPipelineRasterizationStateCreateInfo rasterizer{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .depthClampEnable = VK_FALSE,
        .rasterizerDiscardEnable = VK_FALSE,
        .polygonMode = VK_POLYGON_MODE_FILL,
        .cullMode = VK_CULL_MODE_NONE,
        .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
        .depthBiasEnable = VK_FALSE,
        .lineWidth = 1.0f, // It doesn't matter really we are doing SDF
    };

    VkPipelineMultisampleStateCreateInfo multisampling{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
        .sampleShadingEnable = VK_FALSE,
    };

    VkPipelineColorBlendAttachmentState colorBlendAttachment{
        .blendEnable = VK_FALSE,
        .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                          VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
    };

    VkPipelineColorBlendStateCreateInfo colorBlending{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .logicOpEnable = VK_FALSE,
        .logicOp = VK_LOGIC_OP_COPY,
        .attachmentCount = 1,
        .pAttachments = &colorBlendAttachment,
    };

    VkGraphicsPipelineCreateInfo pipelineInfo = {
        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .stageCount = 2,
        .pStages = shaderStages,
        .pVertexInputState = &vertexInputInfo,
        .pInputAssemblyState = &inputAssembly,
        .pViewportState = &viewportState,
        .pRasterizationState = &rasterizer,
        .pMultisampleState = &multisampling,
        .pColorBlendState = &colorBlending,
        .pDynamicState = &dynamicStateInfo,
        .layout = pipelineLayout,
        .renderPass = renderPass,
        .subpass = 0,
    };
    VK_CHECK(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo,
                                       nullptr, &pipeline));
    spdlog::info("Created graphics pipeline");
    return pipeline;
}

[[nodiscard]] static VkQueryPool createQueryPool(VkDevice device,
                                                 uint32_t numSwapchainImages) {
    // Query pool used for calculating frame processing duration
    VkQueryPoolCreateInfo queryPooolCreateInfo{
        .sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
        .queryType = VK_QUERY_TYPE_TIMESTAMP,
        .queryCount = 2 * numSwapchainImages, // 2 per frame, start and end
    };

    VkQueryPool queryPool;
    VK_CHECK(
        vkCreateQueryPool(device, &queryPooolCreateInfo, nullptr, &queryPool));
    return queryPool;
}

static void recordCommandBuffer(VkQueryPool queryPool, VkRenderPass renderPass,
                                VkExtent2D extent, VkPipeline pipeline,
                                VkPipelineLayout pipelineLayout,
                                VkCommandBuffer commandBuffer,
                                VkFramebuffer framebuffer,
                                const PushConstants &pushConstants,
                                uint32_t imageIndex) {
    vkResetCommandBuffer(commandBuffer, 0);
    VkCommandBufferBeginInfo beginInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
    };

    VkRenderPassBeginInfo renderPassBeginInfo{
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
        .renderPass = renderPass,
        .framebuffer = framebuffer,
        .renderArea = {{0, 0}, extent},
        .clearValueCount = 0,
    };
    spdlog::debug("Record command buffer");
    VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));
    vkCmdResetQueryPool(commandBuffer, queryPool, imageIndex * 2, 2);
    vkCmdWriteTimestamp(commandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                        queryPool, imageIndex * 2);
    vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo,
                         VK_SUBPASS_CONTENTS_INLINE);
    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);

    vkCmdPushConstants(commandBuffer, pipelineLayout,
                       VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants),
                       &pushConstants);
    VkRect2D scissor{
        .offset = {0, 0},
        .extent = {extent.width, extent.height},
    };

    VkViewport viewport{
        .x = 0.0f,
        .y = 0.0f,
        .width = static_cast<float>(extent.width),
        .height = static_cast<float>(extent.height),
        .minDepth = 0.0f,
        .maxDepth = 1.0f,
    };

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

    vkCmdDraw(commandBuffer, 6, 1, 0, 0);
    vkCmdWriteTimestamp(commandBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                        queryPool, imageIndex * 2 + 1);
    vkCmdEndRenderPass(commandBuffer);
    spdlog::debug("End command buffer");
    VK_CHECK(vkEndCommandBuffer(commandBuffer));
    spdlog::debug("Ended command buffer");
}

static void submitCommandBuffer(VkQueue queue, VkCommandBuffer commandBuffer,
                                VkSemaphore imageAvailableSemaphore,
                                VkSemaphore renderFinishedSemaphore,
                                VkFence fence) {
    VkPipelineStageFlags waitStages[] = {
        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
    VkSubmitInfo submitInfo{
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &imageAvailableSemaphore,
        .pWaitDstStageMask = waitStages,
        .commandBufferCount = 1,
        .pCommandBuffers = &commandBuffer,
        .signalSemaphoreCount = 1,
        .pSignalSemaphores = &renderFinishedSemaphore,
    };
    VK_CHECK(vkQueueSubmit(queue, 1, &submitInfo, fence));
}

struct ReadbackContext {
    VkDevice device = VK_NULL_HANDLE;
    VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
    VkCommandPool commandPool = VK_NULL_HANDLE;
    VkQueue queue = VK_NULL_HANDLE;
};

[[nodiscard]] static PPMDebugFrame
debugReadbackSwapchainImage(const ReadbackContext &context, VkImage srcImage,
                            VkFormat format, VkExtent2D extent) {
    // Intended for quick validation/smoke tests of the presented swapchain
    // path. You'd want to avoid swapchain if you just wanted to only encode
    // video for example, to save time
    const ReadbackFormatInfo formatInfo = getReadbackFormatInfo(format);

    VkDeviceSize imageSize = static_cast<VkDeviceSize>(extent.width) *
                             static_cast<VkDeviceSize>(extent.height) *
                             formatInfo.bytesPerPixel;

    ReadbackBuffer stagingBuffer =
        createReadbackBuffer(context.device, context.physicalDevice, imageSize,
                             VK_BUFFER_USAGE_TRANSFER_DST_BIT,
                             VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);

    VkCommandBufferAllocateInfo allocInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .commandPool = context.commandPool,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = 1,
    };

    VkCommandBuffer commandBuffer;
    VK_CHECK(
        vkAllocateCommandBuffers(context.device, &allocInfo, &commandBuffer));

    VkCommandBufferBeginInfo beginInfo{
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    };
    VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));

    // This barrier moves from present → transfer‑src so we can read it.
    VkImageMemoryBarrier barrierToTransfer{
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
        .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
        .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .image = srcImage,
        .subresourceRange =
            {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 1,
            },
    };

    vkCmdPipelineBarrier(commandBuffer,
                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                         VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0,
                         nullptr, 1, &barrierToTransfer);

    VkBufferImageCopy region{
        .bufferOffset = 0,
        .bufferRowLength = 0,
        .bufferImageHeight = 0,
        .imageSubresource =
            {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .mipLevel = 0,
                .baseArrayLayer = 0,
                .layerCount = 1,
            },
        .imageOffset = {0, 0, 0},
        .imageExtent = {extent.width, extent.height, 1},
    };

    vkCmdCopyImageToBuffer(commandBuffer, srcImage,
                           VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                           stagingBuffer.buffer, 1, &region);

    // This is the “undo” barrier after the copy.
    // It transitions the swapchain image back to PRESENT_SRC_KHR so the
    // presentation engine can display it. After the copy, you must move it back
    // to present layout for vkQueuePresentKHR.
    VkImageMemoryBarrier barrierToPresent{
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
        .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
        .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .image = srcImage,
        .subresourceRange =
            {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 1,
            },
    };

    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0,
                         nullptr, 1, &barrierToPresent);

    VK_CHECK(vkEndCommandBuffer(commandBuffer));

    VkSubmitInfo submitInfo{
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .commandBufferCount = 1,
        .pCommandBuffers = &commandBuffer,
    };

    VK_CHECK(vkQueueSubmit(context.queue, 1, &submitInfo, VK_NULL_HANDLE));
    VK_CHECK(vkQueueWaitIdle(context.queue));

    void *data = nullptr;
    VK_CHECK(vkMapMemory(context.device, stagingBuffer.memory, 0, imageSize, 0,
                         &data));

    PPMDebugFrame frame;
    frame.allocateRGB(extent.width, extent.height);
    const uint8_t *src = static_cast<const uint8_t *>(data);
    const size_t pixelCount =
        static_cast<size_t>(extent.width) * static_cast<size_t>(extent.height);
    for (size_t i = 0; i < pixelCount; ++i) {
        const size_t srcOffset = i * formatInfo.bytesPerPixel;
        const size_t dstOffset = i * 3;
        uint8_t r = 0;
        uint8_t g = 0;
        uint8_t b = 0;
        if (formatInfo.swapRB) {
            r = src[srcOffset + 2];
            g = src[srcOffset + 1];
            b = src[srcOffset + 0];
        } else {
            r = src[srcOffset + 0];
            g = src[srcOffset + 1];
            b = src[srcOffset + 2];
        }
        frame.rgb[dstOffset + 0] = r;
        frame.rgb[dstOffset + 1] = g;
        frame.rgb[dstOffset + 2] = b;
    }

    vkUnmapMemory(context.device, stagingBuffer.memory);
    vkFreeCommandBuffers(context.device, context.commandPool, 1,
                         &commandBuffer);
    destroyReadbackBuffer(context.device, stagingBuffer);

    return frame;
}

static void presentImage(VkQueue queue, VkSwapchainKHR swapchain,
                         VkSemaphore renderFinishedSemaphore,
                         uint32_t imageIndex) {
    VkPresentInfoKHR presentInfo{
        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &renderFinishedSemaphore,
        .swapchainCount = 1,
        .pSwapchains = &swapchain,
        .pImageIndices = &imageIndex,
    };
    VK_CHECK(vkQueuePresentKHR(queue, &presentInfo));
}

static void
destroySwapchainImageViews(VkDevice device,
                           SwapchainImageViews &swapchainImageViews) noexcept {
    for (uint32_t i = 0; i < swapchainImageViews.count; ++i) {
        vkDestroyImageView(device, swapchainImageViews.imageViews[i], nullptr);
        swapchainImageViews.imageViews[i] = VK_NULL_HANDLE;
    }
}

static void destroyFrameBuffers(VkDevice device,
                                FrameBuffers &frameBuffers) noexcept {
    for (uint32_t i = 0; i < frameBuffers.count; ++i) {
        vkDestroyFramebuffer(device, frameBuffers.framebuffers[i], nullptr);
        frameBuffers.framebuffers[i] = VK_NULL_HANDLE;
    }
}

static void destroyFences(VkDevice device, Fences &fences) noexcept {
    for (uint32_t i = 0; i < fences.count; ++i) {
        vkDestroyFence(device, fences.fences[i], nullptr);
        fences.fences[i] = VK_NULL_HANDLE;
    }
}

static void destroySemaphores(VkDevice device,
                              Semaphores &semaphores) noexcept {
    for (uint32_t i = 0; i < semaphores.count; ++i) {
        vkDestroySemaphore(device, semaphores.semaphores[i], nullptr);
        semaphores.semaphores[i] = VK_NULL_HANDLE;
    }
}

} // namespace vkutils

#endif