import pytest
from core.builtin_concepts_ids import BuiltinConcepts
from evaluators.MultipleSuccessEvaluator import MultipleSuccessEvaluator

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.evaluators.EvaluatorTestsUtils import p_ret_val_true, reduced_requested, e_ret_val_new, p_ret_val_false, \
    e_ret_val_false, ret_val


class TestMultipleSuccessEvaluator(TestUsingMemoryBasedSheerka):

    @pytest.mark.parametrize("return_values, expected", [
        ([p_ret_val_true()], False),  # all remaining parsers must be in error

        ([e_ret_val_false()], False),  # all remaining evaluators must be successful

        ([e_ret_val_new("foo"),
          e_ret_val_new("foo")], False),  # same returns values

        ([e_ret_val_new("foo", body=1),
          e_ret_val_new("foo", body=1)], False),  # same returns values

        ([reduced_requested,
          e_ret_val_new("foo"),
          e_ret_val_new("bar"),
          p_ret_val_false("value")], True),
    ])
    def test_i_can_match(self, return_values, expected):
        sheerka, context = self.init_concepts()
        evaluator = MultipleSuccessEvaluator()

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

    def test_i_can_eval(self):
        sheerka, context = self.init_concepts()
        evaluator = MultipleSuccessEvaluator()

        ret1 = e_ret_val_new("foo")
        ret2 = e_ret_val_new("bar")
        parser_in_error = p_ret_val_false("value")
        return_values = [reduced_requested,
                         ret1,
                         ret2,
                         parser_in_error,
                         ret_val("success value not coming from evaluator")]

        assert evaluator.matches(context, return_values)

        res = evaluator.eval(context, return_values)

        assert sheerka.isinstance(res, BuiltinConcepts.RETURN_VALUE)
        assert res.who == evaluator.name
        assert res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.MULTIPLE_SUCCESS)
        assert res.body.body == [ret1, ret2]
        assert res.parents == [reduced_requested, ret1, ret2, parser_in_error]