// When you see '<', make sure the following character is not '!' or '/' before parsing as a start element.
// When you skip HTML comments, unlike html documents in the Web, keep in mind that hyphens do not have to be placed other than before an ending greater than character 
// (e.g. `<!br-->` will be skipped as comments but `<!--br->` will be parsed as an HTML br tag). 
// See `GFxSGMLParser<Char>::SkipComment` in `GFxSGMLParser.h` in that secret code to verify how the game would skip html comments.
// When you parse an starting HTML element, you may have to skip space characters and the set below contains all the characters that the scaleform treats as space characters!

// This set contains all the values where `G_iswspace` in `Gstd.h` would return non-zero values and the game would treat as space characters!
HashSet<char> SpaceCharactersForScaleform = new() { '\u0009', '\u000a', '\u000b', '\u000c', '\u000d', '\u0020', '\u00a0', '\u1680', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004', '\u2005', '\u2006', '\u2007', '\u2008', '\u2009', '\u200a', '\u200b', '\u2028', '\u2029', '\u202f', '\u3000' }; 

public enum TokenStateOfParseToken
{
    /// <summary>
    /// standard text (not found a token yet)
    /// </summary>
    StandardArea,
    /// <summary>
    /// inside a token, gathering all the token text
    /// </summary>
    InsideTokenArea,
    /// <summary>
    /// fully completed, ready to go back to standard text again
    /// </summary>
    Completed,
}

const char TokenEscape = '\\';
const char TokenDelimiter = '~';

public static List<string> SplitStringByNewLineTokens(string str)
{
    // same max length as `MAX_TOKEN_LEN` macro in `TextFormat.h` but without the null terminator
    const int MaxTokenLen = 63;
    StringBuilder tokenNameBuffer = new StringBuilder(MaxTokenLen);

    TokenStateOfParseToken tokenState = TokenStateOfParseToken.StandardArea;
    char prevChar = '\0';

    int i = 0;

    int startPosOfSubstring = 0;
    int endPosOfSubstring = 0;
    List<string> substrings = new List<string>();

    while (i < str.Length)
    {
        char newCharacter = str[i];
        if (newCharacter == TokenEscape && (i + 1) < str.Length)
        {
            // Get the next character. If valid (not null), check if it is the delimiter.
            // If it is the delimiter, skip this escape character. The code below
            // will handle treating the delimiter as a normal character.

            // NOTE: the next token delimiter will be added as a part of the token name if the token state is
            // inside token area, but this behavior is exactly the same as how the game parses.
            char peek = str[i + 1];
            if (peek == TokenDelimiter)
            {
                prevChar = newCharacter;
                i++;
                continue;
            }
        }

        if (newCharacter == TokenDelimiter && (i == 0 || prevChar != TokenEscape))
        {
            if (tokenState == TokenStateOfParseToken.StandardArea)
            {
                tokenState = TokenStateOfParseToken.InsideTokenArea;
                prevChar = newCharacter;
                endPosOfSubstring = i;
                i++;
                continue;
            }
            else if (tokenState == TokenStateOfParseToken.InsideTokenArea)
            {
                string tokenName = tokenNameBuffer.ToString();
                tokenNameBuffer.Clear();
                
                tokenState = TokenStateOfParseToken.StandardArea;
                prevChar = newCharacter;

                // The new line token IS case-sensitive in the game unlike how the bold and italic style
                // tokens, wanted star token, Rockstar logo token, and non-renderable token (~nrt~) are parsed.
                if (tokenName == "n")
                {
                    substrings.Add(str.Substring(startPosOfSubstring, endPosOfSubstring - startPosOfSubstring));

                    i++;
                    startPosOfSubstring = i;
                    endPosOfSubstring = i;
                }
                else
                {
                    i++;
                    endPosOfSubstring = i;
                }
            }
        }
        else if (tokenState == TokenStateOfParseToken.InsideTokenArea)
        {
            // Emulate how the game appends the token name to the token name buffer 😛
            if (tokenNameBuffer.Length < MaxTokenLen)
            {
                tokenNameBuffer.Append(newCharacter);
            }

            prevChar = newCharacter;
            i++;
        }
        else if (tokenState == TokenStateOfParseToken.StandardArea)
        {
            prevChar = newCharacter;
            i++;
            endPosOfSubstring = i;
        }
    }

    endPosOfSubstring = i;
    if (endPosOfSubstring - startPosOfSubstring > 0)
    {
        substrings.Add(str.Substring(startPosOfSubstring, endPosOfSubstring - startPosOfSubstring));
    }

    return substrings;
}
 
public static List<RangeCompact> FindAllTokenRanges(string str)
{
    TokenStateOfParseToken tokenState = TokenStateOfParseToken.StandardArea;
    char prevChar = '\0';

    int i = 0;

    int startPosOfToken = 0;
    int endPosOfToken = 0;
    List<RangeCompact> ranges = new List<RangeCompact>();

    while (i < str.Length)
    {
        char newCharacter = str[i];
        if (newCharacter == TokenEscape && (i + 1) < str.Length)
        {
            // Get the next character. If valid (not null), check if it is the delimiter.
            // If it is the delimiter, skip this escape character. The code below
            // will handle treating the delimiter as a normal character.
            char peek = str[i + 1];
            if (peek == TokenDelimiter)
            {
                prevChar = newCharacter;
                i++;
                // endPosOfToken will be set to i + 1 later
                continue;
            }
        }

        if (newCharacter == TokenDelimiter && (i == 0 || prevChar != TokenEscape))
        {
            if (tokenState == TokenStateOfParseToken.StandardArea)
            {
                tokenState = TokenStateOfParseToken.InsideTokenArea;
                prevChar = newCharacter;
                startPosOfToken = i;
                endPosOfToken = i + 1;
                i++;
                continue;
            }
            else if (tokenState == TokenStateOfParseToken.InsideTokenArea)
            {
                tokenState = TokenStateOfParseToken.StandardArea;
                prevChar = newCharacter;
                ranges.Add(new RangeCompact(startPosOfToken, endPosOfToken + 1));

                i++;
                startPosOfToken = i;
                endPosOfToken = i;
            }
        }
        else if (tokenState == TokenStateOfParseToken.InsideTokenArea)
        {
            prevChar = newCharacter;
            i++;
            endPosOfToken = i;
        }
        else if (tokenState == TokenStateOfParseToken.StandardArea)
        {
            prevChar = newCharacter;
            i++;
        }
    }

    if (endPosOfToken - startPosOfToken > 0)
    {
        ranges.Add(new RangeCompact(startPosOfToken, endPosOfToken + 1));
    }

    return ranges;
}
 
public readonly struct RangeCompact : IEquatable<RangeCompact>
{
    /// <summary>Represent the inclusive start index of the Range.</summary>
    public int Start { get; }

    /// <summary>Represent the exclusive end index of the Range.</summary>
    public int End { get; }

    /// <summary>Construct a Range object using the start and end indexes.</summary>
    /// <param name="start">Represent the inclusive start index of the range.</param>
    /// <param name="end">Represent the exclusive end index of the range.</param>
    public RangeCompact(int start, int end)
    {
        Start = start;
        End = end;
    }

    /// <summary>Indicates whether the current Range object is equal to another object of the same type.</summary>
    /// <param name="value">An object to compare with this object.</param>
    public override bool Equals(object? value) =>
        value is RangeCompact r &&
        r.Start.Equals(Start) &&
        r.End.Equals(End);

    /// <summary>Indicates whether the current Range object is equal to another Range object.</summary>
    /// <param name="other">An object to compare with this object</param>
    public bool Equals(RangeCompact other) => other.Start.Equals(Start) && other.End.Equals(End);

    /// <summary>Returns the hash code for this instance.</summary>
    public override int GetHashCode()
    {
        return Start.GetHashCode() * 39 + End.GetHashCode();
    }
}