#pragma once

#include <optional>
#include <span>

#include "FreeList.h"
#include "MacroUtils.h"
#include "RID.h"
#include "RenderDevice.h"
#include "VulkanHeader.h"

struct GlobalMemory;
struct RenderDevice;

struct Buffer
{
  VkBuffer      buffer;
  VmaAllocation allocation;
  std::byte*    mappedData; // Assume the system has ReBAR/SAM enabled.
  size_t        size;
  uint32_t      index;
};

static_assert( sizeof( Buffer ) > sizeof( FreeList::Node ) and "Buffer is used intrusively by FreeList" );
static_assert(
    offsetof( Buffer, index ) >= sizeof( FreeList::Node ) and "Index should not be overwritten even in invalid state" );

extern template struct RID<Buffer>;
using BufferID = RID<Buffer>;

struct BufferManager
{
private:
  constexpr static uint32_t INDEX_MASK        = 0x0007FFFF;
  constexpr static uint32_t GENERATION_MASK   = ~INDEX_MASK;
  constexpr static uint32_t GENERATION_OFFSET = 19;
  static_assert(
      ( ( GENERATION_MASK >> GENERATION_OFFSET & 0x1 ) == 0x1 ) and
      ( ( GENERATION_MASK >> ( GENERATION_OFFSET - 1 ) & 0x1 ) != 0x1 ) and "Checks boundary" );

  RenderDevice* m_pRenderDevice;

  // Texture Manager
  Buffer*  m_aBuffers;
  uint32_t m_count;
  uint32_t m_capacity;
  FreeList m_freeList;

  void     destroyBuffer( Buffer& buf );

  Buffer&  fetchBufferUnchecked( BufferID const& rid );
  void     writeToBufferImpl( BufferID const& rid, void const* data, size_t size );

public:
  [[nodiscard]] bool      isValidID( BufferID const& rid ) const;

  std::optional<BufferID> createVertexBuffer( size_t size );

  void                    freeBuffer( BufferID&& rid );

  DEPRECATE_JULY_2025
  std::optional<VkBuffer> fetchBuffer( BufferID const& rid );

  template <typename T>
  void writeToBuffer( BufferID const& rid, std::span<T> const& data )
  {
    writeToBufferImpl( rid, data.data(), data.size_bytes() );
  }

  //
  BufferManager( RenderDevice* pRenderDevice, Buffer* aBuffers, uint32_t capacity );
  void destroy();

  BufferManager( BufferManager const& other )                = delete;
  BufferManager( BufferManager&& other ) noexcept            = delete;
  BufferManager& operator=( BufferManager const& other )     = delete;
  BufferManager& operator=( BufferManager&& other ) noexcept = delete;
  ~BufferManager();
};

BufferManager* BufferManager_Create( GlobalMemory* mem, RenderDevice* renderDevice, uint32_t maxCount );