#include "AssetManager.hxx"

#include <cassert>
#include <filesystem>
#include <format>

#include <SDL_image.h>

AssetManager* AssetManager::instance_ = nullptr;

AssetManager::AssetManager(SDLRenderer& renderer)
    :renderer_{renderer}
{
  namespace fs = std::filesystem;

  assert(instance_==nullptr);

  auto current_path = fs::current_path();
  auto const asset_directory =
      fs::exists(current_path/"assets") ? current_path/"assets" :
      fs::exists(current_path.parent_path()/"assets") ? current_path.parent_path()/"assets" :
      fs::path{};
  if (asset_directory.empty()) {
    throw std::runtime_error("Assets directory not found.");
  }

  total_assets_ = std::distance(fs::directory_iterator(asset_directory),
      fs::directory_iterator());

  loading_thread_ = std::thread{&AssetManager::load_assets, this, asset_directory};
  instance_ = this;
}

AssetManager::~AssetManager()
{
  assert(instance_!=nullptr);
  if (loading_thread_.joinable()) {
    loading_thread_.join();
  }
  for (auto& kv: image_assets_) {
    SDL_FreeSurface(kv.second);
    SDL_Log("Unloaded texture %s successfully.", kv.first.c_str());
  }
  for (auto& kv: font_assets_) {
    TTF_CloseFont(kv.second);
    SDL_Log("Unloaded font %s successfully.", kv.first.c_str());
  }
  instance_ = nullptr;
}

void AssetManager::load_assets(std::filesystem::path const& asset_directory)
{
  for (auto const& entry: std::filesystem::directory_iterator(asset_directory)) {
    auto const path = entry.path().string();
    auto const ext = entry.path().extension();
    auto const filename = entry.path().filename().string();
    if (ext==".png" || ext==".jpg") {
      auto const surface = IMG_Load(path.c_str());
      if (surface==nullptr) {
        throw SDLError{std::format("Failed to load texture {}.", path)};
      }
      image_assets_[filename] = surface;
      SDL_Log("Loaded texture %s successfully.", filename.c_str());
    }
    else if (ext==".ttf") {
      auto const font = TTF_OpenFont(path.c_str(), 16);
      if (font==nullptr) {
        throw SDLError{std::format("Failed to load font {}.", path)};
      }
      font_assets_[filename] = font;
      SDL_Log("Loaded font %s successfully.", filename.c_str());
    }
    ++assets_loaded_;
  }
}

float AssetManager::get_progress() const
{
  return static_cast<float>(assets_loaded_)/static_cast<float>(total_assets_);
}

SDL_Surface* AssetManager::get_image_asset(std::string const& filepath)
{
  return image_assets_[filepath];
}

TTF_Font* AssetManager::get_font_asset(std::string const& filepath)
{
  return font_assets_[filepath];
}

AssetManager& AssetManager::instance() noexcept
{
  assert(instance_!=nullptr);
  return *instance_;
}