// Copyright (c) 2022 Dominic Masters
// 
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT

#include "AssetManager.hpp"

#if !defined(DAWN_ASSET_BUILD_PREFIX)
  #error Asset Prefix has not been defined.
#endif

using namespace Dawn;

void AssetManager::init() {

}

void AssetManager::update() {
  this->syncTick();
}

void AssetManager::queueLoad(std::vector<Asset*> assets) {
  vectorAppend(&this->assetsToLoad, &assets);
}

void AssetManager::queueLoad(Asset *asset) {
  this->assetsToLoad.push_back(asset);
}

void AssetManager::queueUnload(std::vector<Asset*> assets) {
  std::cout << "Asset list was queued to unload, but is not yet implemented" << std::endl;
  vectorAppend(&this->assetsToUnload, &assets);
}

void AssetManager::queueUnload(Asset *asset) {
  std::cout << "Asset was queued to unload, but is not yet implemented" << std::endl;
  this->assetsToUnload.push_back(asset);
}

void AssetManager::queueSwap(
  std::vector<Asset*> newAssets,
  std::vector<Asset*> oldAssets
) {
  std::vector<Asset*> unload;
  std::vector<Asset*> load;

  // Determine assets to unload.
  auto itUnload = oldAssets.begin();
  while(itUnload != oldAssets.end()) {
    auto inNewAssets = std::find(newAssets.begin(), newAssets.end(), *itUnload);
    if(inNewAssets == newAssets.end()) unload.push_back(*itUnload);
    ++itUnload;
  }

  // Determine assets to load
  auto itLoad = newAssets.begin();
  while(itLoad != newAssets.end()) {
    auto inOldAssets = std::find(oldAssets.begin(), oldAssets.end(), *itLoad);
    if(inOldAssets == oldAssets.end()) load.push_back(*itLoad);
    ++itLoad;
  }

  this->queueUnload(unload);
  this->queueLoad(load);
}

void AssetManager::syncTick() {
  auto it = this->assetsToLoad.begin();
  while(it != this->assetsToLoad.end()) {
    auto asset = *it;
    if(asset->loaded) {
      it = this->assetsToLoad.erase(it);
      asset->eventLoaded.invoke();
      asset->event2Loaded.invoke();
      continue;
    }

    asset->updateSync();
    asset->updateAsync();//TODO: Make Async

    if(asset->loaded) {
      it = this->assetsToLoad.erase(it);
      asset->eventLoaded.invoke();
      asset->event2Loaded.invoke();
      continue;
    }

    ++it;
  }
  // auto it = this->assetsNotLoaded.begin();
  // auto it2 = this->assetsToUnload.begin();
  // while(it2 != this->assetsToUnload.end()) {
  //   ++it2;
  // }
}

void AssetManager::syncLoad() {
  while(this->assetsToLoad.size() > 0) {
    this->syncTick();
  }
}

AssetManager::~AssetManager() {
  auto it = this->assets.begin();
  while(it != this->assets.end()) {
    delete it->second;
    ++it;
  }
}