#pragma once

// NOTE: This file is not intended to be included directly, it is included by 'String/String.h'.

#include "Templates/Tuple.h"
#include "Templates/Utility.h"
#include "TypeTraits/TypeTraits.h"

#include <cmath>
#include <limits>
#include <charconv>

#pragma warning(push)
#pragma warning(disable : 4146 4244)

NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)

// The conversion tool uses a string to describe the object format.

// NOTE: These functions are used to format an object to a string and parse a string to an object.
// If the user-defined overloads a function with the 'Fmt' parameter, fill-and-align needs to be handled.
// The formatting function should produce a string that can be parsed by the parsing function, if the parsing function exists.

// NOTE: These functions are recommended for debug programs.

NAMESPACE_PRIVATE_BEGIN

// In private, conversion tools use structured parameters to describe the object format.
// The structured parameter is an object with specific public members:
//
// - DigitStyle:  A signed integer that represents the letter case of the first part or the digit part.
//	              Less than 0 for lowercase, greater than 0 for uppercase, 0 for default or any in parsing.
//	              It is valid for boolean, integer and floating-point values.
//
// - OtherStyle:  A signed integer that represents the letter case of the other part.
//	              Less than 0 for lowercase, greater than 0 for uppercase, 0 for default or any in parsing.
//	              It is valid for boolean, integer and floating-point values.
//
// - bSign:       A boolean that represents whether to show the sign of the number if it is positive.
//	              It is valid for integer and floating-point values.
//
// - bPrefix:     A boolean that represents whether to show the prefix of the number.
//	              Legal only when base is binary octal decimal and hexadecimal
//	              For parsing, together with the following parameters, it also determines whether to automatically detect the base.
//	              It is valid for integer and floating-point values.
//
// - Base:        A unsigned integer that represents the base of the number, between [2, 36].
//	              However, when parsed and prefixed, 0 is allowed to indicate auto-detection.
//	              It is valid for integer values.
//
// - bFixed:      A boolean that represents whether to use the decimal fixed-point format.
// - bScientific: A boolean that represents whether to use the decimal scientific format.
//	              These two parameters together determine the format of the floating-point value.
//	              When both are false, represents the hex scientific is format.
//	              However, when parsed and prefixed, any values allows auto-detection hex scientific format.
//	              It is valid for floating-point values.
//
// - Precision:   A unsigned integer that represents the number of digits after the decimal point.
//	              For parsing, it is used to determine the maximum number of digits after the decimal point.
//	              It is valid for floating-point values.

template <CCharType T>
struct TStringObjectFormatter
{
	static FORCEINLINE bool Do(auto& Result, auto& Object, auto Param)
	{
		using U = TRemoveCVRef<decltype(Object)>;

		if constexpr (!CConst<TRemoveReference<decltype(Object)>>)
		{
			checkf(false, TEXT("Unsafe formatting for a variable that is non-const."));

			return false;
		}

		// Parse format string if parameter is TStringView, otherwise use the structured parameters directly.
		if constexpr (requires { { Param.Fmt } -> CConvertibleTo<TStringView<T>>; })
		{
			TStringView<T> Fmt = Param.Fmt;

			checkf(Fmt.IsEmpty(), TEXT("Formatted parsing of arithmetic types not implemented."));

			// Format the boolean value by format string.
			if constexpr (CSameAs<U, bool>)
			{
				return TStringObjectFormatter::Do(Result, Object, Invalid);
			}

			// Format the integer value by format string.
			else if constexpr (CIntegral<U> && !CSameAs<U, bool>)
			{
				return TStringObjectFormatter::Do(Result, Object, Invalid);
			}

			// Format the floating-point value by format string.
			else if constexpr (CFloatingPoint<U>)
			{
				return TStringObjectFormatter::Do(Result, Object, Invalid);
			}
		}
		else
		{
			// Format the boolean value by structured parameters.
			if constexpr (CSameAs<U, bool>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				if constexpr (bHasDigitStyle || bHasOtherStyle)
				{
					Result.Reserve(Result.Num() + 5);

					bool bDigitLowercase = false; if constexpr (bHasDigitStyle) bDigitLowercase = Param.DigitStyle <  0;
					bool bOtherLowercase = true;  if constexpr (bHasOtherStyle) bOtherLowercase = Param.OtherStyle <= 0;

					if (bDigitLowercase)
					{
						if (Object) Result += LITERAL(T, 't');
						else        Result += LITERAL(T, 'f');
					}
					else
					{
						if (Object) Result += LITERAL(T, 'T');
						else        Result += LITERAL(T, 'F');
					}

					if (bOtherLowercase)
					{
						if (Object) Result += LITERAL(T, "RUE");
						else        Result += LITERAL(T, "ALSE");
					}
					else
					{
						if (Object) Result += LITERAL(T, "rue");
						else        Result += LITERAL(T, "alse");
					}

					return true;
				}

				if (Object) Result += LITERAL(T, "True");
				else        Result += LITERAL(T, "False");
				return true;
			}

			// Format the integer value by structured parameters.
			else if constexpr (CIntegral<U> && !CSameAs<U, bool>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				constexpr bool bHasSign   = requires { { Param.bSign   } -> CBooleanTestable; };
				constexpr bool bHasPrefix = requires { { Param.bPrefix } -> CBooleanTestable; };
				constexpr bool bHasBase   = requires { { Param.Base    } -> CConvertibleTo<unsigned>; };

				static_assert(TChar<T>::IsASCII());

				// If the value should be formatted with prefix, the value must be binary, octal, decimal or hexadecimal.
				if constexpr (bHasPrefix && bHasBase) if (Param.bPrefix)
				{
					if (Param.Base != 2 && Param.Base != 8 && Param.Base != 10 && Param.Base != 16)
					{
						checkf(false, TEXT("Prefix is only supported for binary, octal, decimal and hexadecimal value."));

						return false;
					}
				}

				using UnsignedU = TMakeUnsigned<U>;

				UnsignedU Unsigned = static_cast<UnsignedU>(Object);

				bool bNegative = false;

				if constexpr (CSigned<U>)
				{
					if (Object < 0)
					{
						bNegative = true;

						Unsigned = static_cast<UnsignedU>(-Unsigned);
					}
				}

				constexpr size_t BufferSize = sizeof(UnsignedU) * 8 + 4;

				T Buffer[BufferSize];

				T* Iter = Buffer + BufferSize;

				// Reverse append the digits to the buffer.
				if constexpr (bHasBase)
				{
					checkf(Param.Base >= 2 && Param.Base <= 36, TEXT("Illegal base."));

					if constexpr (bHasDigitStyle)
					{
						const bool bLowercase = Param.DigitStyle < 0;

						switch (Param.Base)
						{
						case 0x02: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00001));             Unsigned >>= 1; } while (Unsigned != 0); break;
						case 0x04: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00011));             Unsigned >>= 2; } while (Unsigned != 0); break;
						case 0x08: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00111));             Unsigned >>= 3; } while (Unsigned != 0); break;
						case 0x10: do { *--Iter =   TChar<T>::FromDigit(Unsigned & 0b01111, bLowercase);  Unsigned >>= 4; } while (Unsigned != 0); break;
						case 0X20: do { *--Iter =   TChar<T>::FromDigit(Unsigned & 0b11111, bLowercase);  Unsigned >>= 5; } while (Unsigned != 0); break;

						case 3:
						case 5:
						case 6:
						case 7:
						case 9:
						case 10: do { *--Iter = static_cast<T>('0' + Unsigned % Param.Base);             Unsigned = static_cast<UnsignedU>(Unsigned / Param.Base); } while (Unsigned != 0); break;
						default: do { *--Iter =  TChar<T>::FromDigit(Unsigned % Param.Base, bLowercase); Unsigned = static_cast<UnsignedU>(Unsigned / Param.Base); } while (Unsigned != 0); break;
						}
					}
					else
					{
						switch (Param.Base)
						{
						case 0x02: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00001)); Unsigned >>= 1; } while (Unsigned != 0); break;
						case 0x04: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00011)); Unsigned >>= 2; } while (Unsigned != 0); break;
						case 0x08: do { *--Iter = static_cast<T>('0' + (Unsigned & 0b00111)); Unsigned >>= 3; } while (Unsigned != 0); break;
						case 0x10: do { *--Iter =   TChar<T>::FromDigit(Unsigned & 0b01111);  Unsigned >>= 4; } while (Unsigned != 0); break;
						case 0X20: do { *--Iter =   TChar<T>::FromDigit(Unsigned & 0b11111);  Unsigned >>= 5; } while (Unsigned != 0); break;

						case 3:
						case 5:
						case 6:
						case 7:
						case 9:
						case 10: do { *--Iter = static_cast<T>('0' + Unsigned % Param.Base); Unsigned = static_cast<UnsignedU>(Unsigned / Param.Base); } while (Unsigned != 0); break;
						default: do { *--Iter =  TChar<T>::FromDigit(Unsigned % Param.Base); Unsigned = static_cast<UnsignedU>(Unsigned / Param.Base); } while (Unsigned != 0); break;
						}
					}
				}
				else do { *--Iter = static_cast<T>('0' + Unsigned % 10); Unsigned = static_cast<UnsignedU>(Unsigned / 10); } while (Unsigned != 0);

				// Append the prefix to the buffer.
				if constexpr (bHasPrefix && bHasBase) if (Param.bPrefix && Param.Base != 10)
				{
					bool bOtherLowercase = true; if constexpr (bHasOtherStyle) bOtherLowercase = Param.OtherStyle <= 0;

					const T PrefixBin = bOtherLowercase ? LITERAL(T, 'b') : LITERAL(T, 'B');
					const T PrefixHex = bOtherLowercase ? LITERAL(T, 'x') : LITERAL(T, 'X');

					if (Param.Base ==  2) { *--Iter = PrefixBin; *--Iter = LITERAL(T, '0'); }
					if (Param.Base ==  8) { if (Object != 0)     *--Iter = LITERAL(T, '0'); }
					if (Param.Base == 16) { *--Iter = PrefixHex; *--Iter = LITERAL(T, '0'); }
				}

				// Append the negative sign to the buffer.
				if constexpr (CSigned<U>) if (bNegative) *--Iter = LITERAL(T, '-');

				// Append the positive sign to the buffer.
				if constexpr (bHasSign) if (!bNegative && Param.bSign) *--Iter = LITERAL(T, '+');

				Result.Append(Iter, Buffer + BufferSize);

				return true;
			}

			// Format the floating-point value by structured parameters.
			else if constexpr (CFloatingPoint<U>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				constexpr bool bHasSign      = requires { { Param.bSign     } -> CBooleanTestable; };
				constexpr bool bHasPrefix    = requires { { Param.bPrefix   } -> CBooleanTestable; };
				constexpr bool bHasPrecision = requires { { Param.Precision } -> CConvertibleTo<unsigned>; };

				constexpr bool bHasFormat =
					requires
					{
						{ Param.bFixed      } -> CBooleanTestable;
						{ Param.bScientific } -> CBooleanTestable;
					};

				NAMESPACE_STD::chars_format Format = NAMESPACE_STD::chars_format::general;

				if constexpr (bHasFormat) if ( Param.bFixed && !Param.bScientific) Format = NAMESPACE_STD::chars_format::fixed;
				if constexpr (bHasFormat) if (!Param.bFixed &&  Param.bScientific) Format = NAMESPACE_STD::chars_format::scientific;
				if constexpr (bHasFormat) if (!Param.bFixed && !Param.bScientific) Format = NAMESPACE_STD::chars_format::hex;

				constexpr size_t StartingBufferSize = 64;

				// Create a buffer with a starting size.
				TArray<char, TInlineAllocator<StartingBufferSize>> Buffer(StartingBufferSize / 2);

				// Formatting strings using the standard library until successful
				NAMESPACE_STD::to_chars_result ConvertResult;

				do
				{
					Buffer.SetNum(Buffer.Num() * 2);

					if      constexpr (bHasPrecision) ConvertResult = NAMESPACE_STD::to_chars(ToAddress(Buffer.Begin()), ToAddress(Buffer.End()), Object, Format, Param.Precision);
					else if constexpr (bHasFormat)    ConvertResult = NAMESPACE_STD::to_chars(ToAddress(Buffer.Begin()), ToAddress(Buffer.End()), Object, Format);
					else                              ConvertResult = NAMESPACE_STD::to_chars(ToAddress(Buffer.Begin()), ToAddress(Buffer.End()), Object);
				}
				while (ConvertResult.ec == NAMESPACE_STD::errc::value_too_large);

				// Set the buffer size to the number of characters written.
				Buffer.SetNum(ConvertResult.ptr - Buffer.GetData());

				const bool bNegative = Buffer[0] == '-';

				const char* Iter = Buffer.GetData() + (bNegative ? 1 : 0);

				bool bDigitLowercase = false; if constexpr (bHasDigitStyle) bDigitLowercase = Param.DigitStyle <  0;
				bool bOtherLowercase = true;  if constexpr (bHasOtherStyle) bOtherLowercase = Param.OtherStyle <= 0;

				// Handle the infinity values.
				if (*Iter == 'i')
				{
					Result.Reserve(Result.Num() + 9);

					if (bNegative) Result.Append(LITERAL(T, "-"));

					// Append the positive sign to the buffer.
					else if constexpr (bHasSign) if (Param.bSign) Result.Append(LITERAL(T, "+"));

					if constexpr (bHasDigitStyle || bHasOtherStyle)
					{
						if (bDigitLowercase) Result += LITERAL(T, 'i');
						else                 Result += LITERAL(T, 'I');

						if (bOtherLowercase) Result += LITERAL(T, "nfinity");
						else                 Result += LITERAL(T, "NFINITY");

						return true;
					}

					Result += LITERAL(T, "Infinity");
					return true;
				}

				// Handle the NaN values.
				if (*Iter == 'n')
				{
					Result.Reserve(Result.Num() + 4);

					if (bNegative) Result.Append(LITERAL(T, "-"));

					// Append the positive sign to the buffer.
					else if constexpr (bHasSign) if (Param.bSign) Result.Append(LITERAL(T, "+"));

					if constexpr (bHasDigitStyle || bHasOtherStyle)
					{
						if (bDigitLowercase) Result += LITERAL(T, 'n');
						else                 Result += LITERAL(T, 'N');

						if (bOtherLowercase) Result += LITERAL(T, "a");
						else                 Result += LITERAL(T, "A");

						if (bDigitLowercase) Result += LITERAL(T, 'n');
						else                 Result += LITERAL(T, 'N');

						return true;
					}

					Result += LITERAL(T, "NaN");
					return true;
				}

				Result.Reserve(Result.Num() + Buffer.Num() + 4);

				// Append the positive sign to the buffer.
				if constexpr (bHasSign) if (!bNegative && Param.bSign) Result.Append(LITERAL(T, "+"));

				// Handle the prefix.
				if constexpr (bHasPrefix) if (Param.bPrefix)
				{
					if (Format == NAMESPACE_STD::chars_format::hex)
					{
						if (bOtherLowercase) Result += LITERAL(T, "0x");
						else                 Result += LITERAL(T, "0X");
					}
				}

				// Handle the lowercase or uppercase characters.
				if constexpr (bHasFormat || bHasDigitStyle || bHasOtherStyle)
				{
					const unsigned Base = Format == NAMESPACE_STD::chars_format::hex ? 16 : 10;

					if (Base == 16 && !bDigitLowercase)
					{
						for (char& Char : Buffer) if (FChar::ToDigit(Char) <  Base) Char = FChar::ToUpper(Char);
					}

					if (!bOtherLowercase)
					{
						for (char& Char : Buffer) if (FChar::ToDigit(Char) >= Base) Char = FChar::ToUpper(Char);
					}
				}

				Result.Append(Buffer.Begin(), Buffer.End());

				return true;
			}
		}

		return false;
	}
};

template <CCharType T>
struct TStringObjectParser
{
	static FORCEINLINE bool Do(auto& View, auto& Object, auto Param)
	{
		using U = TRemoveCVRef<decltype(Object)>;

		if constexpr (CConst<TRemoveReference<decltype(Object)>>)
		{
			checkf(false, TEXT("Cannot assign to a variable that is const."));

			return false;
		}

		if (View.IsEmpty()) return false;

		// Parse format string if parameter is TStringView, otherwise use the structured parameters directly.
		if constexpr (requires { { Param.Fmt } -> CConvertibleTo<TStringView<T>>; })
		{
			TStringView<T> Fmt = Param.Fmt;

			checkf(Fmt.IsEmpty(), TEXT("Formatted parsing of arithmetic types not implemented."));

			View.TrimStart();

			// Format the boolean value by format string.
			if constexpr (CSameAs<U, bool>)
			{
				return TStringObjectParser::Do(View, Object, Invalid);
			}

			// Format the integer value by format string.
			else if constexpr (CIntegral<U> && !CSameAs<U, bool>)
			{
				return TStringObjectParser::Do(View, Object, Invalid);
			}

			// Format the floating-point value by format string.
			else if constexpr (CFloatingPoint<U>)
			{
				return TStringObjectParser::Do(View, Object, Invalid);
			}
		}
		else
		{
			// Parse the boolean value by structured parameters.
			if constexpr (CSameAs<U, bool>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				if (View.Num() < 4) return false;

				if constexpr (bHasDigitStyle || bHasOtherStyle)
				{
					TOptional<bool> Result;

					signed DigitStyle = 0; if constexpr (bHasDigitStyle) DigitStyle = Param.DigitStyle;
					signed OtherStyle = 0; if constexpr (bHasOtherStyle) OtherStyle = Param.OtherStyle;

					if (DigitStyle <= 0 && OtherStyle <= 0)
					{
						if (View.StartsWith(LITERAL(T, "true")))  Result = true;
						if (View.StartsWith(LITERAL(T, "false"))) Result = false;
					}

					if (DigitStyle >= 0 && OtherStyle <= 0)
					{
						if (View.StartsWith(LITERAL(T, "True")))  Result = true;
						if (View.StartsWith(LITERAL(T, "False"))) Result = false;
					}

					if (DigitStyle <= 0 && OtherStyle >= 0)
					{
						if (View.StartsWith(LITERAL(T, "tRUE")))  Result = true;
						if (View.StartsWith(LITERAL(T, "fALSE"))) Result = false;
					}

					if (DigitStyle >= 0 && OtherStyle >= 0)
					{
						if (View.StartsWith(LITERAL(T, "TRUE")))  Result = true;
						if (View.StartsWith(LITERAL(T, "FALSE"))) Result = false;
					}

					if (Result.IsValid())
					{
						View.RemovePrefix(*Result == true ? 4 : 5);
						Object = *Result;
						return true;
					}

					return false;
				}

				if    (View.StartsWith(LITERAL(T, "true"))
					|| View.StartsWith(LITERAL(T, "True"))
					|| View.StartsWith(LITERAL(T, "tRUE"))
					|| View.StartsWith(LITERAL(T, "TRUE")))
				{
					View.RemovePrefix(4);
					Object = true;
					return true;
				}

				if    (View.StartsWith(LITERAL(T, "false"))
					|| View.StartsWith(LITERAL(T, "False"))
					|| View.StartsWith(LITERAL(T, "fALSE"))
					|| View.StartsWith(LITERAL(T, "FALSE")))
				{
					View.RemovePrefix(5);
					Object = false;
					return true;
				}

				return false;
			}

			// Parse the integer value by structured parameters.
			else if constexpr (CIntegral<U> && !CSameAs<U, bool>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				constexpr bool bHasSign   = requires { { Param.bSign   } -> CBooleanTestable; };
				constexpr bool bHasPrefix = requires { { Param.bPrefix } -> CBooleanTestable; };
				constexpr bool bHasBase   = requires { { Param.Base    } -> CConvertibleTo<unsigned>; };

				static_assert(TChar<T>::IsASCII());

				// Create a temporary view to avoid modifying the original view.
				TStringView<T> TrimmedView = View;

				bool bNegative = false;

				// Handle optional negative sign.
				if constexpr (CSigned<U>)
				{
					if (TrimmedView.StartsWith(LITERAL(T, '-')))
					{
						bNegative = true;
						TrimmedView.RemovePrefix(1);
					}
				}

				// Handle optional positive sign.
				if constexpr (bHasSign) if (!bNegative && Param.bSign) if (TrimmedView.StartsWith(LITERAL(T, '+'))) TrimmedView.RemovePrefix(1);

				unsigned Base; if constexpr (bHasBase) Base = Param.Base; else Base = 10;

				// Handle optional prefix.
				if constexpr (bHasPrefix) if (Param.bPrefix)
				{
					signed OtherStyle = 0; if constexpr (bHasOtherStyle) OtherStyle = Param.OtherStyle;

					// Auto detect base.
					if (Base == 0)
					{
						if (TrimmedView.Num() >= 2 && TrimmedView.Front() == LITERAL(T, '0'))
						{
							if    ((OtherStyle <= 0 && TrimmedView[1] == LITERAL(T, 'x'))
								|| (OtherStyle >= 0 && TrimmedView[1] == LITERAL(T, 'X')))
							{
								Base = 16;
								TrimmedView.RemovePrefix(2);
							}
							else if ((OtherStyle <= 0 && TrimmedView[1] == LITERAL(T, 'b'))
								  || (OtherStyle >= 0 && TrimmedView[1] == LITERAL(T, 'B')))
							{
								Base = 2;
								TrimmedView.RemovePrefix(2);
							}
							else if (TChar<T>::IsDigit(TrimmedView.Front(), 8)) Base = 8;
						}

						if (Base == 0) Base = 10;
					}

					// Handle prefixes with known base.
					else if (Base == 2 || Base == 8 || Base == 10 || Base == 16)
					{
						bool bNeedRemove = false;

						bNeedRemove |= OtherStyle <= 0 && Base ==  2 && TrimmedView.StartsWith(LITERAL(T, "0b"));
						bNeedRemove |= OtherStyle >= 0 && Base ==  2 && TrimmedView.StartsWith(LITERAL(T, "0B"));

						bNeedRemove |= OtherStyle <= 0 && Base == 16 && TrimmedView.StartsWith(LITERAL(T, "0x"));
						bNeedRemove |= OtherStyle >= 0 && Base == 16 && TrimmedView.StartsWith(LITERAL(T, "0X"));

						if (bNeedRemove) TrimmedView.RemovePrefix(2);
					}

					// Illegal base for prefix.
					else checkf(false, TEXT("Prefix is only supported for binary, octal, decimal and hexadecimal value."));
				}

				checkf(Base >= 2 && Base <= 36, TEXT("Illegal base."));

				auto ToDigit = [=](T Char) -> unsigned
				{
					if constexpr (bHasDigitStyle) if (Param.DigitStyle != 0)
					{
						return TChar<T>::ToDigit(Char, Param.DigitStyle < 0);
					}

					return TChar<T>::ToDigit(Char);
				};

				using UnsignedU = TMakeUnsigned<U>;

				// The limit value that can be stored in an unsigned integer.
				constexpr UnsignedU UnsignedMaximum = static_cast<UnsignedU>(-1);

				// The limit value that can be stored in a signed integer.
				constexpr U SignedMaximum = static_cast<U>(UnsignedMaximum >> 1);
				constexpr U SignedMinimum =  -static_cast<U>(SignedMaximum) - 1;

				UnsignedU LastValue = 0;
				UnsignedU Unsigned  = 0;

				if (TrimmedView.IsEmpty()) return false;

				unsigned Digit;

				Digit = ToDigit(TrimmedView.Front());

				// The first character must be a digit.
				if (Digit >= Base) return false;

				TrimmedView.RemovePrefix(1);

				Unsigned = static_cast<UnsignedU>(Digit);

				while (!TrimmedView.IsEmpty())
				{
					Digit = ToDigit(TrimmedView.Front());

					if (Digit >= Base) break;

					TrimmedView.RemovePrefix(1);

					LastValue = Unsigned;

					Unsigned = static_cast<UnsignedU>(LastValue * Base + Digit);

					if (Unsigned < LastValue) return false;
				}

				View = TrimmedView;

				if constexpr (CSigned<U>)
				{
					// Handle overflow.
					if (!bNegative && Unsigned >= static_cast<UnsignedU>(SignedMaximum)) return false;
					if ( bNegative && Unsigned >= static_cast<UnsignedU>(SignedMinimum)) return false;

					// Handle negative sign.
					if (bNegative) Unsigned = static_cast<UnsignedU>(-Unsigned);
				}

				Object = static_cast<U>(Unsigned);
				return true;
			}

			// Format the floating-point value by structured parameters.
			else if constexpr (CFloatingPoint<U>)
			{
				constexpr bool bHasDigitStyle = requires { { Param.DigitStyle } -> CConvertibleTo<signed>; };
				constexpr bool bHasOtherStyle = requires { { Param.OtherStyle } -> CConvertibleTo<signed>; };

				constexpr bool bHasSign      = requires { { Param.bSign     } -> CBooleanTestable; };
				constexpr bool bHasPrefix    = requires { { Param.bPrefix   } -> CBooleanTestable; };
				constexpr bool bHasPrecision = requires { { Param.Precision } -> CConvertibleTo<unsigned>; };

				constexpr bool bHasFormat =
					requires
					{
						{ Param.bFixed      } -> CBooleanTestable;
						{ Param.bScientific } -> CBooleanTestable;
					};

				NAMESPACE_STD::chars_format Format = NAMESPACE_STD::chars_format::general;

				if constexpr (bHasFormat) if ( Param.bFixed && !Param.bScientific) Format = NAMESPACE_STD::chars_format::fixed;
				if constexpr (bHasFormat) if (!Param.bFixed &&  Param.bScientific) Format = NAMESPACE_STD::chars_format::scientific;
				if constexpr (bHasFormat) if (!Param.bFixed && !Param.bScientific) Format = NAMESPACE_STD::chars_format::hex;

				// Create a temporary view to avoid modifying the original view.
				TStringView<T> TrimmedView = View;

				bool bNegative = false;

				if (TrimmedView.StartsWith(LITERAL(T, '-')))
				{
					bNegative = true;
					TrimmedView.RemovePrefix(1);
				}
				else if constexpr (bHasSign) if (Param.bSign) if (TrimmedView.StartsWith(LITERAL(T, '+'))) TrimmedView.RemovePrefix(1);

				signed DigitStyle = 0; if constexpr (bHasDigitStyle) DigitStyle = Param.DigitStyle;
				signed OtherStyle = 0; if constexpr (bHasOtherStyle) OtherStyle = Param.OtherStyle;

				// Handle the infinity and NaN values.
				{
					const U Infinity = bNegative ? -std::numeric_limits<U>::infinity()  : std::numeric_limits<U>::infinity();
					const U NaN      = bNegative ? -std::numeric_limits<U>::quiet_NaN() : std::numeric_limits<U>::quiet_NaN();

					if constexpr (bHasDigitStyle || bHasOtherStyle)
					{
						TOptional<U> Result;

						if (DigitStyle <= 0 && OtherStyle <= 0)
						{
							if (TrimmedView.StartsWith(LITERAL(T, "infinity"))) Result = Infinity;
							if (TrimmedView.StartsWith(LITERAL(T, "nan")))      Result = NaN;
						}

						if (DigitStyle >= 0 && OtherStyle <= 0)
						{
							if (TrimmedView.StartsWith(LITERAL(T, "Infinity"))) Result = Infinity;
							if (TrimmedView.StartsWith(LITERAL(T, "NaN")))      Result = NaN;
						}

						if (DigitStyle <= 0 && OtherStyle >= 0)
						{
							if (TrimmedView.StartsWith(LITERAL(T, "iNFINITY"))) Result = Infinity;
							if (TrimmedView.StartsWith(LITERAL(T, "nAn")))      Result = NaN;
						}

						if (DigitStyle >= 0 && OtherStyle >= 0)
						{
							if (TrimmedView.StartsWith(LITERAL(T, "INFINITY"))) Result = Infinity;
							if (TrimmedView.StartsWith(LITERAL(T, "NAN")))      Result = NaN;
						}

						if (Result.IsValid())
						{
							TrimmedView.RemovePrefix(NAMESPACE_STD::isnan(*Result) ? 3 : 8);
							Object = *Result;
							return true;
						}

						return false;
					}

					if    (TrimmedView.StartsWith(LITERAL(T, "infinity"))
						|| TrimmedView.StartsWith(LITERAL(T, "Infinity"))
						|| TrimmedView.StartsWith(LITERAL(T, "iNFINITY"))
						|| TrimmedView.StartsWith(LITERAL(T, "INFINITY")))
					{
						TrimmedView.RemovePrefix(8);
						Object = Infinity;
						return true;
					}

					if    (TrimmedView.StartsWith(LITERAL(T, "nan"))
						|| TrimmedView.StartsWith(LITERAL(T, "NaN"))
						|| TrimmedView.StartsWith(LITERAL(T, "nAn"))
						|| TrimmedView.StartsWith(LITERAL(T, "NAN")))
					{
						TrimmedView.RemovePrefix(3);
						Object = NaN;
						return true;
					}
				}

				bool bHex = Format == NAMESPACE_STD::chars_format::hex;

				// Handle the prefix.
				if constexpr (bHasPrefix) if (Param.bPrefix)
				{
					bool bNeedRemove = false;

					bNeedRemove |= OtherStyle <= 0 && TrimmedView.StartsWith(LITERAL(T, "0x"));
					bNeedRemove |= OtherStyle >= 0 && TrimmedView.StartsWith(LITERAL(T, "0X"));

					if (bNeedRemove)
					{
						bHex = true;
						TrimmedView.RemovePrefix(2);
						Format = NAMESPACE_STD::chars_format::hex;
					}
				}

				auto Iter = TrimmedView.Begin();

				do
				{
					auto IsDigit = [=](T Char, unsigned Base) -> unsigned
					{
						if constexpr (bHasDigitStyle) if (Param.DigitStyle != 0)
						{
							return TChar<T>::ToDigit(Char, Param.DigitStyle < 0) < Base;
						}

						return TChar<T>::ToDigit(Char) < Base;
					};

					// Handle the number before the decimal point.
					while (Iter != View.End() && IsDigit(*Iter, bHex ? 16 : 10)) ++Iter;

					// Handle the decimal point.
					if (Iter != View.End() && *Iter == LITERAL(T, '.')) ++Iter;

					// Handle the number after the decimal point.
					if constexpr (bHasPrecision)
					{
						for (unsigned Index = 0; Index < Param.Precision; ++Index)
						{
							if (Iter != View.End() && IsDigit(*Iter, bHex ? 16 : 10)) ++Iter;
						}
					}
					else while (Iter != View.End() && IsDigit(*Iter, bHex ? 16 : 10)) ++Iter;

					const bool bScientific = static_cast<bool>(Format & NAMESPACE_STD::chars_format::scientific);

					// Handle the scientific notation.
					if (Iter != View.End())
					{
						bool bNeedRemove = false;

						bNeedRemove |= OtherStyle <= 0 && bHex && *Iter == LITERAL(T, 'p');
						bNeedRemove |= OtherStyle >= 0 && bHex && *Iter == LITERAL(T, 'P');

						bNeedRemove |= OtherStyle <= 0 && bScientific && *Iter == LITERAL(T, 'e');
						bNeedRemove |= OtherStyle >= 0 && bScientific && *Iter == LITERAL(T, 'E');

						if (bNeedRemove) ++Iter;
					}

					// Handle the sign of the exponent.
					if (Iter != View.End() && *Iter == LITERAL(T, '+')) ++Iter;
					if (Iter != View.End() && *Iter == LITERAL(T, '-')) ++Iter;

					// Handle the number of the exponent.
					while (Iter != View.End() && IsDigit(*Iter, 10)) ++Iter;
				}
				while (false);

				U Result;

				NAMESPACE_STD::from_chars_result ConvertResult;

				TString<char, TInlineAllocator<64>> Buffer;

				if (bNegative) Buffer += '-';

				Buffer.Append(TrimmedView.Begin(), Iter);

				ConvertResult = NAMESPACE_STD::from_chars(ToAddress(Buffer.Begin()), ToAddress(Buffer.End()), Result, Format);

				if (ConvertResult.ec == NAMESPACE_STD::errc::result_out_of_range) return false;
				if (ConvertResult.ec == NAMESPACE_STD::errc::invalid_argument)    return false;

				size_t Num = ConvertResult.ptr - Buffer.GetData();

				check(Num != 0);

				if (bNegative) Num -= 1;

				View = TrimmedView.RemovePrefix(Num);

				Object = Result;
				return true;
			}
		}

		return false;
	}
};

template <CCharType T, bool bIsFormat>
struct TStringFormatOrParseHelper
{
	static constexpr T LeftBrace  = LITERAL(T, '{');
	static constexpr T RightBrace = LITERAL(T, '}');

	static inline const TStringView EscapeLeftBrace  = LITERAL(T, "<[{");
	static inline const TStringView EscapeRightBrace = LITERAL(T, "}]>");

	static FORCEINLINE size_t Do(auto& Result, TStringView<T> Fmt, auto ArgsTuple)
	{
		size_t FormattedObjectNum = 0;

		size_t ArgsIndex = 0;

		auto ParseFormat = [&FormattedObjectNum, &ArgsIndex, ArgsTuple](auto& Self, auto& String, TStringView<T>& Fmt) -> bool
		{
			bool bIsFullyFormatted = true;

			while (!Fmt.IsEmpty())
			{
				if (Fmt.StartsWith(EscapeLeftBrace))
				{
					Fmt.RemovePrefix(EscapeLeftBrace.Num());

					if constexpr (!bIsFormat)
					{
						if (!String.StartsWith(LeftBrace)) return false;

						String.RemovePrefix(1);
					}
					else String += LeftBrace;

					continue;
				}

				if (Fmt.StartsWith(EscapeRightBrace))
				{
					Fmt.RemovePrefix(EscapeRightBrace.Num());

					if constexpr (!bIsFormat)
					{
						if (!String.StartsWith(RightBrace)) return false;

						String.RemovePrefix(1);
					}
					else String += RightBrace;

					continue;
				}

				if (Fmt.StartsWith(LeftBrace))
				{
					Fmt.RemovePrefix(1);

					int SubplaceholderNum = -1;

					size_t PlaceholderBegin = -1;
					size_t PlaceholderEnd   = -1;

					// Find the end of the placeholder.
					do
					{
						while (true)
						{
							PlaceholderBegin = Fmt.FindFirstOf(LeftBrace, PlaceholderBegin + 1);

							if (PlaceholderBegin == INDEX_NONE) break;

							if (Fmt.First(PlaceholderBegin + 1).EndsWith(EscapeLeftBrace))
							{
								++PlaceholderBegin;
							}
							else break;
						}

						while (true)
						{
							PlaceholderEnd = Fmt.FindFirstOf(RightBrace, PlaceholderEnd + 1);

							if (PlaceholderEnd == INDEX_NONE) break;

							if (Fmt.Substr(PlaceholderEnd).StartsWith(EscapeRightBrace))
							{
								++PlaceholderEnd;
							}
							else break;
						}

						if (PlaceholderEnd == INDEX_NONE)
						{
							checkf(false, TEXT("Unmatched '{' in format string."));

							if constexpr (bIsFormat) String += Fmt;

							Fmt = LITERAL(T, "");

							return false;
						}

						++SubplaceholderNum;
					}
					while (PlaceholderBegin != INDEX_NONE && PlaceholderBegin < PlaceholderEnd);

					TStringView Subfmt = Fmt.First(PlaceholderEnd);

					Fmt.RemovePrefix(PlaceholderEnd + 1);

					bool bIsSuccessful = true;

					// The subformat string size are usually smaller than 16.
					TString<T, TInlineAllocator<16>> FormattedSubfmt;

					// Recursively format the subformat string.
					if (SubplaceholderNum > 0)
					{
						if constexpr (bIsFormat) bIsSuccessful = Self(Self, FormattedSubfmt, Subfmt);

						else bIsSuccessful = TStringFormatOrParseHelper<T, true>::Do(FormattedSubfmt, Subfmt, ArgsTuple);

						Subfmt = FormattedSubfmt;
					}

					if (bIsSuccessful)
					{
						// Find the placeholder index delimiter.
						size_t IndexLength = Subfmt.FindFirstOf(LITERAL(T, ':'));

						if (IndexLength == INDEX_NONE) IndexLength = Subfmt.Num();

						TStringView PlaceholderIndex  = Subfmt.First(IndexLength);
						TStringView PlaceholderSubfmt = IndexLength != Subfmt.Num() ? Subfmt.Substr(IndexLength + 1) : LITERAL(T, "");

						size_t Index;

						if (IndexLength != 0)
						{
							if (!PlaceholderIndex.IsInteger(10, false))
							{
								checkf(false, TEXT("Invalid placeholder index."));

								if constexpr (bIsFormat)
								{
									String += LeftBrace;
									String += Subfmt;
									String += RightBrace;

									bIsFullyFormatted = false;
								}
								else return false;

								continue;
							}

							verify(PlaceholderIndex.Parse(LITERAL(T, "{}"), Index) == 1);
						}
						else Index = ArgsIndex++;

						checkf(Index < ArgsTuple.Num(), TEXT("Argument not found."));

						bIsSuccessful = ArgsTuple.Visit(
							[&String, Subfmt = PlaceholderSubfmt](auto& Object) mutable
							{
								if (Subfmt.StartsWith(LITERAL(T, ':'))) Subfmt.RemovePrefix(1);

								struct { TStringView<T> Fmt; } Param = { Subfmt };

								if constexpr (bIsFormat) return TStringObjectFormatter<T>::Do(String, Object, Param);

								else return TStringObjectParser<T>::Do(String, Object, Param);
							},
							Index
						);
					}

					if (!bIsSuccessful)
					{
						if constexpr (bIsFormat)
						{
							String += LeftBrace;
							String += Subfmt;
							String += RightBrace;

							bIsFullyFormatted = false;
						}
						else return false;
					}
					else ++FormattedObjectNum;

					continue;
				}

				check_code({ if (Fmt.StartsWith(RightBrace)) check_no_entry(); });

				if constexpr (!bIsFormat)
				{
					if (TChar<T>::IsSpace(Fmt.Front()))
					{
						Fmt.RemovePrefix(1);

						while (TChar<T>::IsSpace(String.Front()))
						{
							String.RemovePrefix(1);
						}

						continue;
					}

					if (!String.StartsWith(Fmt.Front())) return false;

					String.RemovePrefix(1);
				}
				else String += Fmt.Front();

				Fmt.RemovePrefix(1);
			}

			return bIsFullyFormatted;
		};

		bool bIsSuccessful = ParseFormat(ParseFormat, Result, Fmt);

		if constexpr (bIsFormat) return bIsSuccessful;

		return FormattedObjectNum;
	}
};

NAMESPACE_PRIVATE_END

template <CCharType T, CAllocator<T> Allocator>
template <typename ... Ts>
void TString<T, Allocator>::AppendFormat(TStringView<ElementType> Fmt, const Ts&... Args)
{
	// The Unreal Engine says that the starting buffer size catches 99.97% of printf calls.
	constexpr size_t ReserveBufferSize = 512;

	TString<T, TInlineAllocator<ReserveBufferSize>> Result;

	NAMESPACE_PRIVATE::TStringFormatOrParseHelper<ElementType, true>::Do(Result, Fmt, ForwardAsTuple(Args...));

	Append(Result.Begin(), Result.End());
}

template <CCharType T>
template <typename ... Ts>
size_t TStringView<T>::ParseAndTrim(TStringView Fmt, Ts&... Args)
{
	return NAMESPACE_PRIVATE::TStringFormatOrParseHelper<ElementType, false>::Do(*this, Fmt, ForwardAsTuple(Args...));
}

template <CCharType T, CAllocator<T> Allocator>
void TString<T, Allocator>::AppendBool(bool Value)
{
	NAMESPACE_PRIVATE::TStringObjectFormatter<ElementType>::Do(*this, AsConst(Value), Invalid);
}

template <CCharType T, CAllocator<T> Allocator>
template <CIntegral U> requires (!CSameAs<U, bool> && !CConst<U> && !CVolatile<U>)
void TString<T, Allocator>::AppendInt(U Value, unsigned Base)
{
	checkf(Base >= 2 && Base <= 36, TEXT("Illegal base. Please check the base."));

	struct { unsigned Base; } Param = { Base };

	NAMESPACE_PRIVATE::TStringObjectFormatter<ElementType>::Do(*this, AsConst(Value), Param);
}

template <CCharType T, CAllocator<T> Allocator> template <CFloatingPoint U> requires (!CConst<U> && !CVolatile<U>)
void TString<T, Allocator>::AppendFloat(U Value)
{
	NAMESPACE_PRIVATE::TStringObjectFormatter<ElementType>::Do(*this, AsConst(Value), Invalid);
}

template <CCharType T, CAllocator<T> Allocator> template <CFloatingPoint U> requires (!CConst<U> && !CVolatile<U>)
void TString<T, Allocator>::AppendFloat(U Value, bool bFixed, bool bScientific)
{
	struct { bool bFixed; bool bScientific; } Param = { bFixed, bScientific };

	NAMESPACE_PRIVATE::TStringObjectFormatter<ElementType>::Do(*this, AsConst(Value), Param);
}

template <CCharType T, CAllocator<T> Allocator> template <CFloatingPoint U> requires (!CConst<U> && !CVolatile<U>)
void TString<T, Allocator>::AppendFloat(U Value, bool bFixed, bool bScientific, unsigned Precision)
{
	struct { bool bFixed; bool bScientific; unsigned Precision; } Param = { bFixed, bScientific, Precision };

	NAMESPACE_PRIVATE::TStringObjectFormatter<ElementType>::Do(*this, AsConst(Value), Param);
}

template <CCharType T>
constexpr bool TStringView<T>::ToBoolAndTrim()
{
	bool Value = false;

	if (!NAMESPACE_PRIVATE::TStringObjectParser<ElementType>::Do(*this, Value, Invalid))
	{
		if (int IntValue; NAMESPACE_PRIVATE::TStringObjectParser<ElementType>::Do(*this, IntValue, Invalid))
		{
			Value = IntValue != 0;
		}
	}

	return Value;
}

template <CCharType T>
template <CIntegral U> requires (!CSameAs<U, bool> && !CConst<U> && !CVolatile<U>)
constexpr U TStringView<T>::ToIntAndTrim(unsigned Base)
{
	checkf(Base >= 2 && Base <= 36, TEXT("Illegal base. Please check the base."));

	U Value = 0;

	struct { unsigned Base; } Param = { Base };

	NAMESPACE_PRIVATE::TStringObjectParser<ElementType>::Do(*this, Value, Param);

	return Value;
}

template <CCharType T>
template <CFloatingPoint U> requires (!CConst<U> && !CVolatile<U>)
constexpr U TStringView<T>::ToFloatAndTrim(bool bFixed, bool bScientific)
{
	U Value = NAMESPACE_STD::numeric_limits<U>::quiet_NaN();

	struct { bool bFixed; bool bScientific; } Param = { bFixed, bScientific };

	NAMESPACE_PRIVATE::TStringObjectParser<ElementType>::Do(*this, Value, Param);

	return Value;
}

NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)
NAMESPACE_REDCRAFT_END

#pragma warning(pop)