#include <boost/config.hpp>
#include <boost/charconv.hpp>
#include <boost/cstdfloat.hpp>
#include <boost/core/type_name.hpp>

#include <system_error>
#include <string_view>
#include <charconv>
#include <stdfloat>
#include <iostream>
#include <string>
#include <array>



namespace std
{
inline to_chars_result		to_chars(char* first, char* last, boost::float128_type value, chars_format format, int precision)	noexcept
{
	return to_chars(first, last, float128_t(value), format, precision);
}

inline to_chars_result		to_chars(char* first, char* last, boost::float128_type value, chars_format format)	noexcept
{
	return to_chars(first, last, float128_t(value), format);

}

inline to_chars_result		to_chars(char* first, char* last, boost::float128_type value)	noexcept
{
	return to_chars(first, last, float128_t(value));
}

}	//	std



namespace test
{
enum class library
{
	boost, std
};

constexpr std::string_view	format_string(const std::chars_format format)	noexcept
{
	switch (format)
	{
		case std::chars_format::scientific:	return "scientific";
		case std::chars_format::fixed:		return "fixed";
		case std::chars_format::hex:		return "hex";
		default:							return "general";
	}
}

template <library Lib, size_t ArraySize, size_t ResultSize>
struct to_chars_test
{
	static_assert(ArraySize > ResultSize);
	using buffer_type = std::array<char, ArraySize>;

	buffer_type				buffer;
	std::to_chars_result	result;


	inline static constexpr boost::charconv::chars_format	cvt_format(const std::chars_format format)	noexcept
	{
		switch (format)
		{
			case std::chars_format::scientific:	return boost::charconv::chars_format::scientific;
			case std::chars_format::fixed:		return boost::charconv::chars_format::fixed;
			case std::chars_format::hex:		return boost::charconv::chars_format::hex;
			default:							return boost::charconv::chars_format::general;
		}
	}

	inline static constexpr std::to_chars_result	cvt_result(const boost::charconv::to_chars_result& result)	noexcept
	{
		return {result.ptr, result.ec};
	}

	inline constexpr auto	begin()	const noexcept	{ return buffer.data();				}
	inline constexpr auto	end()	const noexcept	{ return buffer.data()+ResultSize;	}

	inline constexpr auto	begin()	noexcept	{ return buffer.data();				}
	inline constexpr auto	end()	noexcept	{ return buffer.data()+ResultSize;	}

	inline std::string	dump_string(const size_t size)	const
	{
		auto is_float_char = [](const char value) constexpr noexcept -> bool
		{
			return
				(value=='+' || value=='-' || value=='.') ? true :
				(value>='0' && value<='9') ? true :
				(value>='a' && value<='f') ? true :
				false;
		};

		std::string
			result{};

		result.reserve(ResultSize);
		for (size_t i=0; i<size; ++i)
		{
			const char
				c = buffer[i];

			result += is_float_char(c) ? c : '#';
		}
		return result;
	}

	constexpr ptrdiff_t	size_result()	const
	{
		return (result.ec == std::errc{}) ? result.ptr - begin() : 0;
	}

	constexpr ptrdiff_t	size_written()	const
	{
		size_t
			result{};

		for (; result<ArraySize && buffer[result]!=char{}; ++result);
		return ptrdiff_t(result);
	}

	constexpr bool	is_buffer_overflow()	const
	{
		if (result.ec == std::errc{})	return !(size_written() == size_result());
		else							return !(size_written() == 0 && result.ptr == end());
	}

	void	reset()
	{
		buffer.fill(0);
		result = std::to_chars_result{nullptr, std::errc(-1)};
	}

	template <typename Type>
	void	to_chars(const Type value, const std::chars_format format, const int precision)
	{
		reset();
		if constexpr (Lib == library::boost)
			result = cvt_result(boost::charconv::to_chars(begin(), end(), value, cvt_format(format), precision));
		else
			result = std::to_chars(begin(), end(), value, format, precision);
	}

	template <typename Type>
	void	to_chars(const Type value, const std::chars_format format)
	{
		reset();
		if constexpr (Lib == library::boost)
			result = cvt_result(boost::charconv::to_chars(begin(), end(), value, cvt_format(format)));
		else
			result = std::to_chars(begin(), end(), value, format);
	}

	template <typename Type>
	void	to_chars(const Type value)
	{
		reset();
		if constexpr (Lib == library::boost)
			result = cvt_result(boost::charconv::to_chars(begin(), end(), value));
		else
			result = std::to_chars(begin(), end(), value);
	}

	template <library L>
	constexpr bool	operator==(const to_chars_test<L, ArraySize, ResultSize>& other)	const noexcept
	{
		return result.ec==other.result.ec && buffer==other.buffer;
	}

	template <typename Char, typename Traits>
	friend std::basic_ostream<Char, Traits>&	operator<<(std::basic_ostream<Char, Traits>& stream, const to_chars_test& test)
	{
		auto out_buffer_overflow = [&]()
		{
			stream << "buffer_overflow:" << test.is_buffer_overflow() << '\t';
		};

		auto out_error = [&]()
		{
			stream << int(test.result.ec) << ':' << std::make_error_code(test.result.ec).message() << '\t';
		};

		auto out_result = [&](const size_t size)
		{
			stream << size << ':' << test.dump_string(size).c_str() << '\t';
		};

		stream << ((Lib == library::boost) ? "boost\t" : "std\t");
		out_buffer_overflow();
		out_error();
		out_result(test.size_result());
		out_result(test.size_written());
		return stream;
	}
};

template <size_t ArraySize, size_t ResultSize, typename Type>
void	show(const Type value, const std::chars_format format, const int precision)
{
	using B = to_chars_test<library::boost, ArraySize, ResultSize>;
	using S = to_chars_test<library::std, ArraySize, ResultSize>;

	B	b;
	S	s;

	b.to_chars(value, format, precision);
	s.to_chars(value, format, precision);
	std::cout << boost::core::type_name<Type>() << ':' << format_string(format) << ':' << precision << " -> " << (b==s) << '\n';
	std::cout << b << '\n';
	std::cout << s << '\n';
	std::cout << "\n\n";
}

template <size_t ArraySize, size_t ResultSize, typename Type>
void	show(const Type value, const std::chars_format format)
{
	using B = to_chars_test<library::boost, ArraySize, ResultSize>;
	using S = to_chars_test<library::std, ArraySize, ResultSize>;

	B	b;
	S	s;

	b.to_chars(value, format);
	s.to_chars(value, format);
	std::cout << boost::core::type_name<Type>() << ':' << format_string(format) << " -> " << (b==s) << '\n';
	std::cout << b << '\n';
	std::cout << s << '\n';
	std::cout << "\n\n";
}

template <size_t ArraySize, size_t ResultSize, typename Type>
void	show(const Type value)
{
	using B = to_chars_test<library::boost, ArraySize, ResultSize>;
	using S = to_chars_test<library::std, ArraySize, ResultSize>;

	B	b;
	S	s;

	b.to_chars(value);
	s.to_chars(value);
	std::cout << boost::core::type_name<Type>() << " -> " << (b==s) << '\n';
	std::cout << b << '\n';
	std::cout << s << '\n';
	std::cout << "\n\n";
}

}	//	test



int main()
{
	constexpr std::chars_format	format		= std::chars_format::fixed;
	constexpr std::float128_t	value		= 3331.519894481067353f128;
	constexpr int				precision	= 17;
	constexpr size_t			array_size	= 8192;
	constexpr size_t			result_size	= 1024;

	std::cout << std::boolalpha;

	test::show<array_size, result_size>(value, format, precision);
	test::show<array_size, result_size>(boost::float128_t(value), format, precision);
	test::show<array_size, result_size>(boost::float80_t(value), format, precision);
	test::show<array_size, result_size>(boost::float64_t(value), format, precision);
	test::show<array_size, result_size>(boost::float32_t(value), format, precision);
	test::show<array_size, result_size>(std::float16_t(value), format, precision);
	test::show<array_size, result_size>(std::bfloat16_t(value), format, precision);

	test::show<array_size, result_size>(value, format);
	test::show<array_size, result_size>(boost::float128_t(value), format);
	test::show<array_size, result_size>(boost::float80_t(value), format);
	test::show<array_size, result_size>(boost::float64_t(value), format);
	test::show<array_size, result_size>(boost::float32_t(value), format);
	test::show<array_size, result_size>(std::float16_t(value), format);
	test::show<array_size, result_size>(std::bfloat16_t(value), format);

	test::show<array_size, result_size>(value);
	test::show<array_size, result_size>(boost::float128_t(value));
	test::show<array_size, result_size>(boost::float80_t(value));
	test::show<array_size, result_size>(boost::float64_t(value));
	test::show<array_size, result_size>(boost::float32_t(value));
	test::show<array_size, result_size>(std::float16_t(value));
	test::show<array_size, result_size>(std::bfloat16_t(value));

	return EXIT_SUCCESS;
}