FactoryCraft-Server/FactoryCraft/TypeRegistry.h

#pragma once

#include <Array.h>
#include <cstdlib>
#include <JSON.h>
#include <Trie.h>
#include <typeinfo>

class TypeRegistry;
class GeneratorRuleFactory;
class GeneratorRule;
class DimensionGenerator;
class JExpressionMemory;
class DimensionFactory;
class Dimension;

/*
 * Used to convert an object of type T to a JSONValue and vice versa.
 * Can be registered at the TypeRegistry to be used by the JSON system
 */
template<typename T> class TypeFactory : public Framework::ReferenceCounter
{
public:
    TypeFactory()
        : ReferenceCounter(){};
    virtual T* fromJson(Framework::JSON::JSONValue* zJson) const = 0;
    virtual Framework::JSON::JSONValue* toJson(T* zObject) const = 0;
    virtual Framework::JSON::Validator::JSONValidator* getValidator() const = 0;
};

/*
 * Used to convert an object of type S witch inherits from type T to a JSONValue
 * and vice versa. Can be registered at the TypeRegistry to be used by the JSON
 */
template<typename T,
    typename S,
    typename = std::enable_if<std::is_base_of<T, S>::value>>
class SubTypeFactory : public Framework::ReferenceCounter
{
public:
    SubTypeFactory()
        : ReferenceCounter(){};

    virtual S* fromJson(Framework::JSON::JSONObject* zJson) const = 0;
    virtual Framework::JSON::JSONObject* toJson(S* zObject) const = 0;
    virtual Framework::JSON::Validator::JSONValidator* getValidator(
        Framework::JSON::Validator::ObjectValidationBuilder<
            Framework::JSON::Validator::JSONValidator>* builder) const
        = 0;
    virtual Framework::Text getTypeToken() const = 0;
};

template<typename T> class SubTypeFactoryRef
    : public Framework::ReferenceCounter
{
private:
    Framework::Text typetoken;
    std::function<T*(Framework::JSON::JSONObject*)> fromJsonFunc;
    std::function<Framework::JSON::JSONObject*(T*)> toJsonFunc;
    std::function<Framework::JSON::Validator::JSONValidator*(
        Framework::JSON::Validator::ObjectValidationBuilder<
            Framework::JSON::Validator::JSONValidator>*)>
        getValidatorFunc;
    Framework::ReferenceCounter* factory;

public:
    SubTypeFactoryRef(Framework::Text typetoken,
        std::function<T*(Framework::JSON::JSONObject*)> fromJsonFunc,
        std::function<Framework::JSON::JSONObject*(T*)> toJsonFunc,
        std::function<Framework::JSON::Validator::JSONValidator*(
            Framework::JSON::Validator::ObjectValidationBuilder<
                Framework::JSON::Validator::JSONValidator>*)> getValidatorFunc,
        Framework::ReferenceCounter* factory)
        : ReferenceCounter(),
          typetoken(typetoken),
          fromJsonFunc(fromJsonFunc),
          toJsonFunc(toJsonFunc),
          getValidatorFunc(getValidatorFunc),
          factory(factory)
    {}

    ~SubTypeFactoryRef()
    {
        factory->release();
    }

    T* fromJson(Framework::JSON::JSONObject* zJson) const
    {
        return fromJsonFunc(zJson);
    }

    Framework::JSON::JSONObject* toJSON(T* zObject) const
    {
        return toJsonFunc(zObject);
    }

    Framework::JSON::Validator::JSONValidator* getValidator(
        Framework::JSON::Validator::ObjectValidationBuilder<
            Framework::JSON::Validator::JSONValidator>* builder) const
    {
        return getValidatorFunc(builder);
    }

    const Framework::Text& getTypetoken() const
    {
        return typetoken;
    }
};

template<typename T> class PolymorphTypeFactory : public TypeFactory<T>
{
private:
    Framework::RCArray<SubTypeFactoryRef<T>> factories;
    Framework::RCArray<Framework::Text> typeNames;
    static thread_local bool insideGetValidator;

public:
    PolymorphTypeFactory()
        : TypeFactory<T>()
    {}

    T* fromJson(Framework::JSON::JSONValue* zJson) const override
    {
        for (SubTypeFactoryRef<T>* factory : factories)
        {
            if (zJson->asObject()
                    ->zValue("type")
                    ->asString()
                    ->getString()
                    .istGleich(factory->getTypetoken()))
            {
                return factory->fromJson(zJson->asObject());
            }
        }
        return 0;
    }

    Framework::JSON::JSONValue* toJson(T* zObject) const override
    {
        auto name = typeNames.begin();
        for (SubTypeFactoryRef<T>* factory : factories)
        {
            if (name->istGleich(typeid(*zObject).name()))
            {
                Framework::JSON::JSONObject* result = factory->toJSON(zObject);
                if (result)
                {
                    result->addValue("type",
                        new Framework::JSON::JSONString(
                            factory->getTypetoken()));
                    return result;
                }
            }
            name++;
        }
        return 0;
    }

    Framework::JSON::Validator::JSONValidator* getValidator() const override
    {
        Framework::JSON::Validator::JSONValidator* result = 0;
        if (!insideGetValidator)
        {
            insideGetValidator = true;
            auto validator
                = Framework::JSON::Validator::JSONValidator::buildForOneOf()
                      ->typeSpecifiedByAttribute("type");
            for (SubTypeFactoryRef<T>* factory : factories)
            {
                validator = validator->addAcceptedType(factory->getValidator(
                    Framework::JSON::Validator::JSONValidator::buildForObject()
                        ->withRequiredString("type")
                        ->withExactMatch(factory->getTypetoken())
                        ->finishString()
                        ->setObjectReferenceId(
                            ((Framework::Text("_type_") += typeid(T).name())
                                += "_")
                            += factory->getTypetoken())));
            }
            result = validator->finishOneOf();
            insideGetValidator = false;
        }
        else
        {
            auto validator
                = Framework::JSON::Validator::JSONValidator::buildForOneOf()
                      ->typeSpecifiedByAttribute("type");
            for (SubTypeFactoryRef<T>* factory : factories)
            {
                validator = validator->addAcceptedType(Framework::JSON::
                        Validator::JSONValidator::buildForObjectReference(
                            ((Framework::Text("_type_") += typeid(T).name())
                                += "_")
                            += factory->getTypetoken()));
            }
            result = validator->finishOneOf();
        }
        return result;
    }

    template<typename S,
        typename = std::enable_if<std::is_base_of<T, S>::value>>
    void addFactory(SubTypeFactory<T, S>* factory)
    {
        factories.add(new SubTypeFactoryRef<T>(
            factory->getTypeToken(),
            [factory](Framework::JSON::JSONObject* zJson) {
                S* value = factory->fromJson(zJson);
                if (value)
                {
                    return dynamic_cast<T*>(factory->fromJson(zJson));
                }
                return (T*)0;
            },
            [factory](T* zObject) {
                S* value = dynamic_cast<S*>(zObject);
                if (value)
                {
                    return factory->toJson(value);
                }
                return (Framework::JSON::JSONObject*)0;
            },
            [factory](Framework::JSON::Validator::ObjectValidationBuilder<
                Framework::JSON::Validator::JSONValidator>* builder) {
                return factory->getValidator(builder);
            },
            dynamic_cast<Framework::ReferenceCounter*>(factory)));
        typeNames.add(new Framework::Text(typeid(S).name()));
    }
};

template<typename T>
thread_local bool PolymorphTypeFactory<T>::insideGetValidator = false;

class TypeFatoryRef : public Framework::ReferenceCounter
{
private:
    std::function<void*(Framework::JSON::JSONValue*)> fromJsonFunc;
    std::function<Framework::JSON::JSONValue*(void*)> toJsonFunc;
    std::function<Framework::JSON::Validator::JSONValidator*()>
        getValidatorFunc;
    Framework::ReferenceCounter* factory;

public:
    TypeFatoryRef(
        std::function<void*(Framework::JSON::JSONValue*)> fromJsonFunc,
        std::function<Framework::JSON::JSONValue*(void*)> toJsonFunc,
        std::function<Framework::JSON::Validator::JSONValidator*()>
            getValidatorFunc,
        Framework::ReferenceCounter* factory)
        : ReferenceCounter(),
          fromJsonFunc(fromJsonFunc),
          toJsonFunc(toJsonFunc),
          getValidatorFunc(getValidatorFunc),
          factory(factory)
    {}

    ~TypeFatoryRef()
    {
        factory->release();
    }

    void* fromJson(Framework::JSON::JSONValue* zJson) const
    {
        return fromJsonFunc(zJson);
    }

    Framework::JSON::JSONValue* toJSON(void* zObject) const
    {
        return toJsonFunc(zObject);
    }

    Framework::JSON::Validator::JSONValidator* getValidator() const
    {
        return getValidatorFunc();
    }

    template<typename T> TypeFactory<T>* zFactory() const
    {
        return (TypeFactory<T>*)(factory);
    }
};

class GeneratorRuleFactory : public virtual Framework::ReferenceCounter
{
public:
    GeneratorRuleFactory();
    virtual GeneratorRule* createRule(
        Framework::JSON::JSONValue* zConfig, JExpressionMemory* zMemory)
        = 0;
    virtual Framework::JSON::Validator::JSONValidator* getValidator() = 0;
};

class DimensionFactory : public virtual Framework::ReferenceCounter
{
private:
    int dimensionId;

public:
    DimensionFactory(int dimensionId);
    virtual ~DimensionFactory() = default;

    virtual Dimension* createDimension() = 0;
    int getDimensionId() const;
};

class DimensionGeneratorFactory : public virtual Framework::ReferenceCounter
{
private:
    Framework::Text name;
    int dimensionId;

public:
    DimensionGeneratorFactory(Framework::Text name, int dimensionId);

    virtual DimensionGenerator* createDimensionGenerator(
        int worldSeed, Framework::JSON::JSONValue* config)
        = 0;
    virtual Framework::JSON::Validator::JSONValidator* getConfigValidator() = 0;
    virtual Framework::JSON::JSONValue* getDefaultConfig() = 0;

    Framework::Text getName() const;
    int getDimensionId() const;
};

class TypeRegistry : public Framework::ReferenceCounter
{
private:
    Framework::RCArray<GeneratorRuleFactory> generatorRules;
    Framework::RCArray<DimensionGeneratorFactory> dimensionGenerators;
    Framework::RCArray<DimensionFactory> dimensionFactories;
    Framework::RCTrie<TypeFatoryRef> parsableTypes;
    Framework::RCArray<Framework::Text> parsableTypeNames;

public:
    TypeRegistry();

    void registerGeneratorRuleFactory(GeneratorRuleFactory* factory);
    GeneratorRule* createGeneratorRule(
        Framework::JSON::JSONValue* zConfig, JExpressionMemory* zMemory);
    Framework::JSON::Validator::JSONValidator* getGeneratorRuleValidator();

    void registerDimensionGeneratorFactory(DimensionGeneratorFactory* factory);
    DimensionGenerator* createDimensionGenerator(
        Framework::JSON::JSONValue* zConfig, int worldSeed);
    Framework::JSON::Validator::JSONValidator* getDimensionGeneratorValidator();
    const Framework::RCArray<DimensionGeneratorFactory>&
    getDimensionGeneratorFactories() const;

    void registerDimension(DimensionFactory* factory);
    Dimension* createDimension(int id);

    template<typename T,
        typename S,
        typename = std::enable_if<std::is_base_of<T, S>::value>>
    void registerSubType(SubTypeFactory<T, S>* factory)
    {
        Framework::Text typeId = typeid(T).name();
        TypeFatoryRef* typeFactoryRef
            = parsableTypes.z(typeId, typeId.getLength());
        if (!typeFactoryRef)
        {
            PolymorphTypeFactory<T>* polymorphFactory
                = new PolymorphTypeFactory<T>();
            registerType(polymorphFactory);
            typeFactoryRef = parsableTypes.z(typeId, typeId.getLength());
            parsableTypeNames.add(new Framework::Text(typeId));
        }
        PolymorphTypeFactory<T>* polymorphFactory
            = dynamic_cast<PolymorphTypeFactory<T>*>(
                typeFactoryRef->zFactory<T>());
        if (!polymorphFactory)
        {
            throw Framework::Text("Type not registered as Polymorphic type: ")
                + typeId;
        }
        polymorphFactory->template addFactory<S>(factory);
    }

    template<typename T> void registerType(TypeFactory<T>* factory)
    {
        Framework::Text typeId = typeid(T).name();
        TypeFatoryRef* typeFactoryRef
            = parsableTypes.z(typeId, typeId.getLength());
        if (typeFactoryRef)
        {
            throw Framework::Text("Type already registered: ") + typeId;
        }
        typeFactoryRef = new TypeFatoryRef(
            [factory](Framework::JSON::JSONValue* zJson) {
                return factory->fromJson(zJson);
            },
            [factory](void* zObject) { return factory->toJson((T*)zObject); },
            [factory]() { return factory->getValidator(); },
            factory);
        parsableTypes.set(typeId, typeId.getLength(), typeFactoryRef);
        parsableTypeNames.add(new Framework::Text(typeId));
    }

    template<typename T> T* fromJson(Framework::JSON::JSONValue* zJson) const
    {
        Framework::Text typeId = typeid(T).name();
        TypeFatoryRef* typeFactoryRef
            = parsableTypes.z(typeId, typeId.getLength());
        if (!typeFactoryRef)
        {
            throw Framework::Text("Type not registered: ") + typeId;
        }
        return (T*)(typeFactoryRef->fromJson(zJson));
    }

    template<typename T> Framework::JSON::JSONValue* toJson(T* zObject) const
    {
        Framework::Text typeId = typeid(T).name();
        TypeFatoryRef* typeFactoryRef
            = parsableTypes.z(typeId, typeId.getLength());
        if (!typeFactoryRef)
        {
            throw Framework::Text("Type not registered: ") + typeId;
        }
        return typeFactoryRef->toJSON(zObject);
    }

    template<typename T>
    Framework::JSON::Validator::JSONValidator* getValidator() const
    {
        Framework::Text typeId = typeid(T).name();
        TypeFatoryRef* typeFactoryRef
            = parsableTypes.z(typeId, typeId.getLength());
        if (!typeFactoryRef)
        {
            throw Framework::Text("Type not registered: ") + typeId;
        }
        return typeFactoryRef->getValidator();
    }

    template<typename T> Framework::JSON::JSONValue* getValidParts(
        Framework::JSON::JSONValue* zJson) const
    {
        Framework::RCArray<Framework::JSON::Validator::JSONValidationResult>
            invalidParts;
        Framework::JSON::Validator::JSONValidator* validator
            = getValidator<T>();
        Framework::JSON::JSONValue* result
            = validator->getValidParts(zJson, &invalidParts);
        for (Framework::JSON::Validator::JSONValidationResult* invalidPart :
            invalidParts)
        {
            invalidPart->printInvalidInfo();
        }
        return result;
    }

    void writeSyntaxInfo(Framework::Text folderPath) const;
};