#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 "SHSerializationTools.h"

namespace YAML
{
    using namespace SHADE;
    template<>
    struct convert<SHMaterial>
    {
        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(SHMaterial const& rhs)
        {
            // Write Properties
            YAML::Node propertiesNode;
            Handle<SHShaderBlockInterface> pipelineProperties = rhs.GetShaderBlockInterface();
            for (int i = 0; i < static_cast<int>(pipelineProperties->GetVariableCount()); ++i)
            {
                const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i);
                if (!VARIABLE)
                    break;
                const std::string& VAR_NAME = pipelineProperties->GetVariableName(i);
                YAML::Node propNode;
                switch (VARIABLE->type)
                {
                    case SHADE::SHShaderBlockInterface::Variable::Type::FLOAT:
                        propNode = rhs.GetProperty<float>(VARIABLE->offset);
                        break;
                    case SHADE::SHShaderBlockInterface::Variable::Type::INT:
                        propNode = rhs.GetProperty<int>(VARIABLE->offset);
                        break;
                    case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2:
                        propNode = SHSerializationTools::ValToYAML(rhs.GetProperty<SHVec2>(VARIABLE->offset));
                        break;
                    case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR3:
                        propNode = SHSerializationTools::ValToYAML(rhs.GetProperty<SHVec3>(VARIABLE->offset));
                        break;
                    case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR4:
                        propNode = SHSerializationTools::ValToYAML(rhs.GetProperty<SHVec4>(VARIABLE->offset));
                        break;
                    case SHADE::SHShaderBlockInterface::Variable::Type::OTHER:
                    default:
                        continue;
                        break;
                }
                propertiesNode[VAR_NAME.data()] = propNode;
            }

            // Get Shader Handles
            const auto& SHADERS = rhs.GetPipeline()->GetPipelineLayout()->GetShaderModules();
            Handle<SHVkShaderModule> vertexShader, fragShader;
            for (const auto& shader : SHADERS)
            {
                const auto FLAG_BITS = shader->GetShaderStageFlagBits();
                if (FLAG_BITS & vk::ShaderStageFlagBits::eVertex)
                    vertexShader = shader;
                else if (FLAG_BITS & vk::ShaderStageFlagBits::eFragment)
                    fragShader = shader;
            }

            // Write Material
            YAML::Node node;
            
            node[VERT_SHADER_YAML_TAG.data()] = 0; // SHResourceManager::GetAssetID<SHVkShaderModule>(vertexShader).value_or(0);
            node[FRAG_SHADER_YAML_TAG.data()] = 0; // SHResourceManager::GetAssetID<SHVkShaderModule>(fragShader).value_or(0);
            node[SUBPASS_YAML_TAG.data()]     = rhs.GetPipeline()->GetPipelineState().GetSubpass()->GetName();
            node[PROPS_YAML_TAG.data()]       = propertiesNode;

            return node;
        }
        static bool decode(YAML::Node const& node, SHMaterial& rhs)
        {
            /*
            // Retrieve Shader Asset IDs
            AssetID vertShaderId = 0;
            AssetID fragShaderId = 0;
            if (node[VERT_SHADER_YAML_TAG.data()])
                vertShaderId = node[VERT_SHADER_YAML_TAG.data()].as<AssetID>();
            if (node[FRAG_SHADER_YAML_TAG.data()])
                fragShaderId = node[FRAG_SHADER_YAML_TAG.data()].as<AssetID>();

            // Ensure that both shaders are present
            if (vertShaderId == 0 || fragShaderId == 0)
                return false; // No pipeline

            // Get Shader Modules
            Handle<SHVkShaderModule> vertexShader, fragShader;
            vertexShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(vertShaderId);
            fragShader = SHResourceManager::LoadOrGet<SHVkShaderModule>(fragShaderId);

            // Get Pipeline Library
            if (node[SUBPASS_YAML_TAG.data()])
            {
                auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
                if (!gfxSystem)
                    return false;

                // Grab subpass from worldRenderer
                auto renderPass = gfxSystem->GetPrimaryRenderpass();
                if (!renderPass)
                    return false;
                auto subPass = renderPass->GetSubpass(node[SUBPASS_YAML_TAG.data()].as<std::string>());
                if (!subPass)
                    return false;

                // Set Pipeline
                rhs.SetPipeline(renderPass->GetOrCreatePipeline
                (
                    std::make_pair(vertexShader, fragShader),
                    subPass
                ));
            }
            */

            // TODO: Load Proper Material!
            // Set default material 
            auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
            if (!gfxSystem)
              return false;
            rhs.SetPipeline(gfxSystem->GetDefaultMaterial()->GetPipeline());

            if (node[PROPS_YAML_TAG.data()])
            {
                // Loop through all properties
                Handle<SHShaderBlockInterface> pipelineProperties = rhs.GetShaderBlockInterface();
                const YAML::Node& PROPS_NODE = node[PROPS_YAML_TAG.data()];
                for (int i = 0; i < static_cast<int>(pipelineProperties->GetVariableCount()); ++i)
                {
                    const std::string& PROP_NAME = pipelineProperties->GetVariableName(i);
                    const auto& PROP_NODE = PROPS_NODE[PROP_NAME.data()];
                    if (PROP_NODE)
                    {
                        const std::string& VAR_NAME = pipelineProperties->GetVariableName(i);
                        const SHShaderBlockInterface::Variable* VARIABLE = pipelineProperties->GetVariable(i);
                        switch (VARIABLE->type)
                        {
                            case SHADE::SHShaderBlockInterface::Variable::Type::FLOAT:
                                rhs.SetProperty(VARIABLE->offset, PROP_NODE.as<float>());
                                break;
                            case SHADE::SHShaderBlockInterface::Variable::Type::INT:
                                rhs.SetProperty(VARIABLE->offset, PROP_NODE.as<int>());
                                break;
                            case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR2:
                                rhs.SetProperty(VARIABLE->offset, SHSerializationTools::YAMLToVec2(PROP_NODE));
                                break;
                            case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR3:
                                rhs.SetProperty(VARIABLE->offset, SHSerializationTools::YAMLToVec3(PROP_NODE));
                                break;
                            case SHADE::SHShaderBlockInterface::Variable::Type::VECTOR4:
                                rhs.SetProperty(VARIABLE->offset, SHSerializationTools::YAMLToVec4(PROP_NODE));
                                break;
                            case SHADE::SHShaderBlockInterface::Variable::Type::OTHER:
                            default:
                                continue;
                                break;
                        }
                    }
                }
            }
            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()] = 0;  // TODO: Asset ID            
            return node;
        }
        static bool decode(YAML::Node const& node, SHRenderable& rhs)
        {
            if (node[MESH_YAML_TAG.data()])
            {
                rhs.SetMesh(SHResourceManager::LoadOrGet<SHMesh>(node[MESH_YAML_TAG.data()].as<AssetID>()));
            }
            if (node[MAT_YAML_TAG.data()])
            {
                // TODO: Convert Asset ID To Material HAndle
                // Temporarily, use default material
                auto gfxSystem = SHSystemManager::GetSystem<SHGraphicsSystem>();
                if (!gfxSystem)
                  return false;
                rhs.SetMaterial(gfxSystem->AddOrGetBaseMaterialInstance(gfxSystem->GetDefaultMaterial()));
            }
            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>())
      {
        prop.set_value(component, SHSerializationTools::YAMLToVec4(propertyNode));
      }
      else if (propType == rttr::type::get<SHVec3>())
      {
        prop.set_value(component, SHSerializationTools::YAMLToVec3(propertyNode));
      }
      else if (propType == rttr::type::get<SHVec2>())
      {
        prop.set_value(component, SHSerializationTools::YAMLToVec2(propertyNode));
      }
      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()]);
        }
      }
    }

    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 (componentsNode.IsNull())
        return;
      YAML::convert<ComponentType>::decode(componentNode, *component);
    }

  };
}