/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#pragma once

#include "Base/UUID.hpp"
#include "Math/AABB.hpp"
#include "Math/Pose.hpp"
#include <yaml-cpp/yaml.h>
#include <fmt/format.h>
#include <c4/format.hpp>

namespace YAML
{
	template<>
	struct convert<OpenVulkano::UUID>
	{
		static Node encode(const OpenVulkano::UUID& uuid)
		{
			return Node(uuid.string());
		}

		static bool decode(const Node& node, OpenVulkano::UUID& uuid)
		{
			if (node.IsScalar())
			{
				uuid.assign(node.Scalar());
				return true;
			}
			return false;
		}
	};

	template<>
	struct convert<OpenVulkano::Math::AABB>
	{
		static Node encode(const OpenVulkano::Math::AABB& bbox)
		{
			return Node(fmt::format("({},{},{}),({},{},{})", bbox.min.x, bbox.min.y, bbox.min.z, bbox.max.x, bbox.max.y, bbox.max.z));
		}

		static bool decode(const Node& node, OpenVulkano::Math::AABB& bbox)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{}),({},{},{})", bbox.min.x, bbox.min.y, bbox.min.z, bbox.max.x, bbox.max.y, bbox.max.z);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<>
	struct convert<OpenVulkano::Math::PoseF>
	{
		static Node encode(const OpenVulkano::Math::PoseF& pose)
		{
			return Node(fmt::format("({},{},{}),({},{},{},{})", pose.GetPosition().x, pose.GetPosition().y, pose.GetPosition().z, pose.GetOrientation().x, pose.GetOrientation().y, pose.GetOrientation().z, pose.GetOrientation().w));
		}

		static bool decode(const Node& node, OpenVulkano::Math::PoseF& pose)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{}),({},{},{},{})", pose.GetPosition().x, pose.GetPosition().y, pose.GetPosition().z, pose.GetOrientation().x, pose.GetOrientation().y, pose.GetOrientation().z, pose.GetOrientation().w);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Vector2<T>>
	{
		static Node encode(const OpenVulkano::Math::Vector2<T>& v)
		{
			return Node(fmt::format("({},{})", v.x, v.y));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Vector2<T>& v)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Vector3<T>>
	{
		static Node encode(const OpenVulkano::Math::Vector3<T>& v)
		{
			return Node(fmt::format("({},{},{})", v.x, v.y, v.z));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Vector3<T>& v)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Vector4<T>>
	{
		static Node encode(const OpenVulkano::Math::Vector4<T>& v)
		{
			return Node(fmt::format("({},{},{},{})", v.x, v.y, v.z, v.w));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Vector4<T>& v)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{},{})", v.x, v.y, v.z, v.w);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Vector2_SIMD<T>>
	{
		static Node encode(const OpenVulkano::Math::Vector2_SIMD<T>& v)
		{
			return Node(fmt::format("({},{})", v.x, v.y));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Vector2_SIMD<T>& v)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{})", v.x, v.y);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Vector3_SIMD<T>>
	{
		static Node encode(const OpenVulkano::Math::Vector3_SIMD<T>& v)
		{
			return Node(fmt::format("({},{},{})", v.x, v.y, v.z));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Vector3_SIMD<T>& v)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), "({},{},{})", v.x, v.y, v.z);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Matrix3<T>>
	{
		static Node encode(const OpenVulkano::Math::Matrix3<T>& mat)
		{
			return Node(fmt::format("(({},{},{}),({},{},{}),({},{},{}))", 
				mat[0][0], mat[0][1], mat[0][2],
				mat[1][0], mat[1][1], mat[1][2],
				mat[2][0], mat[2][1], mat[2][2]));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Matrix3<T>& mat)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), 
					"(({},{},{}),({},{},{}),({},{},{}))", 
					mat[0][0], mat[0][1], mat[0][2],
					mat[1][0], mat[1][1], mat[1][2],
					mat[2][0], mat[2][1], mat[2][2]);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Matrix3_SIMD<T>>
	{
		static Node encode(const OpenVulkano::Math::Matrix3_SIMD<T>& mat)
		{
			return Node(fmt::format("(({},{},{}),({},{},{}),({},{},{}))", 
				mat[0][0], mat[0][1], mat[0][2],
				mat[1][0], mat[1][1], mat[1][2],
				mat[2][0], mat[2][1], mat[2][2]));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Matrix3_SIMD<T>& mat)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), 
					"(({},{},{}),({},{},{}),({},{},{}))", 
					mat[0][0], mat[0][1], mat[0][2],
					mat[1][0], mat[1][1], mat[1][2],
					mat[2][0], mat[2][1], mat[2][2]);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};

	template<typename T>
	struct convert<OpenVulkano::Math::Matrix4<T>>
	{
		static Node encode(const OpenVulkano::Math::Matrix4<T>& mat)
		{
			return Node(fmt::format("(({},{},{},{}),({},{},{},{}),({},{},{},{}),({},{},{},{}))", 
				mat[0][0], mat[0][1], mat[0][2], mat[0][3],
				mat[1][0], mat[1][1], mat[1][2], mat[1][3],
				mat[2][0], mat[2][1], mat[2][2], mat[2][3],
				mat[3][0], mat[3][1], mat[3][2], mat[3][3]));
		}

		static bool decode(const Node& node, OpenVulkano::Math::Matrix4<T>& mat)
		{
			if (node.IsScalar())
			{
				size_t ret = c4::unformat(c4::to_csubstr(node.Scalar().c_str()), 
					"(({},{},{},{}),({},{},{},{}),({},{},{},{}),({},{},{},{}))", 
					mat[0][0], mat[0][1], mat[0][2], mat[0][3],
					mat[1][0], mat[1][1], mat[1][2], mat[1][3],
					mat[2][0], mat[2][1], mat[2][2], mat[2][3],
					mat[3][0], mat[3][1], mat[3][2], mat[3][3]);
				return ret != c4::csubstr::npos;
			}
			return false;
		}
	};
}