#include <iostream>
#include "entt/entt.hpp"
// Type your code here, or load an example.

using entt::literals::operator""_hs;

enum class EDeviceType
{
    SERVER = 0,
    PROJECTOR,
    SWITCH,
    UNKNOWN
};

class TroubleMaker
{
public:
    explicit TroubleMaker(uint32_t inValue)
        : mValue(inValue) {}
    //TroubleMaker(const TroubleMaker&) = delete;

private:
    uint32_t mValue;
};

class Device
{
public:
    explicit Device(std::string inName, EDeviceType inType)
        : mName(std::move(inName))
        , mType(inType)
        , mTrouble(911) { }
    Device(const Device&) = delete;
    Device(Device&&) = default;

    std::string getName() const { return mName; }

private:
    std::string mName;
    EDeviceType mType;
    TroubleMaker mTrouble;
};

class Server
    : public Device
{
public:
    explicit Server(std::string inName)
        : Device(inName, EDeviceType::SERVER) { }
    Server(const Server&) = delete;
    Server(Server&&) = default;

    ~Server()
    {
        std::cout << "Server class has been destroyed. :O" << std::endl;
    }

    void setModelName(const std::string& inModelName) { mModelName = inModelName; }

private:
    std::string mModelName;
};


int main(void)
{
    entt::meta<Server>()
            .type("Server"_hs)
            .base<Device>()
            .ctor<std::string>();

    auto* lTemp = new Server("TestServer");

    entt::meta_any lIt;
    {
        std::cout << "DBG0.0" << std::endl;
        auto lServerType = entt::resolve("Server"_hs);
        std::cout << "DBG0.1" << std::endl;
        auto lInstance = lServerType.construct(std::string("TEST"));
        std::cout << "DBG1" << std::endl;
        lIt = std::move(lInstance);
        std::cout << "DBG2" << std::endl;
    }
    std::cout << "DBG3" << std::endl;
    if (lIt.data()) {
        std::cout << "Instance name: " << static_cast<Device*>(lIt.data())->getName() << std::endl;
    }
    else {
        std::cout << "Instance not valid ???" << std::endl;
    }
    
    return 0;
}