package parser

import lexer.Token
import lexer.state.TokenPosition
import lexer.TokenType
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Test
import prolog.ast.terms.Atom
import prolog.ast.terms.CompoundTerm

class ParseTests {
    @Test
    fun `parse atom a`() {
        val input = Token(TokenType.ALPHANUMERIC, "a", TokenPosition(0, 0, 1))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom("a"), result[0], "Expected atom 'a'")
    }

    @Test
    fun `parse atom foo`() {
        val input = Token(TokenType.ALPHANUMERIC, "foo", TokenPosition(0, 0, 3))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom("foo"), result[0], "Expected atom 'foo'")
    }

    @Test
    fun `parse atom foo1`() {
        val input = Token(TokenType.ALPHANUMERIC, "foo1", TokenPosition(0, 0, 4))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom("foo1"), result[0], "Expected atom 'foo1'")
    }

    @Test
    fun `parse atom fooBar`() {
        val name = "fooBar"
        val input = Token(TokenType.ALPHANUMERIC, name, TokenPosition(0, 0, 6))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom(name), result[0], "Expected atom 'fooBar'")
    }

    @Test
    fun `parse atom foo_bar`() {
        val name = "foo_bar"
        val input = Token(TokenType.ALPHANUMERIC, name, TokenPosition(0, 0, 7))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom(name), result[0], "Expected atom 'foo_bar'")
    }

    @Test
    fun `parse atom my_FooBar1`() {
        val name = "my_FooBar1"
        val input = Token(TokenType.ALPHANUMERIC, name, TokenPosition(0, 0, 11))

        val result = Parser(listOf(input)).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertEquals(Atom(name), result[0], "Expected atom 'my_FooBar1'")
    }

    @Test
    fun `parse compound term f()`() {
        val input = listOf(
            Token(TokenType.ALPHANUMERIC, "f", TokenPosition(0, 0, 1)),
            Token(TokenType.PARENTHESIS_LEFT, "(", TokenPosition(0, 1, 2)),
            Token(TokenType.PARENTHESIS_RIGHT, ")", TokenPosition(0, 3, 4))
        )

        val result = Parser(input).parse()

        assertEquals(1, result.size, "Expected 1 term")
        assertTrue(result[0] is CompoundTerm)
        assertEquals("f", (result[0] as CompoundTerm).name)
        assertEquals(0, (result[0] as CompoundTerm).arguments.size)
    }
}