src/ecs_serializer/ecs_serializer.cpp

/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <PropertyTools/property_data.h>
#include <algorithm>
#include <charconv>
#include <cinttypes>
#include <functional>

#include <3d/ecs/components/render_handle_component.h>
#include <base/util/base64_decode.h>
#include <base/util/base64_encode.h>
#include <base/util/uid_util.h>
#include <core/ecs/intf_component_manager.h>
#include <core/ecs/intf_entity_manager.h>
#include <core/image/intf_image_loader_manager.h>
#include <core/intf_engine.h>
#include <core/property/intf_property_handle.h>
#include <core/property/property_types.h>
#include <ecs_serializer/ecs_property_util.h>
#include <render/device/intf_gpu_resource_manager.h>
#include <render/device/intf_shader_manager.h>
#include <render/intf_render_context.h>
#include <render/util/intf_render_util.h>
#include <util/json_util.h>
#include <util/path_util.h>

#include "ecs_serializer/intf_ecs_serializer.h"

using namespace ;
using namespace CORE_NS;
using namespace RENDER_NS;
using namespace CORE3D_NS;
using namespace UTIL_NS;

ECS_SERIALIZER_BEGIN_NAMESPACE()

class EcsSerializer : public IEcsSerializer {
public:
    explicit EcsSerializer(RENDER_NS::IRenderContext& renderContext);

    // From IEcsSerializer
    void SetListener(IListener* listener) override;

    void SetDefaultSerializers() override;
    void SetSerializer(const CORE_NS::PropertyTypeDecl& type, IPropertySerializer& serializer) override;

    bool WriteEntityCollection(const IEntityCollection& ec, CORE_NS::json::standalone_value& jsonOut) const override;
    bool WriteComponents(
        const IEntityCollection& ec, CORE_NS::Entity entity, CORE_NS::json::standalone_value& jsonOut) const override;
    bool WriteComponent(const IEntityCollection& ec, CORE_NS::Entity entity, const CORE_NS::IComponentManager& cm,
        CORE_NS::IComponentManager::ComponentId id, CORE_NS::json::standalone_value& jsonOut) const override;
    bool WriteProperty(const IEntityCollection& ec, const CORE_NS::Property& property, uintptr_t offset,
        CORE_NS::json::standalone_value& jsonOut) const override;

    bool GatherExternalCollections(const CORE_NS::json::value& jsonIn, ::string_view contextUri,
        ::vector<ExternalCollection>& externalCollectionsOut) const override;

    IoUtil::SerializationResult ReadEntityCollection(
        IEntityCollection& ec, const CORE_NS::json::value& jsonIn, ::string_view contextUri) const override;
    bool ReadComponents(IEntityCollection& ec, const CORE_NS::json::value& jsonIn) const override;
    bool ReadComponent(IEntityCollection& ec, const CORE_NS::json::value& jsonIn, CORE_NS::Entity entity,
        CORE_NS::IComponentManager& component) const override;
    bool ReadProperty(IEntityCollection& ec, const CORE_NS::json::value& jsonIn, const CORE_NS::Property& property,
        uintptr_t offset) const override;

    RENDER_NS::RenderHandleReference LoadImageResource(::string_view uri) const override;

protected:
    void Destroy() override;

private:
    using PropertyToJsonFunc = std::function<bool(
        const IEntityCollection& ec, const CORE_NS::Property&, uintptr_t, CORE_NS::json::standalone_value&)>;
    using PropertyFromJsonFunc = std::function<bool(
        const IEntityCollection& ec, const CORE_NS::json::value&, const CORE_NS::Property&, uintptr_t)>;
    IPropertySerializer& Add(PropertyToJsonFunc toJson, PropertyFromJsonFunc fromJson);

    // A little wrapper class to create a serializer with functions for writing and readig a value.
    class SimpleJsonSerializer : public IPropertySerializer {
    public:
        bool ToJson(const IEntityCollection& ec, const CORE_NS::Property& property, uintptr_t offset,
            CORE_NS::json::standalone_value& jsonOut) const override;
        bool FromJson(const IEntityCollection& ec, const CORE_NS::json::value& jsonIn,
            const CORE_NS::Property& property, uintptr_t offset) const override;

        SimpleJsonSerializer(PropertyToJsonFunc toJson, PropertyFromJsonFunc fromJson);
        virtual ~SimpleJsonSerializer() = default;

    private:
        const PropertyToJsonFunc PropertyToJson;
        const PropertyFromJsonFunc PropertyFromJson;
    };
    ::vector<::unique_ptr<SimpleJsonSerializer>> ownedSerializers_;

    RENDER_NS::IRenderContext& renderContext_;

    // Mapping from each property type to a apecific serializer.
    using SerializerMap = ::unordered_map<CORE_NS::PropertyTypeDecl, IPropertySerializer*>;
    SerializerMap typetoSerializerMap_;

    IListener* listener_ {};
};

namespace {
template<typename Type>
Type& GetPropertyValue(uintptr_t ptr)
{
    return *reinterpret_cast<Type*>(ptr);
}
} // namespace

// EcsSerializer::SimpleJsonSerializer
bool EcsSerializer::SimpleJsonSerializer::ToJson(
    const IEntityCollection& ec, const Property& property, uintptr_t offset, json::standalone_value& jsonOut) const
{
    return PropertyToJson(ec, property, offset, jsonOut);
}

bool EcsSerializer::SimpleJsonSerializer::FromJson(
    const IEntityCollection& ec, const json::value& jsonIn, const Property& property, uintptr_t offset) const
{
    return PropertyFromJson(ec, jsonIn, property, offset);
}

EcsSerializer::SimpleJsonSerializer::SimpleJsonSerializer(PropertyToJsonFunc toJson, PropertyFromJsonFunc fromJson)
    : PropertyToJson(toJson), PropertyFromJson(fromJson)
{}

// EcsSerializer
EcsSerializer::EcsSerializer(RENDER_NS::IRenderContext& renderContext) : renderContext_(renderContext) {}

EcsSerializer::IPropertySerializer& EcsSerializer::Add(PropertyToJsonFunc toJson, PropertyFromJsonFunc fromJson)
{
    auto serializer = new SimpleJsonSerializer(toJson, fromJson);
    auto ptr = unique_ptr<SimpleJsonSerializer> { serializer };
    ownedSerializers_.emplace_back(move(ptr));
    return *ownedSerializers_.back();
}

namespace {
template<class Type>
bool PropertyToJson(
    const IEntityCollection& /*ec*/, const Property& /*property*/, uintptr_t offset, json::standalone_value& jsonOut)
{
    jsonOut = ToJson(GetPropertyValue<Type>(offset));
    return true;
}

template<class Type>
bool PropertyFromJson(
    const IEntityCollection& /*ec*/, const json::value& jsonIn, const Property& /*property*/, uintptr_t offset)
{
    auto& value = GetPropertyValue<Type>(offset);
    return FromJson(jsonIn, value);
}

bool RenderHandleReferenceFromJson(const IEcsSerializer& ecsSerializer, IRenderContext& renderContext,
    const IEntityCollection& ec, const json::value& jsonIn, RenderHandleReference& handleRefOut)
{
    CORE_UNUSED(ec);

    if (!jsonIn.is_object()) {
        return false;
    }

    string error;
    RenderHandleDesc desc;

    // Casting to enum directly from numeric value is a bit fishy.
    uint32_t type = 0;
    if (!SafeGetJsonValue(jsonIn, "type", error, type)) {
        return false;
    }
    desc.type = static_cast<RenderHandleType>(type);

    if (!SafeGetJsonValue(jsonIn, "name", error, desc.name)) {
        return false;
    }

    SafeGetJsonValue(jsonIn, "additionalName", error, desc.additionalName);

    auto& renderUtil = renderContext.GetRenderUtil();
    handleRefOut = renderUtil.GetRenderHandle(desc);

    if (!handleRefOut && desc.type == RenderHandleType::GPU_IMAGE && !desc.name.empty()) {
        // Special handling for images: Load the image if it was not already loaded.
        // Note: assuming that the name is the image uri.
        handleRefOut = ecsSerializer.LoadImageResource(desc.name);
    }

    return true;
}

bool RenderHandleReferenceToJson(IRenderContext& renderContext, const IEntityCollection& ec,
    const RenderHandleReference& handleRefIn, json::standalone_value& jsonOut)
{
    CORE_UNUSED(ec);

    auto& renderUtil = renderContext.GetRenderUtil();
    const auto desc = renderUtil.GetRenderHandleDesc(handleRefIn);

    jsonOut = json::standalone_value::object {};
    jsonOut["type"] = static_cast<unsigned int>(desc.type);
    jsonOut["name"] = string(desc.name);
    if (!desc.additionalName.empty()) {
        jsonOut["additionalName"] = string(desc.additionalName);
    }

    return true;
}

bool EntityFromJson(const IEntityCollection& ec, const json::value& jsonIn, Entity& entityOut)
{
    // Figure out to what entity id a piece of json refers to and handle error cases.
    Entity entity {};
    if (jsonIn.is_unsigned_int()) {
        const auto entityReference = static_cast<uint32_t>(jsonIn.unsigned_);
        entity = ec.GetEntity(entityReference);
        if (entity == Entity {}) {
            CORE_LOG_W("Component entity not found for index: %u", entityReference);
            return false;
        }
    } else if (jsonIn.is_string()) {
        string entityReferenceString;
        if (FromJson(jsonIn, entityReferenceString)) {
            entity = ec.GetEntity(entityReferenceString);
        }
        if (entity == Entity {}) {
            CORE_LOG_W("Component entity not found for id: '%s'", entityReferenceString.c_str());
            return false;
        }
    } else if (jsonIn.is_object()) {
        // Empty object means "null ref".
        if (jsonIn.empty()) {
            entityOut = Entity {};
            return true;
        }

        // Figure out the correct collection (Recursive).
        const IEntityCollection* collection { nullptr };
        const auto* collectionJson = jsonIn.find("collection");
        if (collectionJson) {
            if (collectionJson->is_string()) {
                string collectionName;
                if (FromJson(*collectionJson, collectionName)) {
                    if (auto index = ec.GetSubCollectionIndex(collectionName); index >= 0) {
                        collection = ec.GetSubCollection(static_cast<size_t>(index));
                    }
                }
                if (!collection) {
                    CORE_LOG_W("Collection not found: '%s'", collectionName.c_str());
                    return false;
                }

            } else if (collectionJson->is_unsigned_int()) {
                const auto collectionIndex = collectionJson->unsigned_;
                if (collectionIndex < ec.GetSubCollectionCount()) {
                    collection = ec.GetSubCollection(collectionIndex);
                } else {
                    CORE_LOG_W("Collection not found: %" PRIu64, collectionIndex);
                    return false;
                }

            } else {
                CORE_LOG_W("Invalid collection for a component.");
                return false;
            }

            if (collection) {
                const auto* entityJson = jsonIn.find("entity");
                if (entityJson) {
                    return EntityFromJson(*collection, *entityJson, entityOut);
                }
            }
            return false;
        }

    } else {
        CORE_LOG_W("Component entity property must be an index to the entities array, an string id, or an object");
        return false;
    }

    entityOut = entity;
    return true;
}

bool EntityToJson(const IEntityCollection& ec, const Entity& entityIn, json::standalone_value& jsonOut)
{
    // Write entity index/name if part of this collection.
    const auto entityCount = ec.GetEntityCount();
    for (size_t i = 0; i < entityCount; ++i) {
        if (entityIn == ec.GetEntity(i)) {
            auto id = ec.GetId(entityIn);
            if (!id.empty()) {
                jsonOut = string(id);
            } else {
                jsonOut = i;
            }
            return true;
        }
    }

    // Otherwise check sub-collections recursively.
    const auto collectionCount = ec.GetSubCollectionCount();
    size_t collectionId = 0;
    for (size_t i = 0; i < collectionCount; ++i) {
        auto* collection = ec.GetSubCollection(i);
        BASE_ASSERT(collection);
        // NOTE: Skipping over destroyed collections (same needs to be done when writing the actual collections).
        if (collection->IsMarkedDestroyed()) {
            continue;
        }
        json::standalone_value entityJson;
        if (EntityToJson(*collection, entityIn, entityJson)) {
            jsonOut = json::standalone_value::object {};
            jsonOut[string_view { "collection" }] = collectionId;
            jsonOut[string_view { "entity" }] = move(entityJson);
            return true;
        }
        collectionId++;
    }

    return false;
}

bool EntityReferenceToJson(IRenderContext& renderContext, const IEntityCollection& ec, const EntityReference& entityIn,
    json::standalone_value& jsonOut)
{
    if (EntityToJson(ec, entityIn, jsonOut)) {
        return true;
    }

    // Write render handle reference as render handle desc.
    auto* rhm = GetManager<IRenderHandleComponentManager>(ec.GetEcs());
    if (rhm) {
        if (auto handle = rhm->Read(entityIn); handle) {
            json::standalone_value renderHandleJson = json::standalone_value::object {};
            if (RenderHandleReferenceToJson(renderContext, ec, handle->reference, renderHandleJson["renderHandle"])) {
                jsonOut = move(renderHandleJson);
                return true;
            }
        }
    }

    return false;
}

bool EntityReferenceFromJson(const IEcsSerializer& ecsSerializer, IRenderContext& renderContext,
    const IEntityCollection& ec, const json::value& jsonIn, EntityReference& entityOut)
{
    // A generic handler for any uri to a render handle.
    const auto* renderHandleJson = jsonIn.find("renderHandle");
    if (renderHandleJson) {
        // Try to find a named render handle by desc.
        RenderHandleReference renderHandle;
        if (RenderHandleReferenceFromJson(ecsSerializer, renderContext, ec, *renderHandleJson, renderHandle)) {
            auto* rhm = GetManager<IRenderHandleComponentManager>(ec.GetEcs());
            if (rhm && renderHandle) {
                entityOut = GetOrCreateEntityReference(ec.GetEcs().GetEntityManager(), *rhm, renderHandle);
                return true;
            }
        }
    }

    Entity temp;
    if (!EntityFromJson(ec, jsonIn, temp)) {
        return false;
    }
    entityOut = ec.GetEcs().GetEntityManager().GetReferenceCounted(temp);
    return true;
}
} // namespace

void EcsSerializer::SetDefaultSerializers()
{
    // Basic types (for types that nlohman knows how to serialize).

    SetSerializer(PropertyType::FLOAT_T, Add(PropertyToJson<float>, PropertyFromJson<float>));
    SetSerializer(PropertyType::DOUBLE_T, Add(PropertyToJson<double>, PropertyFromJson<double>));

    SetSerializer(PropertyType::UINT8_T, Add(PropertyToJson<uint8_t>, PropertyFromJson<uint8_t>));
    SetSerializer(PropertyType::UINT16_T, Add(PropertyToJson<uint16_t>, PropertyFromJson<uint16_t>));
    SetSerializer(PropertyType::UINT32_T, Add(PropertyToJson<uint32_t>, PropertyFromJson<uint32_t>));
    SetSerializer(PropertyType::UINT64_T, Add(PropertyToJson<uint64_t>, PropertyFromJson<uint64_t>));

    SetSerializer(PropertyType::INT8_T, Add(PropertyToJson<int8_t>, PropertyFromJson<int8_t>));
    SetSerializer(PropertyType::INT16_T, Add(PropertyToJson<int16_t>, PropertyFromJson<int16_t>));
    SetSerializer(PropertyType::INT32_T, Add(PropertyToJson<int32_t>, PropertyFromJson<int32_t>));
    SetSerializer(PropertyType::INT64_T, Add(PropertyToJson<int64_t>, PropertyFromJson<int64_t>));

    SetSerializer(PropertyType::VEC2_T, Add(PropertyToJson<Math::Vec2>, PropertyFromJson<Math::Vec2>));
    SetSerializer(PropertyType::VEC3_T, Add(PropertyToJson<Math::Vec3>, PropertyFromJson<Math::Vec3>));
    SetSerializer(PropertyType::VEC4_T, Add(PropertyToJson<Math::Vec4>, PropertyFromJson<Math::Vec4>));

    SetSerializer(PropertyType::UVEC2_T, Add(PropertyToJson<Math::UVec2>, PropertyFromJson<Math::UVec2>));
    SetSerializer(PropertyType::UVEC3_T, Add(PropertyToJson<Math::UVec3>, PropertyFromJson<Math::UVec3>));
    SetSerializer(PropertyType::UVEC4_T, Add(PropertyToJson<Math::UVec4>, PropertyFromJson<Math::UVec4>));

    SetSerializer(PropertyType::BOOL_T, Add(PropertyToJson<bool>, PropertyFromJson<bool>));
    SetSerializer(PropertyType::QUAT_T, Add(PropertyToJson<Math::Quat>, PropertyFromJson<Math::Quat>));
    SetSerializer(PropertyType::UID_T, Add(PropertyToJson<Uid>, PropertyFromJson<Uid>));

    SetSerializer(PropertyType::STRING_T, Add(PropertyToJson<string>, PropertyFromJson<string>));

    SetSerializer(PropertyType::CHAR_ARRAY_T,
        Add(
            [](const IEntityCollection& /*ec*/, const Property& property, uintptr_t offset,
                json::standalone_value& jsonOut) {
                const auto* value = &GetPropertyValue<char>(offset);
                // NOTE: a hacky way to calculate cstring size.
                string_view view(value);
                const size_t size = view.size() < property.size ? view.size() : property.size;
                jsonOut = ToJson(string(value, size));
                return true;
            },
            [](const IEntityCollection& /*ec*/, const json::value& jsonIn, const Property& property, uintptr_t offset) {
                string value;
                if (FromJson(jsonIn, value)) {
                    char* charArray = &GetPropertyValue<char>(offset);
                    charArray[value.copy(charArray, property.size - 1)] = '\0';
                    return true;
                }
                return false;
            }));

    SetSerializer(PropertyType::ENTITY_T,
        Add(
            [](const IEntityCollection& ec, const Property& /*property*/, uintptr_t offset,
                json::standalone_value& jsonOut) {
                return EntityToJson(ec, GetPropertyValue<const Entity>(offset), jsonOut);
            },
            [](const IEntityCollection& ec, const json::value& jsonIn, const Property& /*property*/, uintptr_t offset) {
                return EntityFromJson(ec, jsonIn, GetPropertyValue<Entity>(offset));
            }));

    SetSerializer(PropertyType::ENTITY_REFERENCE_T,
        Add(
            [this](const IEntityCollection& ec, const Property& /*property*/, uintptr_t offset,
                json::standalone_value& jsonOut) {
                return EntityReferenceToJson(
                    renderContext_, ec, GetPropertyValue<const EntityReference>(offset), jsonOut);
            },
            [this](const IEntityCollection& ec, const json::value& jsonIn, const Property& /*property*/,
                uintptr_t offset) {
                return EntityReferenceFromJson(
                    *this, renderContext_, ec, jsonIn, GetPropertyValue<EntityReference>(offset));
            }));

    SetSerializer(PROPERTYTYPE(RenderHandleReference),
        Add(
            [this](const IEntityCollection& ec, const Property& /*property*/, uintptr_t offset,
                json::standalone_value& jsonOut) {
                return RenderHandleReferenceToJson(
                    renderContext_, ec, GetPropertyValue<const RenderHandleReference>(offset), jsonOut);
            },
            [this](const IEntityCollection& ec, const json::value& jsonIn, const Property& /*property*/,
                uintptr_t offset) {
                return RenderHandleReferenceFromJson(
                    *this, renderContext_, ec, jsonIn, GetPropertyValue<RenderHandleReference>(offset));
            }));
}

void EcsSerializer::SetListener(IListener* listener)
{
    listener_ = listener;
}

void EcsSerializer::SetSerializer(const PropertyTypeDecl& type, IPropertySerializer& serializer)
{
    typetoSerializerMap_[type] = &serializer;
}

bool EcsSerializer::WriteEntityCollection(const IEntityCollection& ec, json::standalone_value& jsonOut) const
{
    // NOTE: We make sure collections and entities are written in the output before entity-components to make it
    // possible to parse the file in one go.

    jsonOut = json::standalone_value::object();

    string type = ec.GetType();
    if (type.empty()) {
        type = "entitycollection";
    }
    const IoUtil::CompatibilityInfo info { VERSION_MAJOR, VERSION_MINOR, type };
    if (!IoUtil::WriteCompatibilityInfo(jsonOut, info)) {
        return false;
    }

    if (string rootSrc = ec.GetSrc(); !rootSrc.empty()) {
        jsonOut["src"] = move(rootSrc);
    }

    // Write external collections instanced in this collection.
    const auto collectionCount = ec.GetSubCollectionCount();
    if (collectionCount > 0) {
        json::standalone_value collectionsJson = json::standalone_value::array();
        collectionsJson.array_.reserve(collectionCount);

        for (size_t i = 0; i < collectionCount; ++i) {
            json::standalone_value collectionJson = json::standalone_value::object();
            auto* collection = ec.GetSubCollection(i);

            if (!collection || collection->IsMarkedDestroyed()) {
                // NOTE: Skipping over destroyed collections (same needs to be done when writing entity references).
                continue;
            }

            if (string src = collection->GetSrc(); !src.empty()) {
                collectionJson["src"] = move(src);
            }
            if (string id = collection->GetUri(); !id.empty()) {
                collectionJson["id"] = move(id);
            }

            collectionsJson.array_.emplace_back(move(collectionJson));
        }

        if (!collectionsJson.array_.empty()) {
            jsonOut["collections"] = move(collectionsJson);
        }
    }

    // Write bare entities without components.
    const auto entityCount = ec.GetEntityCount();
    if (entityCount > 0) {
        auto& entitiesJson = (jsonOut["entities"] = json::standalone_value::array());
        entitiesJson.array_.reserve(entityCount);
        for (size_t i = 0; i < entityCount; ++i) {
            json::standalone_value entityJson = json::standalone_value::object();

            // Write id if one is defined.
            auto entity = ec.GetEntity(i);
            const auto& id = ec.GetId(entity);
            if (!id.empty()) {
                entityJson["id"] = string(id);
            }

            entitiesJson.array_.emplace_back(move(entityJson));
        }
    }

    vector<EntityReference> allEntities;
    ec.GetEntitiesRecursive(false, allEntities);
    if (allEntities.size() > 0) {
        auto& entityComponentsJson = (jsonOut["entity-components"] = json::standalone_value::array());
        for (Entity entity : allEntities) {
            json::standalone_value componentJson = json::standalone_value::object();
            if (WriteComponents(ec, entity, componentJson["components"])) {
                json::standalone_value entityRefJson;
                if (EntityToJson(ec, entity, entityRefJson)) {
                    componentJson["entity"] = move(entityRefJson);
                }
                entityComponentsJson.array_.emplace_back(move(componentJson));
            }
        }
    }

    // NOTE: Always returns true even if parts of the writing failed.
    return true;
}

bool EcsSerializer::WriteComponents(const IEntityCollection& ec, Entity entity, json::standalone_value& jsonOut) const
{
    // Write all entity components to json (Sorting by uid to keep the order more stable).
    vector<string> managerUids;
    jsonOut = json::standalone_value::object();
    auto cms = ec.GetEcs().GetComponentManagers();
    for (auto cm : cms) {
        const auto componentId = cm->GetComponentId(entity);
        if (componentId != IComponentManager::INVALID_COMPONENT_ID) {
            auto uidString = to_string(cm->GetUid());
            managerUids.emplace_back(string(uidString));
        }
    }
    std::sort(managerUids.begin(), managerUids.end());

    for (const auto& uidString : managerUids) {
        const auto* cm = ec.GetEcs().GetComponentManager(StringToUid(uidString));
        const auto componentId = cm->GetComponentId(entity);

        json::standalone_value componentJson = json::standalone_value::object();
        if (WriteComponent(ec, entity, *cm, componentId, componentJson)) {
            jsonOut[uidString] = move(componentJson);
        }
    }

    return (!jsonOut.empty());
}

bool EcsSerializer::WriteComponent(const IEntityCollection& ec, Entity entity, const IComponentManager& cm,
    IComponentManager::ComponentId id, json::standalone_value& jsonOut) const
{
    // Write all properties to json.
    json::standalone_value propertiesJson = json::standalone_value::object();
    const auto* props = ec.GetSerializedProperties(entity, cm.GetUid());
    if (props) {
        const auto* propertyHandle = cm.GetData(id);
        if (!propertyHandle) {
            return false;
        }
        for (const auto& propertyPath : *props) {
            const IPropertyHandle* handle = propertyHandle;

            PropertyData propertyData;
            PropertyData::PropertyOffset propertyOffset;

            // Check if this is property container.
            string path, name;
            auto containerHandle = ResolveContainerProperty(*handle, propertyPath, path, name);
            if (containerHandle) {
                propertyOffset = propertyData.RLock(*containerHandle, name);
            } else {
                propertyOffset = propertyData.RLock(*propertyHandle, propertyPath);
            }

            if (propertyOffset) {
                if ((propertyOffset.property->flags & static_cast<uint32_t>(PropertyFlags::NO_SERIALIZE)) != 0) {
                    continue;
                }

                json::standalone_value propertyJson;
                if (WriteProperty(ec, *propertyOffset.property, propertyOffset.offset, propertyJson)) {
                    if (!propertyJson.is_null()) {
                        propertiesJson[propertyPath] = move(propertyJson);
                    }
                }
            }
        }

        // NOTE: optional name to make reading files easier.
        jsonOut["name"] = string(cm.GetName());

        if (!propertiesJson.empty()) {
            jsonOut["properties"] = move(propertiesJson);
        }

        // NOTE: Maybe return false if any property write fails?
        return true;
    }
    return false;
}

bool EcsSerializer::WriteProperty(
    const IEntityCollection& ec, const Property& property, uintptr_t offset, json::standalone_value& jsonOut) const
{
    auto serializer = typetoSerializerMap_.find(property.type);
    if (serializer != typetoSerializerMap_.end()) {
        return serializer->second->ToJson(ec, property, offset, jsonOut);

    } else if (!property.metaData.enumMetaData.empty()) {
        // Enum type property.
        switch (property.size) {
            case sizeof(uint8_t):
                jsonOut = GetPropertyValue<uint8_t>(offset);
                return true;
            case sizeof(uint16_t):
                jsonOut = GetPropertyValue<uint16_t>(offset);
                return true;
            case sizeof(uint32_t):
                jsonOut = GetPropertyValue<uint32_t>(offset);
                return true;
            case sizeof(uint64_t):
                jsonOut = GetPropertyValue<uint64_t>(offset);
                return true;
        }

    } else if (property.metaData.containerMethods) {
        const auto& container = *property.metaData.containerMethods;

        // Container type property.
        if (property.type.isArray) {
            // Special handling for byte arrays. Save as a base64 encoded string.
            if (property.type == PropertyType::UINT8_ARRAY_T) {
                array_view<const uint8_t> bytes { (const uint8_t*)offset, property.size };
                jsonOut = ::Base64Encode(bytes);
                return true;
            }

            // C style array.
            json::standalone_value array = json::standalone_value::array();
            array.array_.reserve(property.count);
            for (size_t i = 0; i < property.count; i++) {
                uintptr_t ptr = offset + i * container.property.size;
                // TODO: return false if any recurseive call fails?
                json::standalone_value elementJson;
                WriteProperty(ec, container.property, ptr, elementJson);
                array.array_.push_back(move(elementJson));
            }
            jsonOut = move(array);
            return true;

        } else {
            // This is a "non trivial container".
            const auto count = container.size(offset);

            // Special handling for byte arrays. Save as a base64 encoded string.
            // NOTE: Only specifically vector so we can assume that the memory usage is linear.
            if (property.type == PROPERTYTYPE(vector<uint8_t>)) {
                if (count == 0) {
                    jsonOut = "";
                } else {
                    auto data = container.get(offset, 0);
                    array_view<const uint8_t> bytes { reinterpret_cast<const uint8_t*>(data), count };
                    jsonOut = ::Base64Encode(bytes);
                }
                return true;
            }

            json::standalone_value array = json::standalone_value::array();
            array.array_.reserve(count);

            for (size_t i = 0; i < count; i++) {
                uintptr_t ptr = container.get(offset, i);
                // TODO: return false if any recurseive call fails?
                json::standalone_value elementJson;
                WriteProperty(ec, container.property, ptr, elementJson);
                array.array_.push_back(move(elementJson));
            }
            jsonOut = move(array);
            return true;
        }

    } else if (!property.metaData.memberProperties.empty()) {
        // Struct type property (ie. has sub properties).
        json::standalone_value object = json::standalone_value::object();
        for (const auto& subProperty : property.metaData.memberProperties) {
            json::standalone_value subPropertyJson;
            if (WriteProperty(ec, subProperty, offset + subProperty.offset, subPropertyJson)) {
                object[subProperty.name] = move(subPropertyJson);
            }
        }
        // TODO: return false if any recurseive call fails?
        jsonOut = move(object);
        return true;

    } else {
        CORE_LOG_V("Ecs serializer not found for '%s'", string(property.type.name).c_str());
    }
    return false;
}

bool EcsSerializer::GatherExternalCollections(
    const json::value& jsonIn, string_view contextUri, vector<ExternalCollection>& externalCollectionsOut) const
{
    const auto* srcJson = jsonIn.find("src");
    string srcUri;
    if (srcJson && FromJson(*srcJson, srcUri)) {
#ifdef VERBOSE_LOGGING
        CORE_LOG_D("External Collection: uri='%s' context='%s'", srcUri.c_str(), string(contextUri).c_str());
#endif
        externalCollectionsOut.emplace_back(ExternalCollection { srcUri, string { contextUri } });
    }

    const auto* collectionsJson = jsonIn.find("collections");
    if (collectionsJson && collectionsJson->is_array()) {
        for (const auto& collectionJson : collectionsJson->array_) {
            if (collectionJson.is_object()) {
                const auto* collectionSrcJson = collectionJson.find("src");
                if (collectionSrcJson && collectionSrcJson->is_string()) {
                    string collectionSrcUri;
                    FromJson(*collectionSrcJson, collectionSrcUri);
                    externalCollectionsOut.emplace_back(ExternalCollection { collectionSrcUri, string { contextUri } });
                }
            }
        }
    }
    return true;
}

IoUtil::SerializationResult EcsSerializer::ReadEntityCollection(
    IEntityCollection& ec, const json::value& jsonIn, string_view contextUri) const
{
    // TODO: Move version check to be separately so it can be done before gathering the dependencies.
    // NOTE: Only comparing the major version.
    const auto minor = IoUtil::CompatibilityRange::IGNORE_VERSION;
    // TODO: Type name was changed to be in line with engine naming. Allow the old type name for a while.
    const IoUtil::CompatibilityRange validVersions[] {
        { VERSION_MAJOR, VERSION_MAJOR, minor, minor, ec.GetType() },
        { VERSION_MAJOR, VERSION_MAJOR, minor, minor, "entity_collection" },
    };

    auto result = IoUtil::CheckCompatibility(jsonIn, validVersions);

    const auto* srcJson = jsonIn.find("src");
    string srcUri;

    const auto* collectionsJson = jsonIn.find("collections");
    if (collectionsJson && collectionsJson->is_array()) {
        for (const auto& collectionJson : collectionsJson->array_) {
            string id;
            const auto* idJson = collectionJson.find("id");
            FromJson(*idJson, id);
            const auto* collectionSrcJson = collectionJson.find("src");
            if (collectionSrcJson && collectionSrcJson->is_string()) {
                string collectionSrcUri;
                FromJson(*collectionSrcJson, collectionSrcUri);

                // Instantiate the collection pointed by src.
#ifdef VERBOSE_LOGGING
                CORE_LOG_D("External Collection: uri='%s' context='%s'", collectionSrcUri.c_str(),
                    string(contextUri).c_str());
#endif
                auto* externalCollection =
                    listener_->GetExternalCollection(ec.GetEcs(), collectionSrcUri, contextUri);
            } else {
                ec.AddSubCollection(id, {});
            }
        }
    }

    // NOTE: Always returns success, even if parts of the load failed.
    return result;
}

bool EcsSerializer::ReadComponents(IEntityCollection& ec, const json::value& jsonIn) const
{
    // Figure out to which entity these components belong to.
    const auto* entityJson = jsonIn.find("entity");
    if (!entityJson) {
        CORE_LOG_W("No entity defined for a component.");
        return false;
    }
    Entity entity {};
    if (!EntityFromJson(ec, *entityJson, entity)) {
        return false;
    }

    auto& ecs = ec.GetEcs();
    const auto* componentsJson = jsonIn.find("components");
    if (componentsJson) {
        // Read all entity components from json.
        for (auto& component : componentsJson->object_) {
            auto& key = component.key;
            const auto componentUid = StringToUid(key);

            auto& componentJson = component.value;
            auto* cm = ecs.GetComponentManager(componentUid);
            if (cm) {
                ReadComponent(ec, componentJson, entity, *cm);
            } else {
                // TODO: Maybe we should try to find a matching component by name as a fallback
                CORE_LOG_W("Unrecognized component found: '%s'", string(key).c_str());
            }
        }
    }

    return true;
}

namespace {
// Helper function that makes sure that any dynamic arrays referenced in a property path are large enough to contain the
// referenced indices.
void EnsureDynamicArraySize(IPropertyHandle* propertyHandle, string_view propertyPath)
{
    const auto separatorPosition = propertyPath.find('[');
    if (separatorPosition == ::string::npos) {
        return;
    }
    const auto separatorEndPosition = propertyPath.find(']', separatorPosition);
    if (separatorEndPosition == ::string::npos) {
        return;
    }

    string arrayPath, arrayIndex;
    arrayPath = propertyPath.substr(0, separatorPosition);
    arrayIndex = propertyPath.substr(separatorPosition + 1, separatorEndPosition - separatorPosition - 1);

    char* end = nullptr;
    const unsigned long index = std::strtoul(arrayIndex.c_str(), &end, 10); // 10: base
    // Check that conversion stopped at the end of the string.
    if (!end || *end != '\0') {
        return;
    }

    PropertyData propertyData;
    PropertyData::PropertyOffset propertyOffset = propertyData.WLock(*propertyHandle, arrayPath);
    if (propertyOffset) {
        auto* containerMethods = propertyOffset.property->metaData.containerMethods;
        if (containerMethods && containerMethods->resize) {
            if (containerMethods->size(propertyOffset.offset) <= index) {
                containerMethods->resize(propertyOffset.offset, index + 1);
            }
        }
    }

    const auto restOfThePath = propertyPath.substr(separatorEndPosition);
    EnsureDynamicArraySize(&propertyData, restOfThePath);
}
} // namespace

bool EcsSerializer::ReadComponent(
    IEntityCollection& ec, const json::value& jsonIn, Entity entity, IComponentManager& component) const
{
    // Create the component if it does not exist yet.
    auto componentId = component.GetComponentId(entity);
    if (componentId == IComponentManager::INVALID_COMPONENT_ID) {
        component.Create(entity);
        componentId = component.GetComponentId(entity);
    }

    ec.MarkComponentSerialized(entity, component.GetUid(), true);

    const auto* propertiesJson = jsonIn.find("properties");
    if (!propertiesJson || propertiesJson->type != json::type::object) {
        // No properties.
        return true;
    }

    auto* propertyHandle = component.GetData(componentId);
    if (!propertyHandle) {
        return false;
    }

    for (auto& propertyJson : propertiesJson->object_) {
        const auto& propertyPath = propertyJson.key;
        const auto& propertyValueJson = propertyJson.value;
        auto pathView = string_view(propertyPath.data(), propertyPath.size());

        // Find the property using the propertyName
        {
            const IPropertyHandle* handle = propertyHandle;
            PropertyData propertyData;
            PropertyData::PropertyOffset propertyOffset;

            // Check if this is property container.
            string path, name;
            auto containerHandle = ResolveContainerProperty(*handle, string(pathView), path, name);
            if (containerHandle) {
                propertyOffset = propertyData.WLock(*containerHandle, name);
            } else {
                // We can only ask for the property if we first make sure it exists (we may be referencing a dynamic
                // array).
                EnsureDynamicArraySize(propertyHandle, pathView);

                propertyOffset = propertyData.WLock(*propertyHandle, pathView);
            }

            if (propertyOffset) {
                if (ReadProperty(ec, propertyValueJson, *propertyOffset.property, propertyOffset.offset)) {
                    // Mark this property value as serialized (instead of being a cloned from a prototype entity).
                    ec.MarkPropertySerialized(entity, component.GetUid(), pathView, true);
                } else {
                    CORE_LOG_W("Unrecognized property: Component: '%s' Property: '%s'", component.GetName().data(),
                        string(pathView).c_str());
                }
            }
        }
    }
    return true;
}

bool EcsSerializer::ReadProperty(
    IEntityCollection& ec, const json::value& jsonIn, const Property& property, uintptr_t offset) const
{
    // See if there is a serializer for this type. Otherwise recurse further.
    auto serializer = typetoSerializerMap_.find(property.type);
    if (serializer != typetoSerializerMap_.end()) {
        return serializer->second->FromJson(ec, jsonIn, property, offset);

    } else if (!property.metaData.enumMetaData.empty()) {
        // Enum type property.
        if (jsonIn.is_unsigned_int()) {
            switch (property.size) {
                case sizeof(uint8_t):
                    GetPropertyValue<uint8_t>(offset) = static_cast<uint8_t>(jsonIn.unsigned_);
                    return true;
                case sizeof(uint16_t):
                    GetPropertyValue<uint16_t>(offset) = static_cast<uint16_t>(jsonIn.unsigned_);
                    return true;
                case sizeof(uint32_t):
                    GetPropertyValue<uint32_t>(offset) = static_cast<uint32_t>(jsonIn.unsigned_);
                    return true;
                case sizeof(uint64_t):
                    GetPropertyValue<uint64_t>(offset) = static_cast<uint64_t>(jsonIn.unsigned_);
                    return true;
            }
        }

    } else if (property.metaData.containerMethods) {
        // Special handling for byte data encoded as base64.
        if (jsonIn.is_string()) {
            // A base64 encoded string containing raw array data
            auto bytes = ::Base64Decode(jsonIn.string_);

            // Only valid for byte data.
            if (property.type == PropertyType::UINT8_ARRAY_T) {
                if (property.size != bytes.size()) {
                    CORE_LOG_W("Invalid base64 data size in: %s", string(property.name).c_str());
                    return false;
                }
                CloneData(GetPropertyValue<uint8_t*>(offset), property.size, &bytes[0], bytes.size());
                return true;

            } else if (property.type == PROPERTYTYPE(vector<uint8_t>)) {
                GetPropertyValue<vector<uint8_t>>(offset).swap(bytes);
                return true;
            }
            return false;
        }

        // Container type property.
        if (property.type.isArray) {
            // C style array.
            if (jsonIn.is_array()) {
                if (jsonIn.array_.size() != property.count) {
                    CORE_LOG_W("Expecting a json array of size %zu", property.count);
                    return false;
                }
                for (size_t i = 0; i < property.count; i++) {
                    uintptr_t ptr = offset + i * property.metaData.containerMethods->property.size;
                    // TODO: return false if any recurseive call fails?
                    ReadProperty(ec, jsonIn.array_.at(i), property.metaData.containerMethods->property, ptr);
                }
                return true;

            } else if (jsonIn.is_object()) {
                // Allow "sparse arrays" by using objects with the array index as the key.
                for (auto& element : jsonIn.object_) {
                    const auto& key = element.key;
                    const auto index = static_cast<size_t>(strtol(string(key).c_str(), nullptr, 10));
                    if ((index == 0 && key != "0") || index >= property.count) {
                        CORE_LOG_W("Invalid array Index: %s", string(key).c_str());
                        continue;
                    }
                    uintptr_t ptr = offset + index * property.metaData.containerMethods->property.size;
                    ReadProperty(ec, element.value, property.metaData.containerMethods->property, ptr);
                }
                return true;
            }
            return false;

        } else {
            // This is a "non trivial container".
            if (jsonIn.is_array()) {
                const auto count = jsonIn.array_.size();
                property.metaData.containerMethods->resize(offset, count);
                for (size_t i = 0; i < count; i++) {
                    uintptr_t ptr = property.metaData.containerMethods->get(offset, i);
                    ReadProperty(ec, jsonIn.array_.at(i), property.metaData.containerMethods->property, ptr);
                }
                return true;

            } else if (jsonIn.is_object()) {
                // Allow "sparse arrays" by using objects with the array index as the key.
                for (auto& element : jsonIn.object_) {
                    const auto& key = element.key;
                    const auto index = static_cast<size_t>(strtol(string(key).c_str(), nullptr, 10));
                    if ((index == 0 && key != "0")) {
                        CORE_LOG_W("Invalid array Index: %s", string(key).c_str());
                        continue;
                    }

                    const auto count = property.metaData.containerMethods->size(offset);
                    if (count <= index) {
                        property.metaData.containerMethods->resize(offset, index + 1);
                    }
                    uintptr_t ptr = property.metaData.containerMethods->get(offset, index);
                    ReadProperty(ec, element.value, property.metaData.containerMethods->property, ptr);
                }
                return true;
            }
            return false;
        }

    } else if (!property.metaData.memberProperties.empty()) {
        // Struct type property (ie. has sub properties).
        if (jsonIn.is_object()) {
            for (const auto& subProperty : property.metaData.memberProperties) {
                // TODO: is there a way to not create the string
                const string name(subProperty.name);
                const auto* subJson = jsonIn.find(name);
                if (subJson) {
                    ReadProperty(ec, *subJson, subProperty, offset + subProperty.offset);
                }
            }
            // TODO: return false if any recurseive call fails?
            return true;
        }
    }

    return false;
}

RENDER_NS::RenderHandleReference EcsSerializer::LoadImageResource(::string_view uri) const
{
    // Get rid of a possible query string in the uri.
    const auto fileUri = PathUtil::ResolveUri({}, uri, false);

    auto params = PathUtil::GetUriParameters(uri);

    // Image loading flags can be passed in the uri query string.
    uint64_t imageLoaderFlags {};
    auto loaderFlags = params.find("loaderFlags");
    if (loaderFlags != params.end()) {
        const char* start = loaderFlags->second.data();
        const char* end = start + loaderFlags->second.size();
        std::from_chars(start, end, imageLoaderFlags);
    }

    auto imageLoadResult = renderContext_.GetEngine().GetImageLoaderManager().LoadImage(fileUri, imageLoaderFlags);

    RenderHandleReference imageHandle {};
    if (!imageLoadResult.success) {
        CORE_LOG_E("Could not load image asset: %s", imageLoadResult.error);

    } else {
        auto& gpuResourceMgr = renderContext_.GetDevice().GetGpuResourceManager();
        GpuImageDesc gpuDesc = gpuResourceMgr.CreateGpuImageDesc(imageLoadResult.image->GetImageDesc());
        gpuDesc.usageFlags = CORE_IMAGE_USAGE_SAMPLED_BIT | CORE_IMAGE_USAGE_TRANSFER_DST_BIT;
        if (gpuDesc.engineCreationFlags & EngineImageCreationFlagBits::CORE_ENGINE_IMAGE_CREATION_GENERATE_MIPS) {
            gpuDesc.usageFlags |= CORE_IMAGE_USAGE_TRANSFER_SRC_BIT;
        }
        gpuDesc.memoryPropertyFlags = CORE_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;

        imageHandle = gpuResourceMgr.Create(uri, gpuDesc, std::move(imageLoadResult.image));
    }

    return imageHandle;
}

void EcsSerializer::Destroy()
{
    delete this;
}

IEcsSerializer::Ptr CreateEcsSerializer(RENDER_NS::IRenderContext& renderContext)
{
    return IEcsSerializer::Ptr { new EcsSerializer(renderContext) };
}

ECS_SERIALIZER_END_NAMESPACE()