import pytest
from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.rule import Rule, ACTION_TYPE_DEFERRED
from evaluators.RuleEvaluator import RuleEvaluator

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestRuleEvaluator(TestUsingMemoryBasedSheerka):

    @pytest.mark.parametrize("ret_val, expected", [
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=[Rule()])), True),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value="Not a concept")), False),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=[])), False),
        (ReturnValueConcept("some_name", True, Rule), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=Rule())), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=[Rule()])), False),
    ])
    def test_i_can_match(self, ret_val, expected):
        context = self.get_context()
        assert RuleEvaluator().matches(context, ret_val) == expected

    @pytest.mark.parametrize("body, expected", [
        ([Rule("exec", "rule1")], Rule("exec", "rule1")),
        ([Rule("exec", "rule1"), Rule("exec", "rule2")], [Rule("exec", "rule1"), Rule("exec", "rule2")]),

    ])
    def test_i_can_evaluate(self, body, expected):
        context = self.get_context()
        ret_val = ReturnValueConcept("some_name", True, ParserResultConcept(value=body), True)
        evaluator = RuleEvaluator()

        result = evaluator.eval(context, ret_val)

        assert result.who == evaluator.name
        assert result.status
        assert result.value == expected
        assert result.parents == [ret_val]

    def test_i_can_evaluate_deferred_rules(self):
        context = self.get_context()

        rule = Rule().set_id("i")
        rule.metadata.action_type = ACTION_TYPE_DEFERRED
        ret_val = ReturnValueConcept("some_name", True, ParserResultConcept(value=[rule]), True)
        context.add_to_short_term_memory("i", 1)
        evaluator = RuleEvaluator()

        result = evaluator.eval(context, ret_val)

        assert result.who == evaluator.name
        assert result.status
        assert result.value == context.sheerka.get_rule_by_id("1")
        assert result.parents == [ret_val]

    def test_i_cannot_evaluate_deferred_rule_if_the_rule_is_unknown(self):
        sheerka, context = self.init_concepts()

        rule = Rule().set_id("unknown variable")
        rule.metadata.action_type = ACTION_TYPE_DEFERRED
        ret_val = ReturnValueConcept("some_name", True, ParserResultConcept(value=[rule]), True)
        evaluator = RuleEvaluator()

        result = evaluator.eval(context, ret_val)

        assert result.who == evaluator.name
        assert not result.status
        assert sheerka.isinstance(result.value, BuiltinConcepts.UNKNOWN_RULE)
        assert result.value.body == [('id', 'unknown variable')]
        assert result.parents == [ret_val]