using Jtr.Parsing.Json;

namespace Jtr.Parsing.Tests;

public class JsonLexerTests
{
    [SetUp]
    public void Setup()
    {
    }

    [Test]
    public void Can_lex_null()
    {
        const string source = "null";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_null), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.Null, Lexeme: "null" },
            { Type: JsonToken.EndOfSource }
        ]);
    }

    [Test]
    public void Can_lex_booleans()
    {
        const string trueSource = "true";
        const string falseSource = "false";
        var trueTokens = JsonLexer.Default.Lex(nameof(Can_lex_booleans), trueSource);
        var falseTokens = JsonLexer.Default.Lex(nameof(Can_lex_booleans), falseSource);

        Assert.Multiple(() =>
        {
            Assert.That(trueTokens is
            [
                { Type: JsonToken.True, Lexeme: "true" },
                { Type: JsonToken.EndOfSource }
            ]);

            Assert.That(falseTokens is
            [
                { Type: JsonToken.False, Lexeme: "false" },
                { Type: JsonToken.EndOfSource }
            ]);
        });
    }

    [Test]
    public void Can_lex_an_integer()
    {
        const string source = "1";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_integer), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.Number, Lexeme: "1" },
            { Type: JsonToken.EndOfSource }
        ]);
    }

    [Test]
    public void Can_lex_a_decimal()
    {
        const string source = "1.0";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_a_decimal), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.Number, Lexeme: "1.0" },
            { Type: JsonToken.EndOfSource }
        ]);
    }

    [Test]
    public void Can_lex_a_string()
    {
        const string source = "\"Hello world!\"";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_a_string), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.String, Lexeme: "Hello world!" },
            { Type: JsonToken.EndOfSource }
        ]);
    }

    [Test]
    public void Can_lex_an_empty_array()
    {
        const string source = "[]";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_empty_array), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBracket, Lexeme: "[" },
            { Type: JsonToken.RightBracket, Lexeme: "]" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }

    [Test]
    public void Can_lex_a_single_item_array()
    {
        const string source = "[1]";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_a_single_item_array), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBracket, Lexeme: "[" },
            { Type: JsonToken.Number, Lexeme: "1" },
            { Type: JsonToken.RightBracket, Lexeme: "]" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }

    [Test]
    public void Can_lex_an_array_with_multiple_items()
    {
        const string source = "[1,true,{},[],null]";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_array_with_multiple_items), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBracket, Lexeme: "[" },
            { Type: JsonToken.Number, Lexeme: "1" },
            { Type: JsonToken.Comma, Lexeme: "," },
            { Type: JsonToken.True, Lexeme: "true" },
            { Type: JsonToken.Comma, Lexeme: "," },
            { Type: JsonToken.LeftBrace, Lexeme: "{" },
            { Type: JsonToken.RightBrace, Lexeme: "}" }, 
            { Type: JsonToken.Comma, Lexeme: "," },
            { Type: JsonToken.LeftBracket, Lexeme: "[" },
            { Type: JsonToken.RightBracket, Lexeme: "]" },
            { Type: JsonToken.Comma, Lexeme: "," },
            { Type: JsonToken.Null, Lexeme: "null" },
            { Type: JsonToken.RightBracket, Lexeme: "]" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }

    [Test]
    public void Can_lex_an_empty_object()
    {
        const string source = "{}";
        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_empty_object), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBrace, Lexeme: "{" },
            { Type: JsonToken.RightBrace, Lexeme: "}" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }

    [Test]
    public void Can_lex_an_object_with_one_entry()
    {
        const string source = "{\"first_name\":\"John\"}";

        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_object_with_one_entry), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBrace, Lexeme: "{" },
            { Type: JsonToken.String, Lexeme: "first_name" },
            { Type: JsonToken.Colon, Lexeme: ":" },
            { Type: JsonToken.String, Lexeme: "John" },
            { Type: JsonToken.RightBrace, Lexeme: "}" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }

    [Test]
    public void Can_lex_an_object_with_multiple_entries()
    {
        const string source = "{\"first_name\":\"John\", \"last_name\": \"Doe\"}";

        var tokens = JsonLexer.Default.Lex(nameof(Can_lex_an_object_with_multiple_entries), source);

        Assert.That(tokens is
        [
            { Type: JsonToken.LeftBrace, Lexeme: "{" },
            { Type: JsonToken.String, Lexeme: "first_name" },
            { Type: JsonToken.Colon, Lexeme: ":" },
            { Type: JsonToken.String, Lexeme: "John" },
            { Type: JsonToken.Comma, Lexeme: "," },
            { Type: JsonToken.String, Lexeme: "last_name" },
            { Type: JsonToken.Colon, Lexeme: ":" },
            { Type: JsonToken.String, Lexeme: "Doe" },
            { Type: JsonToken.RightBrace, Lexeme: "}" },
            { Type: JsonToken.EndOfSource }
        ], Is.True);
    }
}