/*
 * Copyright 2025 Rive
 */

#include "rive/renderer/gpu_resource.hpp"

namespace rive::gpu
{
GPUResource::~GPUResource() {}

void GPUResource::onRefCntReachedZero() const
{
  // GPUResourceManager will hold off on deleting "this" until its safe frame
  // number has been reached. With no manager (the Metal Ore backend keeps
  // native objects alive via ARC and command-buffer retention rather than a
  // manager) there is no deferred reclaim, so delete now instead of leaking.
  if (m_manager)
    m_manager->onRenderingResourceReleased(const_cast<GPUResource*>(this));
  else
    delete const_cast<GPUResource*>(this);
}

GPUResourceManager::~GPUResourceManager()
{
  // Call shutdown() before destroying the resource manager.
  assert(m_currentFrameNumber == SHUTDOWN_FRAME_NUMBER);
  assert(m_safeFrameNumber == SHUTDOWN_FRAME_NUMBER);
  assert(m_resourcePurgatory.empty());
}

void GPUResourceManager::advanceFrameNumber(
    uint64_t nextFrameNumber,
    uint64_t safeFrameNumber)
{
  assert(nextFrameNumber >= m_currentFrameNumber);
  assert(safeFrameNumber >= m_safeFrameNumber);
  assert(safeFrameNumber <= nextFrameNumber);

  m_currentFrameNumber = nextFrameNumber;
  m_safeFrameNumber = safeFrameNumber;
  m_didAdvanceFrameNumber = true;

  // Delete all resources whose safe frame number has been reached.
  while (!m_resourcePurgatory.empty() &&
         m_resourcePurgatory.front().lastFrameNumber <= m_safeFrameNumber)
  {
    assert(m_resourcePurgatory.front().resource->debugging_refcnt() == 0);
    m_resourcePurgatory.pop_front();
  }
}

void GPUResourceManager::onRenderingResourceReleased(GPUResource* resource)
{
  assert(resource->manager() == this);

  // Hold the resource in purgatory (rather than freeing it now) only if GPU
  // work that might reference it could still be in flight:
  //   * during normal rendering, while frames are unfinished
  //     (m_currentFrameNumber > m_safeFrameNumber); or
  //   * before the first frame (!m_didAdvanceFrameNumber), where a one-shot
  //     upload may have submitted work referencing a just-released staging
  //     buffer while m_currentFrameNumber == m_safeFrameNumber == 0.
  // Otherwise -- the GPU has caught up to the current frame during rendering,
  // or we're in a shutdown cycle (which implies m_didAdvanceFrameNumber) --
  // delete immediately.
  if (m_currentFrameNumber > m_safeFrameNumber || !m_didAdvanceFrameNumber)
  {
    // Hold this resource until its safe frame number is reached.
    assert(resource->debugging_refcnt() == 0);
    assert(
        m_resourcePurgatory.empty() ||
        m_currentFrameNumber >= m_resourcePurgatory.back().lastFrameNumber);
    m_resourcePurgatory.emplace_back(resource, m_currentFrameNumber);
  }
  else
  {
    delete resource;
  }
}

void GPUResourceManager::shutdown()
{
  advanceFrameNumber(SHUTDOWN_FRAME_NUMBER, SHUTDOWN_FRAME_NUMBER);
}

rcp<GPUResource> GPUResourcePool::acquire()
{
  rcp<GPUResource> resource;
  if (!m_pool.empty() &&
      m_pool.front().lastFrameNumber <= m_manager->safeFrameNumber())
  {
    // Recycle the oldest buffer in the pool.
    resource = rcp(m_pool.front().resource.release());
    m_pool.pop_front();

    // Trim the pool in case it's grown out of control (meaning it was
    // advanced multiple times in a single frame).
    while (m_pool.size() > m_maxPoolCount &&
           m_pool.front().lastFrameNumber <= m_manager->safeFrameNumber())
    {
      m_pool.pop_front();
    }
  }
  assert(resource == nullptr || resource->debugging_refcnt() == 1);
  return resource;
}

void GPUResourcePool::recycle(rcp<GPUResource> resource)
{
  if (resource != nullptr)
  {
    // Return the current buffer to the pool.
    assert(resource->debugging_refcnt() == 1);
    assert(
        m_pool.empty() ||
        m_manager->currentFrameNumber() >= m_pool.back().lastFrameNumber);
    m_pool.emplace_back(resource.release(), m_manager->currentFrameNumber());
  }
}
} // namespace rive::gpu