assets-manager.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
 
#include "flint/core/asset-loader.h"
#include "flint/graphics/gpu/gpu-texture.h"
#include "flint/time/time.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
 
namespace Flint {
 
  class AssetManager {
      struct ManagerLifetime {};
 
      AssetManager(const AssetManager &) = delete;
      AssetManager &operator=(const AssetManager &) = delete;
 
    public:
      AssetManager(IAssetLoader &loader, SDL_GPUDevice *gpuDevice, bool hotReloadEnable)
        : m_loader(loader),
          m_gpuDevice(gpuDevice),
          m_hotReloadEnabled(hotReloadEnable) {
        m_hotReloadClock.start();
      }
 
      ~AssetManager() {
        m_managerLifetime.reset();
      }
 
      using ReloadCallback = std::function<void(const std::string &)>;
 
      class WatchHandle {
        public:
          WatchHandle() = default;
 
          WatchHandle(AssetManager *manager, uint64_t id,
                      std::weak_ptr<ManagerLifetime> managerLifetime)
            : m_manager(manager),
              m_id(id),
              m_managerLifetime(std::move(managerLifetime)) {
          }
 
          ~WatchHandle() {
            reset();
          }
 
          WatchHandle(WatchHandle &&other) noexcept
            : m_manager(other.m_manager),
              m_id(other.m_id),
              m_managerLifetime(std::move(other.m_managerLifetime)) {
            other.m_manager = nullptr;
          }
 
          WatchHandle &operator=(WatchHandle &&other) noexcept {
            if (this != &other) {
              reset();
 
              m_manager = other.m_manager;
              m_id = other.m_id;
              m_managerLifetime = std::move(other.m_managerLifetime);
 
              other.m_manager = nullptr;
            }
            return *this;
          }
 
          WatchHandle(const WatchHandle &) = delete;
          WatchHandle &operator=(const WatchHandle &) = delete;
 
          [[nodiscard]] bool isActive() const {
            return m_manager != nullptr && !m_managerLifetime.expired();
          }
 
          void reset() {
            if (m_manager && !m_managerLifetime.expired()) {
              m_manager->unwatch(m_id);
            }
 
            m_manager = nullptr;
            m_managerLifetime.reset();
          }
 
        private:
          AssetManager *m_manager = nullptr;
          uint64_t      m_id = 0;
 
          std::weak_ptr<ManagerLifetime> m_managerLifetime;
      };
 
      GPUTexture &getTexture(const std::string &path);
 
      [[nodiscard]] WatchHandle watch(const std::string &path, ReloadCallback callback);
 
      void update();
 
      IAssetLoader &getLoader() {
        return m_loader;
      }
 
      void setHotReloadEnabled(bool enabled) {
        m_hotReloadEnabled = enabled;
      }
 
      [[nodiscard]] bool isHotReloadEnabled() const {
        return m_hotReloadEnabled;
      }
 
    private:
      std::shared_ptr<ManagerLifetime> m_managerLifetime = std::make_shared<ManagerLifetime>();
 
      void unwatch(uint64_t id);
 
      struct CachedTexture {
          GPUTexture texture;
          uint64_t   revision = 0;
          bool       missing = false;
      };
 
      struct WatchedAsset {
          std::string    path;
          uint64_t       revision = 0;
          uint64_t       pendingRevision = 0;  
          uint64_t       pendingSince = 0;     
          ReloadCallback callback;
          bool           missing = false;
      };
 
      IAssetLoader  &m_loader;
      SDL_GPUDevice *m_gpuDevice = nullptr;
 
      bool  m_hotReloadEnabled = false;
      Clock m_hotReloadClock;
      static constexpr uint64_t HOT_RELOAD_INTERVAL = 250;
      static constexpr uint64_t PENDING_RELOAD_INTERVAL = 150;
 
      std::unordered_map<std::string, CachedTexture> m_textures;
      std::unordered_map<uint64_t, WatchedAsset>     m_watched;
      uint64_t                                       m_nextWatchId = 1;
  };
}