GOVNOKOD

extern UInt8 GSupportFormatBuffer[FORMAT_BUFFER_SIZE];
extern UInt8 GSupportToStringBuffer[TO_STRING_BUFFER_SIZE];

template<typename CharType>
struct FormatterPlaceholder
{
};

template<>
struct FormatterPlaceholder<char>
{
public:
    enum
    {
        Begin = '{',
        End = '}'
    };
};

template<>
struct FormatterPlaceholder<wchar_t>
{
public:
    enum
    {
        Begin = L'{',
        End = L'}'
    };
};

template<typename CharType>
class Formatter
{
private:
    static int _ToString(Int8 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRId8,
            Value);
    }

    static int _ToString(Int16 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRId16,
            Value);
    }

    static int _ToString(Int32 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRId32,
            Value);
    }

    static int _ToString(Int64 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRId64,
            Value);
    }

    static int _ToString(UInt8 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRIu8,
            Value);
    }

    static int _ToString(UInt16 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRIu16,
            Value);
    }

    static int _ToString(UInt32 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRIu32,
            Value);
    }

    static int _ToString(UInt64 Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%" PRIu64,
            Value);
    }

    static int _ToString(float Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%f",
            Value);
    }

    static int _ToString(double Value)
    {
        return CString<CharType>::Snprintf(
            (CharType*)GSupportToStringBuffer,
            TO_STRING_BUFFER_SIZE,
            "%f",
            Value);
    }

    template<typename First, typename ... Args>
    static void _ConvertArgs(Array<GenericString<CharType>>& _ArgBuffer, const First& _First, const Args& ... _Args)
    {
        _ArgBuffer.Add(ToString(_First));
        _ConvertArgs(_ArgBuffer, _Args ...);
    }

    template<typename First>
    static void _ConvertArgs(Array<GenericString<CharType>>& _ArgBuffer, const First& _First)
    {
        _ArgBuffer.Add(ToString(_First));
    }

    static bool _ScanPlaceholder(const CharType* Format, size_t Index, size_t Length, size_t& Placeholder, size_t& LastIndex)
    {
        size_t i = Index;
        size_t j = 0;
        while (i < Length && Format[i] != FormatterPlaceholder<CharType>::End)
        {
            if (!Char<CharType>::IsDigit(Format[i]))
            {
                return false;
            }
            else
            {
                GSupportToStringBuffer[j] = Format[i];
                j++;
            }

            i++;
        }

        if (i == Length)
            return false;

        GSupportToStringBuffer[j] = 0;
#if defined(64BIT)
        Placeholder = CString<CharType>::Atoi64((const CharType*)GSupportToStringBuffer);
#else
        Placeholder = CString<CharType>::Atoi((const CharType*)GSupportToStringBuffer);
#endif
        LastIndex = i;

        return true;
    }
public:
    template<typename T>
    static GenericString<CharType> ToString(const T& Value)
    {
        int Length = Formatter<CharType>::_ToString(Value);
        return GenericString<CharType>((char*)GSupportToStringBuffer, Length);
    }

    template<typename ... Args>
    static GenericString<CharType> Format(const CharType* Format, const Args& ... _Args)
    {
        Array<GenericString<CharType>> _FormatedArgs;
        _FormatedArgs.Reserve(sizeof...(Args));
        Formatter<CharType>::_ConvertArgs(_FormatedArgs, _Args ...);

        const size_t _Length = CString<CharType>::Strlen(Format);
        size_t Index = 0;
        for (size_t i = 0; i < _Length; i++)
        {
            if (Format[i] == FormatterPlaceholder<CharType>::Begin)
            {
                size_t Placeholder = 0;
                size_t LastIndex = 0;
                if (_ScanPlaceholder(Format, i + 1, _Length, Placeholder, LastIndex) && Placeholder < sizeof...(Args))
                {
                    Memory::Copy(
                        GSupportFormatBuffer + Index,
                        _FormatedArgs[Placeholder].Data(),
                        _FormatedArgs[Placeholder].Length() * sizeof(CharType)
                    );

                    Index += _FormatedArgs[Placeholder].Length();
                    i = LastIndex;
                }
            }
            else
            {
                GSupportFormatBuffer[Index] = Format[i];
                Index++;
            }
        }

        GSupportFormatBuffer[Index] = 0;

        return GenericString<CharType>((const CharType*)GSupportFormatBuffer);
    }
};

template<typename T>
forceinline String ToString(const T& Value)
{
    return Formatter<char>::ToString<T>(Value);
}

forceinline String ToString(const char* Value)
{
    return String(Value);
}

forceinline String ToString(const String& Value)
{
    return Value;
}

forceinline String FormatAnsi(const char* Format, ...)
{
    va_list Args;
    va_start(Args, Format);
    int Length = CString<char>::Vsnprintf((char*)GSupportFormatBuffer, FORMAT_BUFFER_SIZE, Format, Args);
    String Result(GSupportFormatBuffer, Length);
    va_end(Args);
    return Result;
}

template<typename ... Args>
forceinline String Format(const char* Format, const Args& ... _Args)
{
    return Formatter<char>::Format(Format, _Args ...);
}