#pragma once

#include "ECS_Base/Components/SHComponent.h"
#include <yaml-cpp/yaml.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 "Physics/Components/SHColliderComponent.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])
        rhs.x = node[x].as<float>();
      if(node[y])
        rhs.y = node[y].as<float>();
      if(node[z])
        rhs.z = node[z].as<float>();
      if(node[w])
        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])
        rhs.x = node[x].as<float>();
      if(node[y])
        rhs.y = node[y].as<float>();
      if(node[z])
        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])
        rhs.x = node[x].as<float>();
      if(node[y])
        rhs.y = node[y].as<float>();
      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 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["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()]);
        }
      }
    }

  };
}