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

#pragma once
#include "Asset.hpp"

namespace Dawn {
  class AssetManager {
    private:
      /** List of pointers to assets, mapped by their asset key. */
      std::map<std::string, std::shared_ptr<Asset>> assets;
      std::vector<std::shared_ptr<Asset>> assetsToLoad;
      std::vector<std::shared_ptr<Asset>> assetsToUnload;

    public:
      /**
       * Initializes this asset manager so it can begin accepting assets.
       */
      void init();

      /**
       * Updates the asset manager.
       */
      void update();

      /**
       * Queue a loading of a list of assets. Does not actually begin loading.
       * 
       * @param assets Assets to load.
       */
      void queueLoad(const std::vector<std::shared_ptr<Asset>> assets);

      /**
       * Queue a loading of a single asset. Does not actually begin loading.
       * 
       * @param asset Asset to load.
       */
      void queueLoad(const std::shared_ptr<Asset> &asset);

      /**
       * Takes a list of lists to queue to unload. Does not immediately unload.
       * 
       * @param assets Assets to unload.
       */
      void queueUnload(const std::vector<std::shared_ptr<Asset>> &assets);

      /**
       * Takes a single asset to queue to unload. Does not immediately unload.
       * 
       * @param assets Assets to unload.
       */
      void queueUnload(const std::shared_ptr<Asset> &assets);

      /**
       * Queues load and unload based on the difference between two sets of
       * assets. This is mostly used to perform a scene change.
       * 
       * @param newAssets New list of assets to maintain.
       * @param oldAssets Old list of assets to no longer maintain.
       */
      void queueSwap(
        const std::vector<std::shared_ptr<Asset>> &newAssets,
        const std::vector<std::shared_ptr<Asset>> &oldAssets
      );

      /**
       * Ticks the asset manager, synchronously.
       */
      void syncTick();

      /**
       * Loads everything that isn't loaded, blocks the current thread until 
       * that has finished.
       */
      void syncLoad();

      /**
       * Creates and queue an asset to load.
       * 
       * @param name Name of the asset to load.
       * @return The asset element to be loaded.
       */
      template<class T>
      std::shared_ptr<T> get(std::string name) {
        assertTrue(
          name.size() > 0, "AssetManager::get: name must be greater than 0"
        );
        
        auto existing = this->assets.find(name);
        if(existing != this->assets.end()) {
          return dynamic_pointer_cast<T>(existing->second);
        }
        auto asset = std::make_shared<T>(name);
        this->assets[name] = asset;
        return asset;
      }

      /**
       * Both gets an asset, and puts it into the load queue.
       * 
       * @param name Name of the asset to load.
       * @return The asset element to be loaded.
       */
      template<class T>
      std::shared_ptr<T> getAndLoad(std::string name) {
        auto asset = this->get<T>(name);
        this->queueLoad(asset);
        return asset;
      }

      template<class T>
      void unload(std::shared_ptr<T> asset) {
        assertUnreachable("AssetManager::unload: NOT IMPLEMENTED");
      }

      void unload(std::string name) {
        assertUnreachable("AssetManager::unload: NOT IMPLEMENTED");
      }

      /**
       * Dispose the asset manager, and all attached assets.
       */
      ~AssetManager();
  };
}