import pytest

from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
from core.concept import Concept
from evaluators.BaseEvaluator import BaseEvaluator
from evaluators.MultipleErrorsEvaluator import MultipleErrorsEvaluator
from parsers.BaseParser import BaseParser
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


def r(value, status=True):
    return ReturnValueConcept(value, status, value)


def eval_false(name, value="value"):
    return ReturnValueConcept(BaseEvaluator.PREFIX + name, False, value)


def eval_true(name):
    return ReturnValueConcept(BaseEvaluator.PREFIX + name, True, "value")


def parser_false(name):
    return ReturnValueConcept(BaseParser.PREFIX + name, False, "value")


def parser_true(name):
    return ReturnValueConcept(BaseParser.PREFIX + name, True, "value")


reduce_requested = ReturnValueConcept(
    "some_name",
    True,
    Concept(name=BuiltinConcepts.REDUCE_REQUESTED, key=BuiltinConcepts.REDUCE_REQUESTED))


class TestMultipleErrorsEvaluator(TestUsingMemoryBasedSheerka):
    @pytest.mark.parametrize("return_values, expected", [
        ([eval_false("one"), reduce_requested], False),
        ([eval_false("one"), eval_false("two"), reduce_requested], True),
        ([eval_false("one"), eval_false("two"), eval_false("three"), reduce_requested], True),
        ([eval_false("one"), eval_false("two"), parser_false("one"), reduce_requested], True),
        ([eval_false("one"), eval_false("two"), parser_true("one"), reduce_requested], False),
        ([eval_false("one"), eval_false("two"), eval_true("three"), reduce_requested], False),
        ([eval_false("one"), eval_false("two"), r("other concept", False), reduce_requested], True),
        ([eval_false("one"), eval_false("two"), r("other concept", True), reduce_requested], True),
        ([eval_false("reduce not required 1"), eval_false("reduce not required 2")], False),
    ])
    def test_i_can_match(self, return_values, expected):
        context = self.get_context()
        assert MultipleErrorsEvaluator().matches(context, return_values) == expected

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

        return_values = [
            eval_false("one"),
            eval_false("two"),
            eval_false("three"),
            parser_false("one"),
            parser_false("two"),
            reduce_requested
        ]

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

        assert not res.status
        assert context.sheerka.isinstance(res.body, BuiltinConcepts.MULTIPLE_ERRORS)
        assert res.body.body == [eval_false("one"), eval_false("two"), eval_false("three")]
        assert len(res.parents) == 6

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

        a_successful_concept = r("successful concept")
        a_concept_in_error = r("concept in error", False)
        return_values = [
            eval_false("one"),
            eval_false("two"),
            parser_false("one"),
            a_successful_concept,
            a_concept_in_error,
            reduce_requested
        ]

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

        assert not res.status
        assert res.body.body == [eval_false("one"), eval_false("two")]
        assert len(res.parents) == 4

        assert a_successful_concept not in res.parents
        assert a_concept_in_error not in res.parents

    def test_filtered_results_are_not_considered_as_error(self):
        sheerka, context = self.init_concepts()

        filtered = sheerka.new(BuiltinConcepts.FILTERED)
        filtered_ret_val = eval_false("Filter", filtered)
        false_1 = eval_false("one")
        false_2 = eval_false("two")

        evaluator = MultipleErrorsEvaluator()
        assert not evaluator.matches(context, [filtered_ret_val, false_1, reduce_requested])

        evaluator.reset()
        return_values = [filtered_ret_val, false_1, false_2, reduce_requested]
        assert evaluator.matches(context, return_values)
        res = evaluator.eval(context, return_values)
        assert not res.status
        assert res.parents == return_values