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"
#include "Graphics/MiddleEnd/Interface/SHMaterial.h"
#include "Graphics/MiddleEnd/Interface/SHMaterialInstance.h"
#include "SHSerializationTools.h"
#include "Physics/Components/SHColliderComponent.h"
#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h"
#include "Tools/SHLog.h"

namespace YAML
{
  using namespace SHADE;

  template<>
  struct convert<SHVec4>
  {
    static constexpr const char* x = "x";
    static constexpr const char* y = "y";
    static constexpr const char* z = "z";
    static constexpr const char* w = "w";

    static Node encode(SHVec4 const& rhs)
    {
      Node node;
      node.SetStyle(EmitterStyle::Flow);
      node[x] = rhs.x;
      node[y] = rhs.y;
      node[z] = rhs.z;
      node[w] = rhs.w;
      return node;
    }
    static bool decode(Node const& node, SHVec4& rhs)
    {
      if (node[x].IsDefined())
        rhs.x = node[x].as<float>();
      if (node[y].IsDefined())
        rhs.y = node[y].as<float>();
      if (node[z].IsDefined())
        rhs.z = node[z].as<float>();
      if (node[w].IsDefined())
        rhs.w = node[w].as<float>();
      return true;
    }
  };

  template<>
  struct convert<SHVec3>
  {
    static constexpr const char* x = "x";
    static constexpr const char* y = "y";
    static constexpr const char* z = "z";

    static Node encode(SHVec3 const& rhs)
    {
      Node node;
      node.SetStyle(EmitterStyle::Flow);
      node[x] = rhs.x;
      node[y] = rhs.y;
      node[z] = rhs.z;
      return node;
    }
    static bool decode(Node const& node, SHVec3& rhs)
    {
      if (node[x].IsDefined())
        rhs.x = node[x].as<float>();
      if (node[y].IsDefined())
        rhs.y = node[y].as<float>();
      if (node[z].IsDefined())
        rhs.z = node[z].as<float>();
      return true;
    }
  };

  template<>
  struct convert<SHVec2>
  {
    static constexpr const char* x = "x";
    static constexpr const char* y = "y";

    static Node encode(SHVec2 const& rhs)
    {
      Node node;
      node.SetStyle(EmitterStyle::Flow);
      node[x] = rhs.x;
      node[y] = rhs.y;
      return node;
    }
    static bool decode(Node const& node, SHVec2& rhs)
    {
      if (node[x].IsDefined())
        rhs.x = node[x].as<float>();
      if (node[y].IsDefined())
        rhs.y = node[y].as<float>();
      return true;
    }
  };

  template<>
  struct convert<SHCollider>
  {
    static constexpr const char* IsTrigger = "Is Trigger";

    static constexpr const char* Type = "Type";
    static constexpr const char* HalfExtents = "Half Extents";
    static constexpr const char* Radius = "Radius";

    static constexpr const char* Friction = "Friction";
    static constexpr const char* Bounciness = "Bounciness";
    static constexpr const char* Density = "Density";
    static constexpr const char* PositionOffset = "Position Offset";

    static Node encode(SHCollider& rhs)
    {
      Node node;

      node[IsTrigger] = rhs.IsTrigger();

      rttr::type const shapeRttrType = rttr::type::get<SHCollider::Type>();
      rttr::enumeration const enumAlign = shapeRttrType.get_enumeration();
      SHCollider::Type colliderType = rhs.GetType();

      node[Type] = enumAlign.value_to_name(colliderType).data();

      switch (colliderType)
      {
      case SHCollider::Type::BOX:
      {
        auto const bb = reinterpret_cast<SHBoundingBox*>(rhs.GetShape());
        node[HalfExtents] = bb->GetHalfExtents();
      }
      break;
      case SHCollider::Type::SPHERE:
      {
        auto const bs = reinterpret_cast<SHBoundingSphere*>(rhs.GetShape());
        node[Radius] = bs->GetRadius();
      }
      break;
      case SHCollider::Type::CAPSULE: break;
      default:;
      }

      node[Friction] = rhs.GetFriction();
      node[Bounciness] = rhs.GetBounciness();
      node[Density] = rhs.GetDensity();
      node[PositionOffset] = rhs.GetPositionOffset();

      return node;
    }
    static bool decode(Node const& node, SHCollider& rhs)
    {
      if (node[IsTrigger].IsDefined())
        rhs.SetIsTrigger(node[IsTrigger].as<bool>());
      if (!node[Type].IsDefined())
        return false;
      rttr::type const shapeRttrType = rttr::type::get<SHCollider::Type>();
      rttr::enumeration const enumAlign = shapeRttrType.get_enumeration();
      bool ok;
      const SHCollider::Type colliderType = enumAlign.name_to_value(node[Type].as<std::string>()).convert<SHCollider::Type>(&ok);
      if (!ok)
        return false;
      switch (colliderType)
      {
      case SHCollider::Type::BOX:
      {
        if (node[HalfExtents].IsDefined())
          rhs.SetBoundingBox(node[HalfExtents].as<SHVec3>());
      }
      break;
      case SHCollider::Type::SPHERE:
      {
        if (node[Radius].IsDefined())
          rhs.SetBoundingSphere(node[Radius].as<float>());
      }
      break;
      case SHCollider::Type::CAPSULE: break;
      default:;
      }
      if (node[Friction].IsDefined())
        rhs.SetFriction(node[Friction].as<float>());
      if (node[Bounciness].IsDefined())
        rhs.SetBounciness(rhs.GetBounciness());
      if (node[Density].IsDefined())
        rhs.SetDensity(node[Density].as<float>());
      if (node[PositionOffset].IsDefined())
        rhs.SetPositionOffset(node[PositionOffset].as<SHVec3>());

      return true;
    }
  };

  template<>
  struct convert<SHColliderComponent>
  {
    static constexpr const char* Colliders = "Colliders";
    static Node encode(SHColliderComponent& rhs)
    {
      Node node, collidersNode;
      auto const& colliders = rhs.GetColliders();
      int const numColliders = static_cast<int>(colliders.size());
      for (int i = 0; i < numColliders; ++i)
      {
        auto& collider = rhs.GetCollider(i);
        Node colliderNode = convert<SHCollider>::encode(collider);
        if (colliderNode.IsDefined())
          collidersNode[i] = colliderNode;
      }
      node[Colliders] = collidersNode;
      return node;
    }
    static bool decode(Node const& node, SHColliderComponent& rhs)
    {
      if (node[Colliders].IsDefined())
      {
        int numColliders{};
        for (auto const& colliderNode : node[Colliders])
        {
          rttr::type const shapeRttrType = rttr::type::get<SHCollider::Type>();
          rttr::enumeration const enumAlign = shapeRttrType.get_enumeration();
          bool ok = false;
          const SHCollider::Type colliderType = enumAlign.name_to_value(colliderNode[convert<SHCollider>::Type].as<std::string>()).convert<SHCollider::Type>(&ok);
          if (!ok)
            return false;

          switch (colliderType)
          {
          case SHCollider::Type::BOX: rhs.AddBoundingBox(); break;
          case SHCollider::Type::SPHERE: rhs.AddBoundingSphere(); break;
          case SHCollider::Type::CAPSULE: break;
          default:;
          }
          YAML::convert<SHCollider>::decode(colliderNode, rhs.GetCollider(numColliders++));
        }
      }
      return true;
    }
  };

  template<>
  struct convert<SHMaterialSpec>
  {
    static constexpr std::string_view VERT_SHADER_YAML_TAG = "VertexShader";
    static constexpr std::string_view FRAG_SHADER_YAML_TAG = "FragmentShader";
    static constexpr std::string_view SUBPASS_YAML_TAG = "SubPass";
    static constexpr std::string_view PROPS_YAML_TAG = "Properties";

    static YAML::Node encode(SHMaterialSpec const& rhs)
    {
      YAML::Node node;
      node[VERT_SHADER_YAML_TAG.data()] = rhs.vertexShader;
      node[FRAG_SHADER_YAML_TAG.data()] = rhs.fragShader;
      node[SUBPASS_YAML_TAG.data()] = rhs.subpassName;
      node[PROPS_YAML_TAG.data()] = rhs.properties;
      return node;
    }

    static bool decode(YAML::Node const& node, SHMaterialSpec& rhs)
    {
      // Retrieve Shader Asset IDs
      if (node[VERT_SHADER_YAML_TAG.data()].IsDefined())
        rhs.vertexShader = node[VERT_SHADER_YAML_TAG.data()].as<AssetID>();
      if (node[FRAG_SHADER_YAML_TAG.data()].IsDefined())
        rhs.fragShader = node[FRAG_SHADER_YAML_TAG.data()].as<AssetID>();

      // Retrieve Subpass
      if (node[SUBPASS_YAML_TAG.data()].IsDefined())
        rhs.subpassName = node[SUBPASS_YAML_TAG.data()].as<std::string>();

      // Retrieve
      if (node[PROPS_YAML_TAG.data()].IsDefined())
        rhs.properties = node[PROPS_YAML_TAG.data()];

      return true;
    }
  };

  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.GetMesh()).value_or(0);
      node[MAT_YAML_TAG.data()] = SHResourceManager::GetAssetID<SHMaterial>(rhs.GetMaterial()->GetBaseMaterial()).value_or(0);
      return node;
    }
    static bool decode(YAML::Node const& node, SHRenderable& rhs)
    {
      if (node[MESH_YAML_TAG.data()].IsDefined())
      {
        rhs.SetMesh(SHResourceManager::LoadOrGet<SHMesh>(node[MESH_YAML_TAG.data()].as<AssetID>()));
      }
      if (node[MAT_YAML_TAG.data()].IsDefined())
      {
        // Temporarily, use default material
        auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
        if (!gfxSystem)
          return false;
        Handle<SHMaterial> baseMat = SHResourceManager::LoadOrGet<SHMaterial>(node[MAT_YAML_TAG.data()].as<AssetID>());
        if (!baseMat)
        {
          baseMat = gfxSystem->GetDefaultMaterial();
          SHLog::Warning("[SHSerializationHelper] Unable to load specified material. Falling back to default material.");
        }
        rhs.SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(baseMat));
      }
      return true;
    }
  };
}

namespace SHADE
{
  struct SHSerializationHelper
  {


    static YAML::Node RTTRToNode(const rttr::variant& var)
    {
      YAML::Node node;
      auto varType = var.get_type();
      if (varType.is_sequential_container())
      {
        for (auto const& elem : var.create_sequential_view())
        {
          node.push_back(RTTRToNode(elem));
        }
      }
      if (varType == rttr::type::get<SHVec4>())
      {
        node = YAML::convert<SHVec4>::encode(var.convert<SHVec4>());
      }
      else if (varType == rttr::type::get<SHVec3>())
      {
        node = YAML::convert<SHVec3>::encode(var.convert<SHVec3>());
      }
      else if (varType == rttr::type::get<SHVec2>())
      {
        node = YAML::convert<SHVec2>::encode(var.convert<SHVec2>());
      }
      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 const& 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 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)
    {
    }

    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.as<SHVec4>();
        prop.set_value(component, vec);
      }
      else if (propType == rttr::type::get<SHVec3>())
      {
        SHVec3 vec = propertyNode.as<SHVec3>();
        prop.set_value(component, vec);
      }
      else if (propType == rttr::type::get<SHVec2>())
      {
        SHVec2 vec = propertyNode.as<SHVec2>();
        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 const& property : properties)
        {
          if (propertyNode[property.get_name().data()].IsDefined())
            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)
    {
      ComponentType* 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 (!componentNode.IsDefined())
        return;
      auto properties = rttrType.get_properties();
      for (auto const& prop : properties)
      {
        if (componentNode[prop.get_name().data()].IsDefined())
        {
          InitializeProperty<ComponentType>(component, prop, componentNode[prop.get_name().data()]);
        }
      }
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static void ConvertNodeToComponent(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 (!componentNode.IsDefined())
        return;
      YAML::convert<ComponentType>::decode(componentNode, *component);
    }

  };
}