#pragma once

#include "freelist.hpp"
#include "vk-command-buffer.hpp"

using VmaAllocator = struct VmaAllocator_T*;

struct command_buffer;
class window;

class vkdevice {
    struct queue {
        VkQueue       vk_queue      = VK_NULL_HANDLE;
        uint32_t      index         = UINT32_MAX;
        VkQueueFlags  usages;
        VkCommandPool command_pool  = VK_NULL_HANDLE;
    };

    public:
    void init();
    void deinit();

    static inline vkdevice& get() {
        return render_device;
    }

    handle<device_texture>   create_texture(const texture_desc& desc);

    handle<device_sampler>   create_sampler(const sampler_desc& desc);

    handle<device_buffer>    create_buffer(const buffer_desc& desc);

    handle<device_pipeline>  create_graphics_pipeline(const graphics_pipeline_desc& desc);

    handle<device_pipeline>  create_compute_pipeline(const compute_pipeline_desc& desc);

    handle<device_surface>   create_surface(const surface_desc& desc);

    void                     destroy_texture(handle<device_texture> handle);

    void                     destroy_sampler(handle<device_sampler> handle);

    void                     destroy_buffer(handle<device_buffer> handle);

    void                     destroy_pipeline(handle<device_pipeline> handle);

    void                     destroy_surface(handle<device_surface> handle);

    template<typename buffer_type>
    void allocate_command_buffers(buffer_type* buffers, size_t count, QueueType queue_type, const char* name) {
        allocate_command_buffers(static_cast<command_buffer*>(buffers), count, queue_type, name);
    }

    [[nodiscard]] inline device_texture* get_texture(handle<device_texture> handle) {
        return &textures[handle];
    }

    [[nodiscard]] inline device_sampler* get_sampler(handle<device_sampler> handle) {
        return &samplers[handle];
    }

    [[nodiscard]] inline device_buffer* get_buffer(handle<device_buffer> handle) {
        return &buffers[handle];
    }

    [[nodiscard]] inline const device_pipeline* get_pipeline(handle<device_pipeline> handle) const {
        return &pipelines[handle];
    }

    [[nodiscard]] inline device_surface* get_surface(handle<device_surface> handle) {
        return &surfaces[handle];
    }

    // uint64_t submit(std::span<command_buffer> buffers, handle<device_semaphore> wait_handle, handle<device_semaphore> signal_handle, handle<device_semaphore> fence_handle);
    uint32_t acquire_image_index(handle<device_surface> surface_handle);
    uint64_t submit_before_present(handle<device_surface> surface_handle, command_buffer* buffers, uint32_t count);
    uint64_t submit(command_buffer* buffers, uint32_t count);

    void present(handle<device_surface> surface_handle);

    void wait();

    void wait_for_fence(u64 value);

    private:
    vkdevice() = default;
    ~vkdevice() = default;

    void allocate_command_buffers(command_buffer* buffers, size_t count, QueueType type, const char* name);

    void create_swapchain(const surface_desc& desc, device_surface& surface);

    // TODO: Wrap in a struct called adapter ?
    void                        create_instance();

    void                        create_device();

    bool                        device_support_features(VkPhysicalDevice physical_dev);

    queue                       queues[static_cast<uint32_t>(QueueType::MAX)];

    static constexpr size_t     max_allocable_command_buffers  = 16;
    static constexpr size_t     max_submitable_command_buffers = 16;

    freelist<device_texture>    textures;
    freelist<device_sampler>    samplers;
    freelist<device_buffer>     buffers;
    freelist<device_pipeline>   pipelines;
    freelist<device_surface>    surfaces;

    device_semaphore            fence;

    static vkdevice             render_device;

#ifdef _DEBUG
    VkDebugUtilsMessengerEXT debug_messenger;
#endif // _DEBUG
};