import pytest

from core.builtin_concepts_ids import BuiltinConcepts
from core.sheerka.services.SheerkaExecute import ParserInput
from core.tokenizer import Tokenizer
from parsers.BaseParser import ErrorSink
from parsers.ExpressionParser import ExpressionParser
from parsers.expressions import VariableNode
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.parsers.parsers_utils import get_expr_node_from_test_node, VAR, EXPR, AND


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

    def input_parser_with_source(self, source):
        sheerka, context, parser = self.init_parser()
        error_sink = ErrorSink()
        parser_input = ParserInput(source)
        parser.reset_parser_input(parser_input, error_sink)
        return sheerka, context, parser, parser_input, error_sink

    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", [
        ("var1 + var2", EXPR("var1 + var2")),
        ("variable", VAR("variable")),
        ("var.attr", VAR("var.attr")),
        ("var1 and var2", AND(VAR("var1"), VAR("var2")))
    ])
    def test_i_can_parse_input(self, expression, expected):
        sheerka, context, parser, parser_input, error_sink = self.input_parser_with_source(expression)
        expected = get_expr_node_from_test_node(expression, expected)

        parsed = parser.parse_input(context, parser_input, error_sink)

        assert not error_sink.has_error
        assert parsed == expected

    @pytest.mark.parametrize("expression", [
        "var.attr1.attr2",
        "var . attr1 . attr2",
    ])
    def test_i_can_parse_variable(self, expression):
        sheerka, context, parser, parser_input, error_sink = self.input_parser_with_source(expression)
        parsed = parser.parse_input(context, parser_input, error_sink)

        assert not error_sink.has_error
        assert isinstance(parsed, VariableNode)
        assert parsed.name == "var"
        assert parsed.attributes == ["attr1", "attr2"]

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

        expression = "do not care var1 + var2 do not care either"
        parser_input = ParserInput("text", list(Tokenizer(expression, yield_eof=False)), start=6, end=10)
        error_sink = ErrorSink()
        parser.reset_parser_input(parser_input, error_sink)
        parsed = parser.parse_input(context, parser_input, error_sink)

        assert not error_sink.has_error
        assert parsed == get_expr_node_from_test_node(expression, EXPR("var1 + var2"))