# Make sure that the evaluators works as expected
from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from core.sheerka import Sheerka, ExecutionContext
from evaluators.BaseEvaluator import OneReturnValueEvaluator, BaseEvaluator


def get_sheerka():
    sheerka = Sheerka()
    sheerka.initialize("mem://")
    return sheerka


def get_context(sheerka):
    return ExecutionContext("test", "xxx", sheerka)


def get_ret_val(sheerka, concept, who="who"):
    concept.init_key()
    if concept.key not in sheerka.concepts_cache:
        sheerka.concepts_cache[concept.key] = concept
    return sheerka.ret(who, True, sheerka.new(concept.key))


class EvaluatorWithPriority(OneReturnValueEvaluator):
    out = []

    def __init__(self, name, priority):
        super().__init__(name, priority)

    def matches(self, context, return_value):
        target = str(return_value.body.key)
        step = str(context.step)
        text = f"{step} [{context.iteration}] "
        text += f"{self.name[len(BaseEvaluator.PREFIX):]} - matches - target={target}"
        self.out.append(text)
        return True

    def eval(self, context, return_value):
        target = str(return_value.body.key)
        step = str(context.step)
        text = f"{step} [{context.iteration}] "
        text += f"{self.name[len(BaseEvaluator.PREFIX):]} - eval - target={target}"
        self.out.append(text)


class EvaluatorWithPriority10(EvaluatorWithPriority):
    def __init__(self):
        super().__init__("priority10", 10)


class EvaluatorWithPriority15(EvaluatorWithPriority):
    def __init__(self):
        super().__init__("priority15", 15)


class EvaluatorWithPriority20(EvaluatorWithPriority):
    def __init__(self):
        super().__init__("priority20", 20)


class EvaluatorModifyFoo(EvaluatorWithPriority):
    def __init__(self):
        super().__init__("modifyFoo", 10)

    def matches(self, context, return_value):
        super().matches(context, return_value)
        return context.sheerka.isinstance(return_value.body, "foo")

    def eval(self, context, return_value):
        super().eval(context, return_value)
        return get_ret_val(context.sheerka, Concept("bar"))


class EvaluatorModifyBar(EvaluatorWithPriority):
    def __init__(self):
        super().__init__("modifyBar", 10)

    def matches(self, context, return_value):
        super().matches(context, return_value)
        return context.sheerka.isinstance(return_value.body, "bar")

    def eval(self, context, return_value):
        super().eval(context, return_value)
        return get_ret_val(context.sheerka, Concept("baz"))


def test_that_return_values_is_unchanged_when_no_evaluator():
    sheerka = get_sheerka()
    sheerka.evaluators = []

    entries = get_ret_val(sheerka, Concept("foo"))
    return_values = sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])

    assert return_values == [entries]


def test_i_can_use_a_list_as_input():
    sheerka = get_sheerka()
    sheerka.evaluators = []

    entries = [get_ret_val(sheerka, Concept("foo"))]
    return_values = sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])

    assert return_values == entries


def test_step_concept_is_removed_after_processing_if_not_reduced():
    """
    The entry is not modified by an evaluator
    """
    sheerka = get_sheerka()
    sheerka.evaluators = [EvaluatorWithPriority10]

    entry = get_ret_val(sheerka, Concept("foo"))
    return_values = sheerka.execute(get_context(sheerka), entry, [BuiltinConcepts.EVALUATION])

    assert BuiltinConcepts.EVALUATION not in [r.body.key for r in return_values]


def test_step_concept_is_removed_after_processing_if_not_reduced_2():
    """
    This time the entry is modified by an evaluator,
    nevertheless, step concept is removed
    """
    sheerka = get_sheerka()
    sheerka.evaluators = [EvaluatorModifyFoo]

    entry = get_ret_val(sheerka, Concept("foo"))
    return_values = sheerka.execute(get_context(sheerka), entry, [BuiltinConcepts.EVALUATION])

    assert BuiltinConcepts.EVALUATION not in [r.body.key for r in return_values]


def test_that_higher_priority_evaluators_are_evaluated_first():
    sheerka = get_sheerka()
    sheerka.evaluators = [EvaluatorWithPriority20, EvaluatorWithPriority10, EvaluatorWithPriority15]

    entries = [get_ret_val(sheerka, Concept("foo"))]
    EvaluatorWithPriority.out = []
    sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])

    assert EvaluatorWithPriority.out == [
        '__EVALUATION [0] priority20 - matches - target=foo',
        '__EVALUATION [0] priority20 - eval - target=foo',
        '__EVALUATION [0] priority20 - matches - target=__EVALUATION',
        '__EVALUATION [0] priority20 - eval - target=__EVALUATION',
        '__EVALUATION [0] priority15 - matches - target=foo',
        '__EVALUATION [0] priority15 - eval - target=foo',
        '__EVALUATION [0] priority15 - matches - target=__EVALUATION',
        '__EVALUATION [0] priority15 - eval - target=__EVALUATION',
        '__EVALUATION [0] priority10 - matches - target=foo',
        '__EVALUATION [0] priority10 - eval - target=foo',
        '__EVALUATION [0] priority10 - matches - target=__EVALUATION',
        '__EVALUATION [0] priority10 - eval - target=__EVALUATION']


def test_that_predicate_is_checked_before_evaluation():
    sheerka = get_sheerka()
    sheerka.evaluators = [EvaluatorModifyFoo]

    entries = [get_ret_val(sheerka, Concept("foo")), get_ret_val(sheerka, Concept("baz"))]
    EvaluatorWithPriority.out = []
    sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])

    assert EvaluatorWithPriority.out == [
        '__EVALUATION [0] modifyFoo - matches - target=foo',
        '__EVALUATION [0] modifyFoo - eval - target=foo',
        '__EVALUATION [0] modifyFoo - matches - target=baz',
        '__EVALUATION [0] modifyFoo - matches - target=__EVALUATION',
        '__EVALUATION [1] modifyFoo - matches - target=bar',
        '__EVALUATION [1] modifyFoo - matches - target=baz',
        '__EVALUATION [1] modifyFoo - matches - target=__EVALUATION'
    ]


def test_evaluation_continue_until_no_more_modification():
    sheerka = get_sheerka()
    sheerka.evaluators = [EvaluatorModifyFoo, EvaluatorModifyBar]

    entries = [get_ret_val(sheerka, Concept("foo")), get_ret_val(sheerka, Concept("baz"))]
    EvaluatorWithPriority.out = []
    sheerka.execute(get_context(sheerka), entries, [BuiltinConcepts.EVALUATION])

    assert EvaluatorWithPriority.out == [
        '__EVALUATION [0] modifyFoo - matches - target=foo',
        '__EVALUATION [0] modifyFoo - eval - target=foo',
        '__EVALUATION [0] modifyFoo - matches - target=baz',
        '__EVALUATION [0] modifyFoo - matches - target=__EVALUATION',
        '__EVALUATION [0] modifyBar - matches - target=foo',
        '__EVALUATION [0] modifyBar - matches - target=baz',
        '__EVALUATION [0] modifyBar - matches - target=__EVALUATION',
        '__EVALUATION [1] modifyFoo - matches - target=bar',
        '__EVALUATION [1] modifyFoo - matches - target=baz',
        '__EVALUATION [1] modifyFoo - matches - target=__EVALUATION',
        '__EVALUATION [1] modifyBar - matches - target=bar',
        '__EVALUATION [1] modifyBar - eval - target=bar',
        '__EVALUATION [1] modifyBar - matches - target=baz',
        '__EVALUATION [1] modifyBar - matches - target=__EVALUATION',
        '__EVALUATION [2] modifyFoo - matches - target=baz',
        '__EVALUATION [2] modifyFoo - matches - target=baz',
        '__EVALUATION [2] modifyFoo - matches - target=__EVALUATION',
        '__EVALUATION [2] modifyBar - matches - target=baz',
        '__EVALUATION [2] modifyBar - matches - target=baz',
        '__EVALUATION [2] modifyBar - matches - target=__EVALUATION'
    ]