SHADE_Y3/SHADE_Engine/src/Serialization/SHSerializationHelper.hpp

#pragma once

#include <yaml-cpp/yaml.h>
#include "ECS_Base/Components/SHComponent.h"

#include <rttr/registration>

#include "ECS_Base/Managers/SHComponentManager.h"
#include "Math/Vector/SHVec2.h"
#include "Math/Vector/SHVec3.h"
#include "Math/Vector/SHVec4.h"
#include "Resource/SHResourceManager.h"
#include "Graphics/MiddleEnd/Interface/SHRenderable.h"

namespace YAML
{
    using namespace SHADE;
    template<>
    struct convert<SHRenderable>
    {
        static constexpr std::string_view MESH_YAML_TAG = "Mesh";
        static constexpr std::string_view MAT_YAML_TAG  = "Material";

        static YAML::Node encode(SHRenderable const& rhs)
        {
            YAML::Node node;
            node[MESH_YAML_TAG.data()] = SHResourceManager::GetAssetID<SHMesh>(rhs.Mesh).value_or(0);
            node[MAT_YAML_TAG.data()] = 0;  // TODO: Asset ID            
            return node;
        }
        static bool decode(YAML::Node const& node, SHRenderable& rhs)
        {
            if (node[MESH_YAML_TAG.data()])
            {
                rhs.Mesh = {};//SHResourceManager::LoadOrGet<SHMesh>(node[MESH_YAML_TAG].as<AssetID>());
            }
            if (node[MAT_YAML_TAG.data()])
            {
                // TODO: Convert Asset ID To Material HAndle
            }
            return true;
        }
    };
}


namespace SHADE
{
  struct SHSerializationHelper
  {
    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static std::string SerializeComponentToString(ComponentType* component)
    {
      return std::string();
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static void SerializeComponentToFile(ComponentType* component, std::filesystem::path const& path)
    {
    }

    static YAML::Node RTTRToNode(const rttr::variant& var)
    {
      YAML::Node node;
      auto varType = var.get_type();
      if (varType == rttr::type::get<SHVec4>())
      {
        node.SetStyle(YAML::EmitterStyle::Flow);
        node["X"] = var.convert<SHVec4>().x;
        node["Y"] = var.convert<SHVec4>().y;
        node["Z"] = var.convert<SHVec4>().z;
        node["W"] = var.convert<SHVec4>().w;
      }
      else if (varType == rttr::type::get<SHVec3>())
      {
        node.SetStyle(YAML::EmitterStyle::Flow);
        node["X"] = var.convert<SHVec3>().x;
        node["Y"] = var.convert<SHVec3>().y;
        node["Z"] = var.convert<SHVec3>().z;
      }
      else if (varType == rttr::type::get<SHVec2>())
      {
        node.SetStyle(YAML::EmitterStyle::Flow);
        node["X"] = var.convert<SHVec3>().x;
        node["Y"] = var.convert<SHVec3>().y;
      }
      else if (varType.is_arithmetic())
      {
        bool ok = false;
        if (varType == rttr::type::get<bool>())
          node = var.to_bool();
        else if (varType == rttr::type::get<int8_t>())
          node = var.to_int8(&ok);
        else if (varType == rttr::type::get<int16_t>())
          node = var.to_int16(&ok);
        else if (varType == rttr::type::get<int32_t>())
          node = var.to_int32(&ok);
        else if (varType == rttr::type::get<int64_t>())
          node = var.to_int64(&ok);
        else if (varType == rttr::type::get<uint8_t>())
          node = var.to_uint8(&ok);
        else if (varType == rttr::type::get<uint16_t>())
          node = var.to_uint16(&ok);
        else if (varType == rttr::type::get<uint32_t>())
          node = var.to_uint32(&ok);
        else if (varType == rttr::type::get<uint64_t>())
          node = var.to_uint64(&ok);
        else if (varType == rttr::type::get<float>())
          node = var.to_float(&ok);
        else if (varType == rttr::type::get<double>())
          node = var.to_double(&ok);
        //else if (varType == rttr::type::get<char>()) //same as uint8_t
        //    node = var.to_uint8();
      }
      else if (varType.is_enumeration())
      {
        bool ok = false;
        auto result = var.to_string(&ok);
        if (ok)
        {
          node = var.to_string();
        }
        else
        {
          ok = false;
          auto value = var.to_uint64(&ok);
          if (ok)
            node = value;
          else
            node = YAML::Null;
        }
      }
      else
      {
        auto properties = var.get_type().get_properties();
        for (auto property : properties)
        {
          node[property.get_name().data()] = RTTRToNode(property.get_value(var));
        }
      }
      return node;
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static YAML::Node SerializeComponentToNode(ComponentType* component)
    {
      YAML::Node node{};
      if (!component)
        return node;

      auto componentType = rttr::type::get<ComponentType>();
      node = RTTRToNode(*component);

      return node;
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static void InitializeProperty(ComponentType* component, rttr::property const& prop, YAML::Node const& propertyNode)
    {
      auto propType = prop.get_type();
      if (propType == rttr::type::get<SHVec4>())
      {
        SHVec4 vec{ propertyNode["X"].as<float>(), propertyNode["Y"].as<float>(), propertyNode["Z"].as<float>(), propertyNode["W"].as<float>() };
        prop.set_value(component, vec);
      }
      else if (propType == rttr::type::get<SHVec3>())
      {
        SHVec3 vec{ propertyNode["X"].as<float>(), propertyNode["Y"].as<float>(), propertyNode["Z"].as<float>() };
        prop.set_value(component, vec);
      }
      else if (propType == rttr::type::get<SHVec2>())
      {
        SHVec2 vec{ propertyNode["X"].as<float>(), propertyNode["Y"].as<float>() };
        prop.set_value(component, vec);
      }
      else if (propType.is_arithmetic())
      {
        bool ok = false;
        if (propType == rttr::type::get<bool>())
          prop.set_value(component, propertyNode.as<bool>());
        else if (propType == rttr::type::get<int8_t>())
          prop.set_value(component, propertyNode.as<int8_t>());
        else if (propType == rttr::type::get<int16_t>())
          prop.set_value(component, propertyNode.as<int16_t>());
        else if (propType == rttr::type::get<int32_t>())
          prop.set_value(component, propertyNode.as<int32_t>());
        else if (propType == rttr::type::get<int64_t>())
          prop.set_value(component, propertyNode.as<int64_t>());
        else if (propType == rttr::type::get<uint8_t>())
          prop.set_value(component, propertyNode.as<uint8_t>());
        else if (propType == rttr::type::get<uint16_t>())
          prop.set_value(component, propertyNode.as<uint16_t>());
        else if (propType == rttr::type::get<uint32_t>())
          prop.set_value(component, propertyNode.as<uint32_t>());
        else if (propType == rttr::type::get<uint64_t>())
          prop.set_value(component, propertyNode.as<uint64_t>());
        else if (propType == rttr::type::get<float>())
          prop.set_value(component, propertyNode.as<float>());
        else if (propType == rttr::type::get<double>())
          prop.set_value(component, propertyNode.as<double>());
      }
      else if (propType.is_enumeration())
      {
        auto enumAlign = prop.get_enumeration();
        prop.set_value(component, enumAlign.name_to_value(propertyNode.as<std::string>()));
      }
      else
      {
        auto properties = propType.get_properties();
        for (auto property : properties)
        {
          InitializeProperty(component, property, propertyNode[property.get_name().data()]);
        }
      }
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static void InitializeComponentFromNode(YAML::Node const& componentsNode, EntityID const& eid)
    {
      auto component = SHComponentManager::GetComponent_s<ComponentType>(eid);
      if (componentsNode.IsNull() && !component)
        return;
      auto rttrType = rttr::type::get<ComponentType>();
      auto componentNode = componentsNode[rttrType.get_name().data()];
      if (componentsNode.IsNull())
        return;
      auto properties = rttrType.get_properties();
      for (auto const& prop : properties)
      {
        if (componentNode[prop.get_name().data()])
        {
          InitializeProperty<ComponentType>(component, prop, componentNode[prop.get_name().data()]);
        }
      }
    }

  };
}