/*
 * 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

#if __has_include("fmt/format.h")
#include <fmt/format.h>
#elif __has_include("spdlog/fmt/fmt.h")
#include <spdlog/fmt/fmt.h>
#else
#error "Failed to find fmt include"
#endif
#include "Math/Math.hpp"
#include "Math/ByteSize.hpp"
#include "Math/DenseVector3i.hpp"
#include "Math/Float16.hpp"
#include "Math/Int24.hpp"
#include "Math/Range.hpp"
#include "Math/RGB10A2.hpp"
#include "Math/RGB565.hpp"
#include "Math/RGBA5551.hpp"
#include "Math/Timestamp.hpp"
#include "Math/UInt24.hpp"
#include "Base/UUID.hpp"
#include <filesystem>

template<> struct fmt::formatter<OpenVulkano::ByteSize>
{
	template<typename ParseContext> constexpr auto parse(ParseContext& ctx)
	{
		return ctx.begin();
	}

	template<typename FormatContext> auto format(const OpenVulkano::ByteSize& bs, FormatContext& ctx) const
	{
		return fmt::format_to(ctx.out(), "{}", bs.Format());
	}
};

template<> struct fmt::formatter<std::filesystem::path> : fmt::formatter<std::string>
{
	template<typename PATH = std::filesystem::path>
	auto format(const std::filesystem::path& path, format_context& ctx) const requires std::is_same_v<std::filesystem::path::value_type, char>
	{
		return formatter<std::string>::format(path.native(), ctx);
	}

	template<typename PATH = std::filesystem::path>
	auto format(const std::filesystem::path& path, format_context& ctx) const requires std::is_same_v<std::filesystem::path::value_type, wchar_t>
	{
		return formatter<std::string>::format(path.string(), ctx);
	}
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::vec<2, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::vec<2, T, Q>& v, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "(");
        formatter<T>::format(v.x, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.y, ctx);
        return fmt::format_to(ctx.out(), ")");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::vec<3, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::vec<3, T, Q>& v, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "(");
        formatter<T>::format(v.x, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.y, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.z, ctx);
        return fmt::format_to(ctx.out(), ")");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::vec<4, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::vec<4, T, Q>& v, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "(");
        formatter<T>::format(v.x, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.y, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.z, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(v.w, ctx);
        return fmt::format_to(ctx.out(), ")");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::mat<2, 2, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::mat<2, 2, T, Q>& m, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "[[");
        formatter<T>::format(m[0][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][0], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][1], ctx);
        return fmt::format_to(ctx.out(), "]]");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::mat<3, 3, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::mat<3, 3, T, Q>& m, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "[[");
        formatter<T>::format(m[0][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][0], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][1], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][2], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][2], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][2], ctx);
        return fmt::format_to(ctx.out(), "]]");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::mat<4, 4, T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::mat<4, 4, T, Q>& m, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "[[");
        formatter<T>::format(m[0][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][0], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[3][0], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][1], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[3][1], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][2], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][2], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][2], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[3][2], ctx);
        fmt::format_to(ctx.out(), "], [");
        formatter<T>::format(m[0][3], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[1][3], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[2][3], ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(m[3][3], ctx);
        return fmt::format_to(ctx.out(), "]]");
    }
};

template<typename T, glm::qualifier Q>
struct fmt::formatter<glm::qua<T, Q>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const glm::qua<T, Q>& q, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "(");
        formatter<T>::format(q.w, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(q.x, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(q.y, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(q.z, ctx);
        return fmt::format_to(ctx.out(), ")");
    }
};

template<typename T>
struct fmt::formatter<OpenVulkano::Math::Range<T>> : fmt::formatter<T>
{
    template<typename FormatContext>
    auto format(const OpenVulkano::Math::Range<T>& range, FormatContext& ctx) const
    {
        fmt::format_to(ctx.out(), "[");
        formatter<T>::format(range.min, ctx);
        fmt::format_to(ctx.out(), ", ");
        formatter<T>::format(range.max, ctx);
        return fmt::format_to(ctx.out(), "]");
    }
};

template<>
struct fmt::formatter<OpenVulkano::UUID> : fmt::formatter<std::string>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::UUID& uuid, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "{}", uuid.string());
    }
};

template<>
struct fmt::formatter<OpenVulkano::Math::RGB565>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::Math::RGB565& color, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "RGB565(r:{}, g:{}, b:{})", 
            color.r, color.g, color.b);
    }
};

template<>
struct fmt::formatter<OpenVulkano::Math::RGBA5551>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::Math::RGBA5551& color, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "RGBA5551(r:{}, g:{}, b:{}, a:{})", 
            color.r, color.g, color.b, color.a);
    }
};

template<typename TYPE>
struct fmt::formatter<OpenVulkano::Math::RGB10A2<TYPE>>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::Math::RGB10A2<TYPE>& color, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "RGB10A2(r:{}, g:{}, b:{}, a:{})", 
            color.r, color.g, color.b, color.a);
    }
};

template<typename T, bool REDUCE_Y_RESOLUTION, bool ASSERT_INPUT_VALUES, int BITS_PER_COMPONENT>
struct fmt::formatter<OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::Math::DenseVector3i<T, REDUCE_Y_RESOLUTION, ASSERT_INPUT_VALUES, BITS_PER_COMPONENT>& vec, 
                FormatContext& ctx) const
    {
		return fmt::format_to(ctx.out(), "DenseVector3i({}, {}, {})", vec.X(), vec.Y(), vec.Z());
	}
};

template<>
struct fmt::formatter<OpenVulkano::Math::Timestamp>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const OpenVulkano::Math::Timestamp& ts, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "{}ns", ts.GetNanos());
    }
};

template<>
struct fmt::formatter<UNDERLYING_FLOAT16_TYPE> : fmt::formatter<float>
{
    template<typename FormatContext>
    auto format(const UNDERLYING_FLOAT16_TYPE& f, FormatContext& ctx) const
    {
        return fmt::formatter<float>::format(static_cast<float>(f), ctx);
    }
};

template<>
struct fmt::formatter<OpenVulkano::int24> : fmt::formatter<int32_t>
{
    template<typename FormatContext>
    auto format(const OpenVulkano::int24& i, FormatContext& ctx) const
    {
        return fmt::formatter<int32_t>::format(static_cast<int32_t>(i), ctx);
    }
};

template<>
struct fmt::formatter<OpenVulkano::uint24> : fmt::formatter<int32_t>
{
    template<typename FormatContext>
    auto format(const OpenVulkano::uint24& i, FormatContext& ctx) const
    {
        return fmt::formatter<int32_t>::format(static_cast<int>(i), ctx);
    }
};