#pragma once

#include <assets/asset_loader.h>
#include <assets/asset_storage.h>
#include <assets/builtin/builtin_asset_factory.h>
#include <assets/cache/asset_cache.h>
#include <assets/dependency/asset_dependency_graph.h>
#include <assets/font.h>
#include <assets/io/asset_file_system.h>
#include <assets/music.h>
#include <assets/runtime/asset_async_runtime.h>
#include <assets/runtime/asset_hot_reload_runtime.h>
#include <functional>
#include <memory>
#include <string>
#include <vector>

namespace extra2d {

class ShaderLoader;

class AssetSystem {
public:
  struct Stats {
    size_t textureCount = 0;
    size_t shaderCount = 0;
    size_t fontCount = 0;
    size_t musicCount = 0;
    size_t materialCount = 0;
    size_t meshCount = 0;
  };

  AssetSystem(AssetStorage<Texture> &textures, AssetStorage<Shader> &shaders,
              AssetStorage<Font> &fonts, AssetStorage<Music> &musics,
              AssetStorage<Material> &materials, AssetStorage<Mesh> &meshes,
              std::unique_ptr<AssetLoader<Texture>> &textureLoader,
              std::unique_ptr<AssetLoader<Shader>> &shaderLoader,
              std::unique_ptr<AssetLoader<Font>> &fontLoader,
              std::unique_ptr<AssetLoader<Music>> &musicLoader);

  Handle<Texture> loadTexture(const std::string &path);
  Handle<Texture> loadTextureFromMemory(const std::string &key,
                                        const uint8_t *data, size_t size);
  std::vector<Handle<Texture>>
  loadTextureDir(const std::string &directory, bool recursive);

  Handle<Shader> loadShader(const std::string &path);
  Handle<Shader> loadShader(const std::string &vertPath,
                            const std::string &fragPath);
  Handle<Font> loadFont(const std::string &path);
  Handle<Font> loadFontFromMemory(const std::string &key, const uint8_t *data,
                                  size_t size);
  Handle<Music> loadMusic(const std::string &path);

  void loadTextureAsync(const std::string &path,
                        std::function<void(Handle<Texture>)> callback);
  void loadShaderAsync(const std::string &path,
                       std::function<void(Handle<Shader>)> callback);
  void initAsync(uint32_t threadCount = 0);
  void shutdownAsync();
  void processAsyncCallbacks();

  void registerTextureLoader(std::unique_ptr<AssetLoader<Texture>> loader);
  void registerShaderLoader(std::unique_ptr<AssetLoader<Shader>> loader);
  void registerFontLoader(std::unique_ptr<AssetLoader<Font>> loader);
  void registerMusicLoader(std::unique_ptr<AssetLoader<Music>> loader);

  bool createDefaults();
  void destroyDefaults();
  Handle<Texture> defaultTexture() const;
  Handle<Shader> defaultShader() const;
  Handle<Material> defaultMaterial() const;
  Handle<Mesh> defaultQuad() const;

  void enableHotReload(bool enable);
  void setHotReloadInterval(float interval);
  void checkForChanges();

  void registerDependency(Handle<Material> material, Handle<Texture> texture);
  void registerDependency(Handle<Material> material, Handle<Shader> shader);
  void notifyTextureReloaded(Handle<Texture> texture);
  void notifyShaderReloaded(Handle<Shader> shader);

  void clear();
  Stats stats() const;

private:
  void reloadTexture(const AssetHotReloader::FileWatchInfo &info);
  void reloadShader(const AssetHotReloader::FileWatchInfo &info);

  AssetStorage<Texture> &textures_;
  AssetStorage<Shader> &shaders_;
  AssetStorage<Font> &fonts_;
  AssetStorage<Music> &musics_;
  AssetStorage<Material> &materials_;
  AssetStorage<Mesh> &meshes_;

  std::unique_ptr<AssetLoader<Texture>> &textureLoader_;
  std::unique_ptr<AssetLoader<Shader>> &shaderLoader_;
  std::unique_ptr<AssetLoader<Font>> &fontLoader_;
  std::unique_ptr<AssetLoader<Music>> &musicLoader_;

  AssetCache<Texture> textureCache_;
  AssetCache<Shader> shaderCache_;
  AssetCache<Font> fontCache_;
  AssetCache<Music> musicCache_;
  AssetDependencyGraph dependencyGraph_;
  AssetAsyncRuntime asyncRuntime_;
  AssetHotReloadRuntime hotReloadRuntime_;
  BuiltinAssetFactory builtinFactory_;
  AssetFileSystem fileSystem_;
};

} // namespace extra2d