import pytest

from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
from core.concept import Concept
from evaluators.EvalEvaluator import EvalEvaluator
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka

eval_requested = ReturnValueConcept("some_name", True, Concept(key=BuiltinConcepts.CONCEPT_EVAL_REQUESTED))


def retval(obj, who="who", status=True):
    """ret_val"""
    return ReturnValueConcept(who, status, obj)


class TestEvalEvaluator(TestUsingMemoryBasedSheerka):
    def test_i_can_match_and_eval(self):
        context = self.get_context()

        to_eval1 = ReturnValueConcept("some_name", True, Concept(name="2", body="to eval").auto_init())
        to_eval2 = ReturnValueConcept("some_name", True, Concept(name="3", body="also to eval").auto_init())

        return_values = [
            ReturnValueConcept("some_name", True, "not to eval"),
            ReturnValueConcept("some_name", True, Concept(name="not to eval")),
            ReturnValueConcept("some_name", False, Concept(name="1", body="'not to eval'")),
            to_eval1,
            to_eval2,
            eval_requested
        ]

        evaluator = EvalEvaluator()
        assert evaluator.matches(context, return_values)

        evaluated = evaluator.eval(context, return_values)
        assert len(evaluated) == 2
        assert evaluated[0].value == to_eval1.body.body
        assert evaluated[0].parents == [to_eval1, eval_requested]

        assert evaluated[1].value == to_eval2.body.body
        assert evaluated[1].parents == [to_eval2, eval_requested]

    @pytest.mark.parametrize("return_values, expected", [
        ([retval(Concept("foo", body="bar")), eval_requested], True),
        ([retval(Concept("status is false", body="bar"), status=False), eval_requested], True),
        ([retval("string_value"), eval_requested], True),
        ([retval(Concept("no body")), eval_requested], True),
        ([retval(Concept("eval requested missing", body="bar"))], False),
    ])
    def test_i_cannot_match_if_eval_request_is_not_present(self, return_values, expected):
        context = self.get_context()
        assert EvalEvaluator().matches(context, return_values) == expected

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

        return_values = [
            ReturnValueConcept("some_name", True, "not to eval"),
            ReturnValueConcept("some_name", True, Concept(name="not to eval")),
            ReturnValueConcept("some_name", False, Concept(name="1", body="not to eval")),
            eval_requested
        ]

        evaluator = EvalEvaluator()
        assert evaluator.matches(context, return_values)

        evaluated = evaluator.eval(context, return_values)
        assert evaluated == ReturnValueConcept(
            "evaluators.Eval",
            False,
            context.sheerka.new(BuiltinConcepts.CONCEPT_EVAL_REQUESTED))
        assert evaluated.parents == [eval_requested]

    def test_i_can_evaluate_sets(self):
        sheerka, context, foo, bar, baz, number = self.init_concepts(
            Concept("foo"),
            Concept("bar"),
            Concept("baz"),
            Concept("number"))
        sheerka.sets_handler.add_concepts_to_set(context, [foo, bar, baz], number)

        return_values = [retval(number), eval_requested]

        evaluator = EvalEvaluator()
        evaluator.matches(context, return_values)
        evaluated = evaluator.eval(context, return_values)

        assert len(evaluated) == 1
        assert evaluated[0].status
        assert evaluated[0].body == [foo, bar, baz]