#pragma once

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

#include <rttr/registration>
#include <unordered_map>

#include "ECS_Base/Managers/SHComponentManager.h"
#include "Graphics/MiddleEnd/Materials/SHMaterialSpec.h"
#include "Tools/Logger/SHLog.h"


namespace SHADE
{
  static constexpr std::string_view IsActive = "IsActive";

  using AssetQueue =  std::unordered_map<AssetID, AssetType>;
  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 if (varType == rttr::type::get<std::string>())
          node = var.to_string();
      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 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)
    {
      if constexpr (YAML::HasYAMLConv<ComponentType>())
      {
        if (component)
        {
          auto componentNode = YAML::convert<ComponentType>::encode(*component);
          componentNode[IsActive.data()] = component->isActive;
          return componentNode;
        }
      }
      else
      {
        if (component)
        {
          YAML::Node compNode{};
          if (!component)
            return compNode;
          auto componentType = rttr::type::get<ComponentType>();
          compNode = RTTRToNode(*component);
          compNode[IsActive.data()] = component->isActive;
          return compNode;

        }
      }
    }

    template <typename Type>
    static void InitializeProperty(Type* object, 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(object, vec);
      }
      else if (propType == rttr::type::get<SHVec3>())
      {
        SHVec3 vec = propertyNode.as<SHVec3>();
        prop.set_value(object, vec);
      }
      else if (propType == rttr::type::get<SHVec2>())
      {
        SHVec2 vec = propertyNode.as<SHVec2>();
        prop.set_value(object, vec);
      }
      else if (propType.is_arithmetic())
      {
        bool ok = false;
        if (propType == rttr::type::get<bool>())
          prop.set_value(object, propertyNode.as<bool>());
        else if (propType == rttr::type::get<int8_t>())
          prop.set_value(object, propertyNode.as<int8_t>());
        else if (propType == rttr::type::get<int16_t>())
          prop.set_value(object, propertyNode.as<int16_t>());
        else if (propType == rttr::type::get<int32_t>())
          prop.set_value(object, propertyNode.as<int32_t>());
        else if (propType == rttr::type::get<int64_t>())
          prop.set_value(object, propertyNode.as<int64_t>());
        else if (propType == rttr::type::get<uint8_t>())
          prop.set_value(object, propertyNode.as<uint8_t>());
        else if (propType == rttr::type::get<uint16_t>())
          prop.set_value(object, propertyNode.as<uint16_t>());
        else if (propType == rttr::type::get<uint32_t>())
          prop.set_value(object, propertyNode.as<uint32_t>());
        else if (propType == rttr::type::get<uint64_t>())
          prop.set_value(object, propertyNode.as<uint64_t>());
        else if (propType == rttr::type::get<float>())
          prop.set_value(object, propertyNode.as<float>());
        else if (propType == rttr::type::get<double>())
          prop.set_value(object, propertyNode.as<double>());
      }
      else if (propType.is_enumeration())
      {
        auto enumAlign = prop.get_enumeration();
        prop.set_value(object, enumAlign.name_to_value(propertyNode.as<std::string>()));
      }
      else if (propType == rttr::type::get<std::string>())
          prop.set_value(object, propertyNode.as<std::string>());
      else
      {
        auto properties = propType.get_properties();
        for (auto const& property : properties)
        {
          if(propertyNode[property.get_name().data()].IsDefined())
            InitializeProperty(object, property, propertyNode[property.get_name().data()]);
        }
      }
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static bool InitializeComponentFromNode(YAML::Node const& componentsNode, EntityID const& eid)
    {
      if constexpr (YAML::HasYAMLConv<ComponentType>())
      {
        auto component = SHComponentManager::GetComponent_s<ComponentType>(eid);
        if (componentsNode.IsNull() || !component)
          return false;
        auto componentNode = GetComponentNode<ComponentType>(componentsNode, eid);
        if (componentNode.IsNull() || !componentNode.IsDefined())
          return false;
        if (componentNode[IsActive.data()].IsDefined())
          component->isActive = componentNode[IsActive.data()].as<bool>();
        YAML::convert<ComponentType>::decode(componentNode, *component);
        return true;
      }
      else
      {
        ComponentType* component = SHComponentManager::GetComponent_s<ComponentType>(eid);
        if (componentsNode.IsNull() && !component)
          return false;
        auto rttrType = rttr::type::get<ComponentType>();
        auto componentNode = componentsNode[rttrType.get_name().data()];
        if (!componentNode.IsDefined())
          return false;
        if (componentNode[IsActive.data()].IsDefined())
          component->isActive = componentNode[IsActive.data()].as<bool>();

        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()]);
          }
        }
      }
      return true;
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static YAML::Node GetComponentNode(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 {};
      return componentNode;
    }

    //template<typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    //static void AddComponentToComponentNode(YAML::Node& componentsNode, EntityID const& eid)
    //{
    //  if constexpr (YAML::HasYAMLConv<ComponentType>())
    //  {
    //    if (ComponentType* component = SHComponentManager::GetComponent_s<ComponentType>(eid))
    //    {
    //      auto componentNode = YAML::convert<ComponentType>::encode(*component);
    //      componentNode[IsActive.data()] = component->isActive;
    //      componentsNode[rttr::type::get<ComponentType>().get_name().data()] = componentNode;
    //    }
    //  }
    //  else
    //  {
    //    if (const ComponentType* component = SHComponentManager::GetComponent_s<ComponentType>(eid))
    //    {
    //      componentsNode[rttr::type::get<ComponentType>().get_name().data()] = SHSerializationHelper::SerializeComponentToNode(component);
    //    }
    //  }

    //}

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static std::string SerializeComponentToString(EntityID const& eid)
    {
      if (ComponentType* component = SHComponentManager::GetComponent_s<ComponentType>(eid))
      {
        YAML::Emitter out;
        YAML::Node node{};

        node[rttr::type::get<ComponentType>().get_name().data()] = SerializeComponentToNode(component);
        out << node;

        return out.c_str();
      }
      return std::string();
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static bool DeserializeComponentFromString(std::string data, EntityID const& eid)
    {
      YAML::Node node = YAML::Load(data);
      return InitializeComponentFromNode<ComponentType>(node, eid);
    }

    template <typename ComponentType, std::enable_if_t<std::is_base_of_v<SHComponent, ComponentType>, bool> = true>
    static void FetchAssetsFromComponent(YAML::Node const& componentsNode, EntityID const& eid, AssetQueue& assetQueue)
    {
    }

    template<>
    static void FetchAssetsFromComponent<SHRenderable>(YAML::Node const& componentsNode, EntityID const& eid, AssetQueue& assetQueue)
    {
      auto node = GetComponentNode<SHRenderable>(componentsNode, eid);
      if(!node.IsDefined())
        return;
      if (auto const& meshNode = node[YAML::convert<SHRenderable>::MESH_YAML_TAG.data()]; meshNode.IsDefined())
      {
        assetQueue.insert({meshNode.as<AssetID>(), AssetType::MESH});
        //SHResourceManager::LoadOrGet<SHMesh>(node[YAML::convert<SHRenderable>::MESH_YAML_TAG.data()].as<AssetID>());
      }
      if (auto const& matNode = node[YAML::convert<SHRenderable>::MAT_YAML_TAG.data()]; matNode.IsDefined())
      {
        auto const matAsset = SHAssetManager::GetData<SHMaterialAsset>(matNode.as<AssetID>());
        if(matAsset)
        {
          SHMaterialSpec spec;
          YAML::convert<SHMaterialSpec>::decode(*YAML::Load(matAsset->data).begin(), spec);
          if(spec.properties.IsDefined())
          {
            auto fragShader =  SHResourceManager::LoadOrGet<SHVkShaderModule>(spec.fragShader);
            auto interface = fragShader->GetReflectedData().GetDescriptorBindingInfo().GetShaderBlockInterface(SHGraphicsConstants::DescriptorSetIndex::PER_INSTANCE, SHGraphicsConstants::DescriptorSetBindings::BATCHED_PER_INST_DATA);
            int const varCount = static_cast<int>(interface->GetVariableCount());

            for (int i = 0; i < varCount; ++i)
            {
              auto variable = interface->GetVariable(i);
              if(variable->type != SHShaderBlockInterface::Variable::Type::INT)
                continue;
              const std::string& VAR_NAME = interface->GetVariableName(i);
              if(VAR_NAME.empty())
                continue;
              assetQueue.insert({spec.properties[VAR_NAME.data()].as<AssetID>(), AssetType::TEXTURE});
            }
          }
        }
        //assetQueue.insert({matNode.as<AssetID>(), AssetType::MATERIAL});
        //SHResourceManager::LoadOrGet<SHMaterial>(node[YAML::convert<SHRenderable>::MAT_YAML_TAG.data()].as<AssetID>());
      }
    }
  };
}