/*
Copyright 2019 Mittendrein Markus

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#pragma once
#include <string>
#include <string_view>
#include <optional>
#include <cstring>
#include <stdexcept>
#include <cstdint>

namespace format {

using FormatException = std::invalid_argument;

template<typename To, typename From, typename Enable = void>
struct FormatConvert {};

template<typename From>
struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_signed_v<From> && std::is_integral_v<From>>>
{
	static constexpr std::intmax_t convert(From from)
	{
		return from;
	}
};

template<typename From>
struct FormatConvert<std::intmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From> && (sizeof(From) < sizeof(std::intmax_t))>>
{
	static constexpr std::intmax_t convert(From from)
	{
		return from;
	}
};

template<typename From>
struct FormatConvert<std::uintmax_t, From, std::enable_if_t<std::is_unsigned_v<From> && std::is_integral_v<From>>>
{
	static constexpr std::uintmax_t convert(From from)
	{
		return from;
	}
};

template<typename String>
struct FormatConvert<std::string_view, String, std::enable_if_t<std::is_convertible_v<String, std::string_view>>>
{
	static constexpr std::string_view convert(const String &str)
	{
		return str;
	}
};

template<typename From>
struct FormatConvert<double, From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>>
{
	static constexpr double convert(const From& val)
	{
		return val;
	}
};

template<typename Pointer>
struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && !std::is_array_v<std::remove_pointer_t<Pointer>> && !std::is_same_v<std::remove_pointer_t<Pointer>, char>>>
{
	static constexpr const void *convert(const Pointer* pointer)
	{
		return pointer;
	}
};

template<typename Pointer>
struct FormatConvert<const void *, Pointer, std::enable_if_t<std::is_pointer_v<Pointer> && std::is_array_v<std::remove_pointer_t<Pointer>>>>
{
	static constexpr const void *convert(const Pointer pointer)
	{
		return pointer;
	}
};

template<typename From, typename Enable = void>
struct AutoConversion
{
	static std::string conversion(const From &)
	{
		throw FormatException{""};
	}
};

template<typename From>
struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_unsigned_v<From>>>
{
	static std::string conversion(const From &)
	{
		return "u";
	}
};

template<typename From>
struct AutoConversion<From, std::enable_if_t<std::is_integral_v<From> && std::is_signed_v<From>>>
{
	static std::string conversion(const From &)
	{
		return "d";
	}
};

template<typename From>
struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, double> && !std::is_integral_v<From>>>
{
	static std::string conversion(const From &)
	{
		return "G";
	}
};

template<typename From>
struct AutoConversion<From, std::enable_if_t<std::is_convertible_v<From, std::string_view>>>
{
	static std::string conversion(const From &)
	{
		return "s";
	}
};

template<>
struct AutoConversion<char>
{
	static std::string conversion(const char)
	{
		return "c";
	}
};

namespace detail
{
	template<typename T>
	struct remove_cvref { using type = std::remove_cv_t<std::remove_reference_t<T>>; };

	template<typename T>
	using remove_cvref_t = typename remove_cvref<T>::type;

	template<typename T, bool Ok = false>
	struct StointHelper
	{
		static T convert(const std::string &, std::size_t *, int)
		{
			static_assert(Ok, "stoint: Unsupported type");
			return T{};
		}
	};

	template<typename T, T(converter)(const std::string &, std::size_t *, int)>
	struct StointHelperConverter
	{
		static T convert(const std::string &str, std::size_t *pos, int base)
		{
			return converter(str, pos, base);
		}
	};

	template<>
	struct StointHelper<int> : StointHelperConverter<int, std::stoi> {};
	template<>
	struct StointHelper<long> : StointHelperConverter<long, std::stol> {};
	template<>
	struct StointHelper<long long> : StointHelperConverter<long long, std::stoll> {};
	template<>
	struct StointHelper<unsigned long> : StointHelperConverter<unsigned long, std::stoul> {};
	template<>
	struct StointHelper<unsigned long long> : StointHelperConverter<unsigned long long, std::stoull> {};

	template<typename T>
	T stoint(const std::string &str, std::size_t *pos = nullptr, int base = 10)
	{
		return StointHelper<T>::convert(str, pos, base);
	}

	template<typename... Args>
	std::string strprintf(const char *fmt, Args... args)
	{
		int size = std::snprintf(nullptr, 0, fmt, args...) + 1;
		std::string result;
		result.resize(size);
		std::snprintf(result.data(), size, fmt, args...);
		result.resize(size - 1);
		return result;
	}

	template<typename To, typename From, bool allowFallback, typename Enable = void>
	struct FormatConvertHelper
	{
		static constexpr To convert(const From &)
		{
			static_assert(allowFallback, "Impossible conversion needed");
			throw FormatException{""};
		}
	};

	template<typename T, bool allowFallback>
	struct FormatConvertHelper<T, T, allowFallback>
	{
		static constexpr const T &convert(const T &from)
		{
			return from;
		}
	};

	template<typename To, typename From, bool allowFallback>
	struct FormatConvertHelper<To, From, allowFallback, std::enable_if_t<!std::is_same_v<To, From> && std::is_same_v<remove_cvref_t<decltype(FormatConvert<To, remove_cvref_t<From>>::convert(std::declval<From>()))>, remove_cvref_t<To>>>>
	{
		static constexpr To convert(const From &from)
		{
			return FormatConvert<To, remove_cvref_t<From>>::convert(from);
		}
	};

	template<typename To, bool allowFallback = true, typename From>
	auto convert(const From &from, const char *toName, std::size_t index = 0)
	{
		try
		{
			return FormatConvertHelper<To, From, allowFallback>::convert(from);
		}
		catch (const FormatException &)
		{
			throw FormatException{"Argument#" + std::to_string(index) + " is not convertible to " + std::string{toName}};
		}
	}

	template<typename From, typename Enable = void>
	struct StringOrStringViewHelper
	{
		using type = std::string_view;
	};

	template<typename From>
	struct StringOrStringViewHelper<From, std::enable_if_t<std::is_same_v<std::string, std::decay_t<decltype(FormatConvert<std::string, From>::convert(std::declval<From>()))>>>>
	{
		using type = std::string;
	};

	template<typename From>
	using string_or_string_view = typename StringOrStringViewHelper<From>::type;

	template<bool allowPointer = false, typename From>
	std::string autoConversionSpecifier(From &&from, std::size_t index = 0)
	{
		try
		{
			return AutoConversion<remove_cvref_t<From>>::conversion(std::forward<From>(from));
		}
		catch (const FormatException &)
		{
			if constexpr (std::is_pointer_v<From>)
			{
				if constexpr (allowPointer)
				{
					return "p";
				}
				else
				{
					throw FormatException{"Argument#" + std::to_string(index) + " is not applicable for auto conversion with %v, use %V to also allow arbitrary pointers"};
				}
			}
			throw FormatException{"Argument#" + std::to_string(index) + " is not applicable for auto conversion (%v / %V)"};
		}
	}

	std::string format(std::string_view fmt, const std::size_t argumentIndex)
	{
		const auto fmtSize = fmt.size();
		for (std::size_t i = 0; i < fmtSize; ++i)
		{
			if (fmt[i] == '%')
			{
				if (i >= fmtSize - 1)
				{
					throw FormatException{"Incomplete directive"};
				}

				if (fmt[++i] == '%')
				{
					return std::string{fmt.substr(0, i)} + format(fmt.substr(i + 1), argumentIndex);
				}

				throw FormatException{"Not enough arguments passed"};
			}
		}
		return std::string{fmt};
	}

	template<typename Arg, typename... Args>
	std::string format(std::string_view fmt, const std::size_t argumentIndex, Arg &&arg, Args &&... args)
	{
		const auto fmtSize = fmt.size();
		for (std::size_t i = 0; i < fmtSize; ++i)
		{
			auto checkFmtLength = [i, fmtSize]
			{
				if (i >= fmtSize - 1)
				{
					throw FormatException{"Incomplete directive"};
				}
			};
			const auto current = fmt[i];
			if (current == '%')
			{
				const auto directiveStart = i;
				checkFmtLength();
				std::string specification{"%"};

				const auto flag = fmt[++i];
				if (flag == '%') // handle %% here
				{
					return std::string{fmt.substr(0, directiveStart + 1)} + format(fmt.substr(i + 1), argumentIndex, std::forward<Arg>(arg), std::forward<Args>(args)...);
				}
				switch (flag)
				{
					case '#': case '0': case '-': case ' ': case '+':
						specification.push_back(flag);
						checkFmtLength();
						break;
					default:
						--i;
				}

				std::string tempNumber;
				// field width
				while (std::isdigit(fmt[++i]))
				{
					tempNumber.push_back(fmt[i]);
					checkFmtLength();
				}
				--i;
				const auto fieldWidth = tempNumber.empty() ? 0 : stoint<std::size_t>(tempNumber);
				tempNumber.clear();

				std::optional<std::size_t> precision;
				// precision
				if (fmt[++i] == '.')
				{
					checkFmtLength();
					while (std::isdigit(fmt[++i]))
					{
						tempNumber.push_back(fmt[i]);
						checkFmtLength();
					}
					precision = tempNumber.empty() ? 0 : stoint<std::size_t>(tempNumber);
				}
				--i;

				std::string conversion{fmt[++i]};
				if(conversion.front() == 'v')
				{
					conversion = autoConversionSpecifier(std::forward<Arg>(arg), argumentIndex);
				}
				else if(conversion.front() == 'V')
				{
					conversion = autoConversionSpecifier<true>(std::forward<Arg>(arg), argumentIndex);
				}

				auto continueFormatting = [directiveStart, &args..., fmt, &specification, &fieldWidth, &precision, i, conversion, argumentIndex](auto length, auto converted)
				{
					if (fieldWidth) specification += std::to_string(fieldWidth);
					if (precision) specification += '.' + std::to_string(*precision);
					if (length) specification += length;
					specification += conversion;
					return std::string{fmt.substr(0, directiveStart)} + strprintf(specification.c_str(), converted) + format(fmt.substr(i + 1), argumentIndex + 1, std::forward<Args>(args)...);
				};

				switch (conversion.back())
				{
					case 'c':
						return continueFormatting(false, convert<char>(std::forward<Arg>(arg), "character", argumentIndex));

					case 'd': case 'i':
						return continueFormatting('j', convert<std::intmax_t>(std::forward<Arg>(arg), "signed integer", argumentIndex));

					case 'u': case 'o': case 'x': case 'X':
						return continueFormatting('j', convert<std::uintmax_t>(std::forward<Arg>(arg), "unsigned integer", argumentIndex));

					case 's':
					{
						const auto& string = convert<string_or_string_view<remove_cvref_t<Arg>>>(std::forward<Arg>(arg), "string", argumentIndex);
						precision = precision ? std::min(*precision, string.size()) : string.size();
						return continueFormatting(false, string.data());
					}

					case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A':
						return continueFormatting(false, convert<double>(std::forward<Arg>(arg), "double", argumentIndex));

					case 'p':
						return continueFormatting(false, convert<const void *>(std::forward<Arg>(arg), "pointer", argumentIndex));

					default:
						throw FormatException{std::string{"Unknown conversion specifier: \""} + conversion + "\""};
				}
			}
		}

		throw FormatException{std::to_string(argumentIndex - 1) + " placeholders found, but " + std::to_string(argumentIndex + sizeof...(args)) + " arguments passed"};
	}
}

template<bool NoThrow = false, typename String, typename... Args>
std::string format(const String &fmt, Args &&... args)
{
	const auto fmtStr = detail::convert<std::string_view, false>(fmt, "string");
	try
	{
		return detail::format(fmtStr, 1, std::forward<Args>(args)...);
	}
	catch (const FormatException &e)
	{
		const auto &message = std::string{"format(\""} + std::string{fmtStr} + "\", " + std::to_string(sizeof...(args)) + " more arguments...): " + e.what();

		if constexpr (NoThrow) return message;
		else throw FormatException(message);
	}
}

}