using CanonSharp.Combinator;
using CanonSharp.Combinator.Abstractions;
using CanonSharp.Common.Scanner;

namespace CanonSharp.Tests.Utils;

public abstract class LexicalTestBase
{
    protected static void ValidateSuccessfulParser(Parser<char, LexicalToken> parser, LexicalTokenType exceptedType,
        string literalValue, string input)
    {
        StringReadState state = new(input);
        ParseResult<char, LexicalToken> result = parser.Parse(state);

        Assert.Equal(exceptedType, result.Value.TokenType);
        Assert.Equal(literalValue, result.Value.LiteralValue);
    }

    protected static void ValidateFailedParser(Parser<char, LexicalToken> parser, string input)
    {
        StringReadState state = new(input);
        ParseResult<char, LexicalToken> result = parser.Parse(state);
        Assert.ThrowsAny<ParseException>(() => result.Value);
    }

    protected static void ValidateLexicalTokens(Parser<char, IEnumerable<LexicalToken>> parser, string input,
        IEnumerable<(LexicalTokenType, string)> exceptedResult)
    {
        StringReadState state = new(input);
        ParseResult<char, IEnumerable<LexicalToken>> result = parser.Parse(state);

        foreach (((LexicalTokenType exceptedType, string exceptedValue), LexicalToken token) in exceptedResult.Zip(
                     result.Value))
        {
            Assert.Equal(exceptedType, token.TokenType);
            Assert.Equal(exceptedValue, token.LiteralValue);
        }
    }
}