import pytest
from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from evaluators.ResolveAmbiguityEvaluator import ResolveAmbiguityEvaluator

from tests.BaseTest import BaseTest
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


pretval = BaseTest.pretval


class TestResolveAmbiguityEvaluator(TestUsingMemoryBasedSheerka):

    @pytest.mark.parametrize("return_values, expected", [
        ([pretval(Concept("foo"), source="source"), pretval(Concept("bar"), source="source")], True),
        ([pretval(Concept("foo"), source="source"), pretval(Concept("bar"), source="source", status=False)], False),
        ([pretval(Concept("foo"), source="source1"), pretval(Concept("bar"), source="source2")], False),
    ])
    def test_i_can_match(self, return_values, expected):
        context = self.get_context()
        assert ResolveAmbiguityEvaluator().matches(context, return_values) == expected

    def test_i_can_manage_when_no_source(self):
        context = self.get_context()
        return_values = [BaseTest.retval(Concept("foo"))]

        assert not ResolveAmbiguityEvaluator().matches(context, return_values)

    def test_i_can_eval(self):
        context = self.get_context()
        return_values = [
            self.pretval(Concept("hello a").def_var("a", "world"), "hello word"),
            self.pretval(Concept("hello world"), "hello word"),
            self.pretval(Concept("hello world", pre="False"), "hello word"),
            self.retval(Concept("not a parser result")),
            self.retval(Concept("status is false"), status=False),
            self.pretval(Concept("false parser result"), status=False),
        ]

        evaluator = ResolveAmbiguityEvaluator()
        evaluator.matches(context, return_values)
        res = evaluator.eval(context, return_values)

        assert len(res) == 1
        resolved = res[0]

        assert resolved.who == evaluator.name
        assert resolved.body == return_values[1].body
        assert resolved.parents == [
            return_values[0],
            return_values[1],
            return_values[2],
        ]

    def test_i_can_eval_all_fail(self):
        context = self.get_context()
        return_values = [
            self.pretval(Concept("hello world", pre="2 < 1"), "hello word"),
            self.pretval(Concept("hello world", pre="False"), "hello word"),
        ]

        evaluator = ResolveAmbiguityEvaluator()
        evaluator.matches(context, return_values)
        res = evaluator.eval(context, return_values)

        assert len(res) == 1
        resolved = res[0]

        assert resolved.who == evaluator.name
        assert resolved.body == BuiltinConcepts.NO_RESULT
        assert resolved.parents == [
            return_values[0],
            return_values[1],
        ]

    def test_i_can_eval_all_pass(self):
        """
        If they all pass, that means that no concept was reduced
        -> We need to act like resolve ambiguity was not called
        :return:
        """
        context = self.get_context()
        return_values = [
            self.pretval(Concept("hello world 1"), "hello word"),
            self.pretval(Concept("hello world 2"), "hello word"),
        ]

        evaluator = ResolveAmbiguityEvaluator()
        evaluator.matches(context, return_values)
        res = evaluator.eval(context, return_values)

        assert res is None