import pytest

from core.builtin_concepts_ids import BuiltinConcepts
from core.sheerka.services.SheerkaExecute import ParserInput
from core.tokenizer import TokenKind
from parsers.BaseExpressionParser import ParenthesisMismatchError
from parsers.BaseParser import UnexpectedTokenParsingError
from parsers.RelationalOperatorParser import RelationalOperatorParser
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.parsers.parsers_utils import EQ, EXPR, GT, GTE, IN, LT, LTE, L_EXPR, NEQ, NIN, get_expr_node_from_test_node


class TestRelationalOperatorParser(TestUsingMemoryBasedSheerka):
    def init_parser(self):
        sheerka, context = self.init_concepts()
        parser = RelationalOperatorParser()
        return sheerka, context, parser

    def test_i_can_detect_empty_expression(self):
        sheerka, context, parser = self.init_parser()
        res = parser.parse(context, ParserInput(""))

        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.IS_EMPTY)

    @pytest.mark.parametrize("expression, expected", [
        ("var_name", EXPR("var_name")),
        ("var_name.attr", EXPR("var_name.attr")),
        ("var_name.attr.get_value(x)", EXPR("var_name.attr.get_value(x)")),
        ("var_name.attr == 10", EQ(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr != 10", NEQ(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr > 10", GT(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr >= 10", GTE(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr < 10", LT(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr <= 10", LTE(EXPR("var_name.attr"), EXPR("10"))),
        ("var_name.attr in (a, b)", IN(EXPR("var_name.attr"), L_EXPR("(", ")", "a", "b"))),
        ("var_name.attr not in (a, b)", NIN(EXPR("var_name.attr"), L_EXPR("(", ")", "a", "b"))),
        ("var1.attr1 == var2.attr2", EQ(EXPR("var1.attr1"), EXPR("var2.attr2"))),
        ("var1.attr1 == (var2.attr2)", EQ(EXPR("var1.attr1"), EXPR("var2.attr2"))),
        ("var_name.attr in (a.b, b.c)", IN(EXPR("var_name.attr"), L_EXPR("(", ")", "a.b", "b.c"))),

        ("not a var identifier", EXPR("not a var identifier")),
        ("func()", EXPR("func()")),
        ("func(a, not an identifier, x >5)", EXPR("func(a, not an identifier, x >5)")),
        ("(var_name.attr != var_name2.attr2)", NEQ(EXPR("var_name.attr"), EXPR("var_name2.attr2")))
    ])
    def test_i_can_parse_simple_expressions(self, expression, expected):
        sheerka, context, parser = self.init_parser()
        expected = get_expr_node_from_test_node(expression, expected)

        res = parser.parse(context, ParserInput(expression))
        parser_result = res.body
        parsed_expr = parser_result.body

        assert res.status
        assert res.who == parser.name
        assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
        assert parsed_expr == expected

    @pytest.mark.parametrize("expression, expected_error, parenthesis_type, index", [
        ("(", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 0),
        (")", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 0),
        ("something (", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
        ("something )", BuiltinConcepts.ERROR, TokenKind.RPAR, 10),
        ("something == (", BuiltinConcepts.ERROR, TokenKind.LPAR, 13),
        ("something == )", BuiltinConcepts.ERROR, TokenKind.RPAR, 13),
        ("something (==", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
        ("something )==", BuiltinConcepts.ERROR, TokenKind.RPAR, 10),
    ])
    def test_i_can_detect_unbalanced_parenthesis(self, expression, expected_error, parenthesis_type, index):
        sheerka, context, parser = self.init_parser()

        res = parser.parse(context, ParserInput(expression))
        assert not res.status
        if expected_error == BuiltinConcepts.NOT_FOR_ME:
            assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
            assert isinstance(res.body.reason[0], ParenthesisMismatchError)
            assert res.body.reason[0].token.type == parenthesis_type
            assert res.body.reason[0].token.index == index
        else:
            assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
            assert isinstance(res.body.body[0], ParenthesisMismatchError)
            assert res.body.body[0].token.type == parenthesis_type
            assert res.body.body[0].token.index == index

    def test_i_can_detect_syntax_error(self):
        sheerka, context, parser = self.init_parser()

        expression = "var in a"
        res = parser.parse(context, ParserInput(expression))

        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
        assert isinstance(res.body.body[0], UnexpectedTokenParsingError)