// Copyright 2022 Simon Boyé
#pragma once

#include <vk/forward.h>
#include <vk/Memory.h>

#include <core/utils.h>

#include <vulkan/vulkan.h>

#include <memory>
#include <vector>


namespace vk {


class Buffer {
public:
    Buffer() noexcept;
    Buffer(
        Context& context,
        VkDeviceSize size,
        VkBufferUsageFlags usage
    );
    Buffer(
        Context& context,
        VkDeviceSize size,
        VkBufferUsageFlags usage,
        VkMemoryPropertyFlags memory_properties
    );
    Buffer(const Buffer&) = delete;
    Buffer(Buffer&& other) noexcept;
    ~Buffer() noexcept;

    Buffer& operator=(const Buffer&) = delete;
    Buffer& operator=(Buffer&& other) noexcept;

    inline explicit operator bool() const {
        return !is_null();
    }

    inline bool is_null() const {
        return m_buffer == VK_NULL_HANDLE;
    }

    inline Context* context() noexcept {
        return m_context;
    }

    inline const Context* context() const noexcept {
        return m_context;
    }

    inline operator VkBuffer() const noexcept {
        return m_buffer;
    }

    inline VkBuffer buffer() const noexcept {
        return m_buffer;
    }

    inline const MemoryBlock& memory() const noexcept {
        return m_memory;
    }

    inline MemoryBlock& memory() noexcept {
        return m_memory;
    }

    VkMemoryRequirements memory_requirements() const noexcept;

    void bind_memory(const MemoryBlock& memory_block, VkDeviceSize offset=0);
    void bind_memory(MemoryBlock&& memory_block);
    void allocate_and_bind_memory(VkMemoryPropertyFlags memory_properties);

    void upload(size_t size, void* src_buffer, uint32_t dst_queue_family);

    void destroy() noexcept;

private:
    Context* m_context = nullptr;
    VkBuffer m_buffer = VK_NULL_HANDLE;
    MemoryBlock m_memory;
};


}