SHADE_Y3/SHADE_Engine/src/Serialization/SHSerialization.cpp

#include "SHpch.h"
#include "SHSerializationHelper.hpp"
#include "SHSerialization.h"

#include <yaml-cpp/yaml.h>

#include "ECS_Base/Managers/SHEntityManager.h"
#include "Scene/SHSceneManager.h"
#include "Tools/SHException.h"

#include "Math/Transform/SHTransformComponent.h"

namespace SHADE
{
  void SHSerialization::SerializeSceneToFile(std::filesystem::path const& path)
  {

  }

  std::string SHSerialization::SerializeSceneToString()
  {
    YAML::Emitter out;
    SerializeSceneToEmitter(out);
    return std::string(out.c_str());
  }

  void SHSerialization::SerializeSceneToEmitter(YAML::Emitter& out)
  {
    auto const& sceneGraph = SHSceneManager::GetCurrentSceneGraph();
    auto root = sceneGraph.GetRoot();

    SHASSERT(root != nullptr, "Root is null. Failed to serialize scene to node.");
  
    auto const& children = root->GetChildren();
    out << YAML::BeginDoc;

    auto pred = [&out](SHSceneNode* node){out << SerializeEntityToNode(node);};
    sceneGraph.Traverse(pred);
      //out << SerializeEntityToNode(child);
    
    out << YAML::EndDoc;
  }

  static void DeserializeEntity(YAML::iterator& it, YAML::Node const& node, std::vector<EntityID>& createdEntities, EntityID parentEID = MAX_EID)
  {
    if(!node[EIDNode])
      return;
    EntityID eid = node[EIDNode].as<EntityID>();
    std::string name = "Default";
    if(node[EntityNameNode])
      name = node[EntityNameNode].as<std::string>();
    //Compile component IDs
    const auto componentIDList = SHSerialization::GetComponentIDList(node[ComponentsNode]);
    eid = SHEntityManager::CreateEntity(componentIDList, eid, name, parentEID);
    createdEntities.push_back(eid);
    if(node[NumberOfChildrenNode])
    {      int numOfChildren = node[NumberOfChildrenNode].as<int>();
      for(int i = 0; i < numOfChildren; ++i)
      {
        DeserializeEntity(it, *it, createdEntities, eid);
        ++it;
      }
    }
  }

  void SHSerialization::DeserializeSceneFromFile(std::string const& fileData)
  {
    YAML::Node entities = YAML::Load(fileData.c_str());
    std::vector<EntityID> createdEntities{};

    //Create Entities
    for(auto it = entities.begin(); it != entities.end(); ++it)
    {
      DeserializeEntity(it, (*it), createdEntities);
    }

    //Initialize Entity
    for(auto it = entities.begin(); it != entities.end(); ++it)
    {
      //For each node, Deserialize component
        //Recurse through properties 
    }
  }



  std::string SHSerialization::SerializeEntityToString()
  {
    return std::string();
  }

  void SHSerialization::SerializeEntityToFile(std::filesystem::path const& path)
  {
  }

  YAML::Node SHSerialization::SerializeEntityToNode(SHSceneNode* sceneNode)
  {
    YAML::Node node;
    auto eid = sceneNode->GetEntityID();
    auto entity = SHEntityManager::GetEntityByID(eid);
    if (!sceneNode || !entity)
    {
      node = YAML::Null;
      return node;
    }

    node[EIDNode] = eid;
    node[EntityNameNode] = entity->name;
    node[IsActiveNode] = sceneNode->IsActive();
    auto const& children = sceneNode->GetChildren();
    node[NumberOfChildrenNode] = children.size();

    YAML::Node components;

    if (const auto transform = SHComponentManager::GetComponent_s<SHTransformComponent>(eid))
    {
      components[rttr::type::get<SHTransformComponent>().get_name().data()] = SHSerializationHelper::SerializeComponentToNode(transform);
    }
    node[ComponentsNode] = components;
    return node;
  }

  template<typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
   std::optional<ComponentTypeID> GetComponentID(YAML::Node const & componentNode)
  {
    if(componentNode[rttr::type::get<ComponentType>().get_name().data()])
      return {SHFamilyID<SHComponent>::GetID<ComponentType>()};
    else
      return std::nullopt;
  }

  std::vector<ComponentTypeID> SHSerialization::GetComponentIDList(YAML::Node const& componentsNode)
  {
    std::vector<ComponentTypeID> componentIDList;

    auto id = GetComponentID<SHTransformComponent>(componentsNode);
    if(id.has_value())
      componentIDList.push_back(id.value());

    return componentIDList;
  }
}