#ifndef RESOURCEPACK_H
#define RESOURCEPACK_H

#include <string>
#include <glm/vec3.hpp>

#include <cereal/archives/json.hpp>
//#include <cereal/types/array.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/types/vector.hpp>

#include "glm_serialize_functions.h"

class Texture;
class PBRMaterial;
class Mesh;

/**
 * @brief The ResourceInterface struct holds a resource, it handles its loading and its destruction
 */
struct ResourceInterface
{
    std::string m_name;

    template<class Archive>
    void serialize(Archive & archive){
        archive(CEREAL_NVP(m_name));
    }

    virtual void loadResource(float & progress) = 0;

    virtual void destroy() = 0;

    virtual void gui() = 0;
};

/**
 * @brief The ResourcePack class is just a container of LoadTask, it only exists for serialization purposes
 */
struct ResourcePack
{
    std::string m_name;
    std::vector<std::shared_ptr<ResourceInterface>> m_resources;

    ResourcePack() {}

    void gui();

    template<class Archive>
    void serialize(Archive & archive){
        archive(cereal::make_nvp("ResourcePack",m_name),CEREAL_NVP(m_resources));
    }
};

/*
 * Some LoadTask implementations
 */

class TextureResource : public ResourceInterface
{
    std::string m_path;
    int m_bitsPerPixel;
    bool m_isVerticallyReversed;
    bool m_needsMipMaps;

    Texture* m_texture;

public:
    TextureResource();
    virtual ~TextureResource();

    template <class Archive>
    void serialize(Archive & archive)
    {
        archive(CEREAL_NVP(m_name),
                CEREAL_NVP(m_path),
                CEREAL_NVP(m_bitsPerPixel),
                CEREAL_NVP(m_isVerticallyReversed),
                CEREAL_NVP(m_needsMipMaps));
    }

    void loadResource(float & progress);

    void destroy();
    void gui();
};

class MaterialResource : public ResourceInterface
{
    glm::vec3 m_albedo;
    float m_metallic;
    float m_roughness;
    glm::vec3 m_emission;
    float m_opacity;
    std::string m_albedoTexture;
    std::string m_metallicTexture;
    std::string m_roughnessTexture;
    std::string m_emissionTexture;
    std::string m_normalTexture;
    std::string m_alphaMaskTexture;

    PBRMaterial* m_material;

public:
    MaterialResource();
    virtual ~MaterialResource();

    template <class Archive>
    void serialize(Archive & archive)
    {
        archive(CEREAL_NVP(m_name),
                CEREAL_NVP(m_albedo),
                CEREAL_NVP(m_metallic),
                CEREAL_NVP(m_roughness),
                CEREAL_NVP(m_emission),
                CEREAL_NVP(m_opacity),
                CEREAL_NVP(m_albedoTexture),
                CEREAL_NVP(m_metallicTexture),
                CEREAL_NVP(m_roughnessTexture),
                CEREAL_NVP(m_emissionTexture),
                CEREAL_NVP(m_normalTexture),
                CEREAL_NVP(m_alphaMaskTexture)
                );
    }

    void loadResource(float & progress);

    void destroy();

    void gui();
};

class MeshResource : public ResourceInterface
{
    //add metadata for mesh

    Mesh* m_mesh;
public:
    MeshResource();
    virtual ~MeshResource();


    // differentiate load and save ?
    template <class Archive>
    void serialize(Archive & archive)
    {

    }

    void loadResource(float & progress);

    void destroy();

    void gui();
};

CEREAL_REGISTER_TYPE(TextureResource)
CEREAL_REGISTER_TYPE(MaterialResource)
CEREAL_REGISTER_TYPE(MeshResource)

CEREAL_REGISTER_POLYMORPHIC_RELATION(ResourceInterface,TextureResource)
CEREAL_REGISTER_POLYMORPHIC_RELATION(ResourceInterface,MaterialResource)
CEREAL_REGISTER_POLYMORPHIC_RELATION(ResourceInterface,MeshResource)

#endif // RESOURCEPACK_H