import pytest
from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
from core.concept import Concept
from core.sheerka.services.SheerkaIsAManager import SheerkaIsAManager
from evaluators.ReturnBodyEvaluator import ReturnBodyEvaluator

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


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()
        context.global_hints.add(BuiltinConcepts.RETURN_BODY_REQUESTED)

        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")),  # no body
            ReturnValueConcept("some_name", False, Concept(name="1", body="'not to eval'")),  # status is false
            to_eval1,
            to_eval2,
        ]

        evaluator = ReturnBodyEvaluator()
        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]

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

    @pytest.mark.parametrize("return_value", [
        retval(Concept("foo", body="bar")),
        retval(Concept("status is false", body="bar"), status=False),
        retval("string_value"),
        retval(Concept("no body")),
    ])
    def test_i_cannot_match_if_eval_request_is_not_present(self, return_value):
        context = self.get_context()
        assert not ReturnBodyEvaluator().matches(context, [return_value])

        context.global_hints.add(BuiltinConcepts.RETURN_BODY_REQUESTED)
        assert ReturnBodyEvaluator().matches(context, [return_value])

    def test_i_can_match_depending_on_builtin_concept_processing(self):
        context = self.get_context()
        context.global_hints.add(BuiltinConcepts.RETURN_BODY_REQUESTED)
        return_values = [ReturnValueConcept("some_name", True, Concept(name="2", body="to eval").auto_init())]
        evaluator = ReturnBodyEvaluator()

        # i match when no BuiltinConcepts.PROCESSING is found
        assert evaluator.matches(context, return_values)

        # i match when one BuiltinConcepts.PROCESSING is found
        root_processing = context.push(BuiltinConcepts.PROCESSING, {"step": BuiltinConcepts.EVALUATION}). \
            push(BuiltinConcepts.NOP, None)
        assert evaluator.matches(root_processing, return_values)

        # otherwise, i cannot match
        sub_root = root_processing.push(BuiltinConcepts.PROCESSING, {"step": BuiltinConcepts.EVALUATION}). \
            push(BuiltinConcepts.NOP, None)
        assert not evaluator.matches(sub_root, return_values)

    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"),  # not a concept
            ReturnValueConcept("some_name", True, Concept(name="not to eval")),  # no body
            ReturnValueConcept("some_name", False, Concept(name="1", body="not to eval")),  # no evaluated body
        ]

        evaluated = ReturnBodyEvaluator().eval(context, return_values)
        assert evaluated is None

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

        evaluated = ReturnBodyEvaluator().eval(context, [retval(number)])

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