#pragma once

#include <Reader.h>
#include <ReferenceCounter.h>
#include <Vec3.h>
#include <Writer.h>

#include "DropConfig.h"
#include "ModelInfo.h"

class Entity;
class Game;

class EntityTypeEnum
{
public:
    static const int PLAYER = 0;
    static const int ITEM = 1;
};

class EntityType : public virtual Framework::ReferenceCounter
{
private:
    Framework::Text name;
    int id;
    ModelInfo* model;
    Framework::RCArray<DropConfig> dropConfigs;

protected:
    EntityType();
    ~EntityType();

    virtual void loadSuperEntity(
        Entity* zEntity, Framework::StreamReader* zReader) const;
    virtual void saveSuperEntity(
        Entity* zEntity, Framework::StreamWriter* zWriter) const;
    virtual void createSuperEntity(Entity* zEntity) const;

public:
    virtual bool initialize(Game* zGame);
    void addDropConfig(DropConfig* config);
    void setName(Framework::Text name);
    void setModel(ModelInfo* model);
    const Framework::RCArray<DropConfig>& getDropConfigs() const;
    virtual Entity* loadEntity(Framework::StreamReader* zReader) const;
    virtual void saveEntity(
        Entity* zEntity, Framework::StreamWriter* zWriter) const;
    virtual Entity* createEntityAt(
        Framework::Vec3<float> position, int dimensionId) const;
    virtual Entity* createEntity(
        Framework::Vec3<float> position, int dimensionId, int entityId) const
        = 0;

    int getId() const;
    ModelInfo* zModel() const;
    void setTypeId(int id);
    Framework::Text getName() const;
};

template<typename S> class EntityTypeFactoryBase
    : public SubTypeFactory<EntityType, S>
{
public:
    EntityTypeFactoryBase()
        : SubTypeFactory<EntityType, S>()
    {}

    virtual S* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        S* result = createValue(zJson);
        EntityType* zType = dynamic_cast<EntityType*>(result);
        zType->setModel(Game::INSTANCE->zTypeRegistry()->fromJson<ModelInfo>(
            zJson->zValue("model")->asObject()));
        zType->setName(zJson->zValue("typeName")->asString()->getString());
        for (Framework::JSON::JSONValue* value :
            *zJson->zValue("drops")->asArray())
        {
            zType->addDropConfig(
                Game::INSTANCE->zTypeRegistry()->fromJson<DropConfig>(
                    value->asObject()));
        }
        return result;
    }

    virtual Framework::JSON::JSONObject* toJsonObject(S* zObject) const override
    {
        Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
        EntityType* zType = dynamic_cast<EntityType*>(zObject);
        result->addValue("model",
            Game::INSTANCE->zTypeRegistry()->toJson<ModelInfo>(
                zType->zModel()));
        result->addValue(
            "typeName", new Framework::JSON::JSONString(zType->getName()));
        Framework::JSON::JSONArray* drops = new Framework::JSON::JSONArray();
        for (DropConfig* drop : zType->getDropConfigs())
        {
            drops->addValue(
                Game::INSTANCE->zTypeRegistry()->toJson<DropConfig>(drop));
        }
        result->addValue("drops", drops);
        addToJson(result, zObject);
        return result;
    }

    virtual JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return builder
            ->withRequiredAttribute("model",
                Game::INSTANCE->zTypeRegistry()->getValidator<ModelInfo>())
            ->withRequiredString("typeName")
            ->finishString()
            ->withRequiredAttribute("drops",
                Framework::Validator::DataValidator::buildForArray()
                    ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                            ->getValidator<DropConfig>())
                    ->finishArray());
    }

protected:
    virtual S* createValue(Framework::JSON::JSONObject* zJson) const = 0;
    virtual void addToJson(Framework::JSON::JSONObject* zJson, S* zObject) const
        = 0;
};