import pytest

from core.concept import Concept
from evaluators.ResolveMultiplePluralAmbiguityEvaluator import ResolveMultiplePluralAmbiguityEvaluator
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.evaluators.EvaluatorTestsUtils import cnode_ret_val, exact, new_plural, pr_ret_val, python_ret_val, sequence, \
    sya


class TestResolveMultiplePluralAmbiguityEvaluator(TestUsingMemoryBasedSheerka):

    @pytest.mark.parametrize("return_values, expected", [
        ([python_ret_val("numbers"), cnode_ret_val(new_plural("numbers"), parser=sequence)], True),
        ([python_ret_val("numbers"), cnode_ret_val(new_plural("numbers"), parser=sequence), pr_ret_val("other")], True),
        ([python_ret_val("numbers"), cnode_ret_val(new_plural("numbers"), parser=sya)], False),
        ([python_ret_val("numbers"), cnode_ret_val(Concept("numbers"), parser=sequence)], False),
        ([python_ret_val("numbers"), pr_ret_val(new_plural("numbers"), parser=exact)], False),
    ])
    def test_i_can_match(self, return_values, expected):
        context = self.get_context()
        assert ResolveMultiplePluralAmbiguityEvaluator().matches(context, return_values) == expected

    def test_i_can_eval_when_nothing_in_memory(self):
        sheerka, context = self.init_test().unpack()

        return_values = [
            python_ret_val("numbers"),
            cnode_ret_val(new_plural("numbers"), source="source", parser=sequence)
        ]

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

        rets = evaluator.eval(context, return_values)
        assert len(rets) == 1
        ret = rets[0]
        assert ret.who == evaluator.name
        assert ret.status == return_values[1].status
        assert ret.value == return_values[1].value
        assert ret.parents == return_values

    def test_i_can_eval_when_plural_in_memory(self):
        sheerka, context = self.init_test().unpack()
        sheerka.add_to_memory(context, "numbers", "something")

        return_values = [
            python_ret_val("numbers"),
            cnode_ret_val(new_plural("numbers"), source="source", parser=sequence)
        ]

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

        rets = evaluator.eval(context, return_values)
        assert len(rets) == 1
        ret = rets[0]
        assert ret.who == evaluator.name
        assert ret.status == return_values[0].status
        assert ret.value == return_values[0].value
        assert ret.parents == return_values