import pytest

from core.builtin_concepts_ids import BuiltinConcepts
from core.concept import Concept
from core.sheerka.services.SheerkaExecute import ParserInput
from evaluators.BaseEvaluator import BaseEvaluator
from evaluators.ExpressionEvaluator import ExpressionEvaluator
from parsers.BaseExpressionParser import AndNode
from parsers.ExpressionParser import ExpressionParser
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.evaluators.EvaluatorTestsUtils import pr_ret_val, e_ret_val_true


class TestExpressionEvaluator(TestUsingMemoryBasedSheerka):

    @pytest.mark.parametrize("return_value, expected", [
        (pr_ret_val(AndNode(0, 0, [])), True),
        (pr_ret_val(AndNode(0, 0, []), status=False), False),
        (pr_ret_val("not a ExprNode", status=True), False),
        (e_ret_val_true("no parser result"), False),
    ])
    def test_i_can_match(self, return_value, expected):
        sheerka, context = self.init_concepts()
        evaluator = ExpressionEvaluator()

        assert evaluator.matches(context, return_value) == expected

    def test_i_can_eval(self):
        sheerka, context, one, number, isa = self.init_concepts(
            "one",
            "number",
            Concept("x is a y", body="isa(x,y)", pre="is_question()").def_var("x").def_var("y"))
        evaluator = ExpressionEvaluator()

        context.add_to_protected_hints(BuiltinConcepts.EVAL_QUESTION_REQUESTED)

        parsed_return_value = ExpressionParser().parse(context, ParserInput("one is a number"))

        # first time, it returns False
        res = evaluator.eval(context, parsed_return_value)
        assert res.status
        assert res.who == BaseEvaluator.PREFIX + ExpressionEvaluator.NAME
        assert not res.body

        # second time
        global_truth_context = self.get_context(sheerka, global_truth=True)
        sheerka.set_isa(global_truth_context, one, number)
        parsed_return_value = ExpressionParser().parse(context, ParserInput("one is a number"))
        res = evaluator.eval(context, parsed_return_value)
        assert res.status
        assert res.body

    def test_i_do_not_mess_up_use_copy(self):
        sheerka, context, one, number, isa = self.init_concepts(
            "one",
            "number",
            Concept("x is a y", body="isa(x,y)", pre="is_question()").def_var("x").def_var("y"))
        context.add_to_protected_hints(BuiltinConcepts.EVAL_QUESTION_REQUESTED)
        evaluator = ExpressionEvaluator()

        parsed_return_value = ExpressionParser().parse(context, ParserInput("one is a number"))
        concept = next(iter(parsed_return_value.body.body.compiled[0].return_value.body.body.objects.values()))
        assert concept.get_compiled()["x"][0].body.body.get_hints().use_copy
        assert concept.get_compiled()["y"][0].body.body.get_hints().use_copy

        evaluator.eval(context, parsed_return_value)
        concept = next(iter(parsed_return_value.body.body.compiled[0].return_value.body.body.objects.values()))
        assert concept.get_compiled()["x"][0].body.body.get_hints().use_copy
        assert concept.get_compiled()["y"][0].body.body.get_hints().use_copy

    def test_i_cannot_eval_when_variables_are_missing(self):
        sheerka, context, one, number, isa = self.init_concepts(
            "one",
            "number",
            Concept("x is a y", body="isa(x,y)", pre="is_question()").def_var("x").def_var("y"))
        context.add_to_protected_hints(BuiltinConcepts.EVAL_QUESTION_REQUESTED)
        evaluator = ExpressionEvaluator()

        parsed_return_value = ExpressionParser().parse(context, ParserInput("self is a number"))
        res = evaluator.eval(context, parsed_return_value)

        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
        assert len(res.body.body) == 1
        assert isinstance(res.body.body[0], NameError)
        assert res.body.body[0].args == ("self",)