import pytest

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


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", VAR("var_name")),
        ("var_name.attr", VAR("var_name.attr")),
        ("var_name .attr", VAR("var_name.attr", source="var_name .attr")),
        ("var_name. attr", VAR("var_name.attr", source="var_name. attr")),
        ("var_name . attr", VAR("var_name.attr", source="var_name . attr")),
        ("var_name.attr.get_value(x)", VAR("var_name.attr.get_value(x)")),
        ("var_name.attr == 10", EQ(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr != 10", NEQ(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr > 10", GT(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr >= 10", GTE(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr < 10", LT(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr <= 10", LTE(VAR("var_name.attr"), EXPR("10"))),
        ("var_name.attr in (a, b)", IN(VAR("var_name.attr"), EXPR("a, b"))),
        ("var_name.attr not in (a, b)", NIN(VAR("var_name.attr"), EXPR("a, b"))),
        ("var1.attr1 == var2.attr2", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
        ("var1.attr1 == (var2.attr2)", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
        # ("var_name.attr in (a.b, b.c)", IN(VAR("var_name.attr"), PAREN(EXPR("a.b, b.c"), source="(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(VAR("var_name.attr"), VAR("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.NOT_FOR_ME, 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.NOT_FOR_ME, 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)