from core.builtin_concepts_ids import BuiltinConcepts
from core.sheerka.Sheerka import ExecutionContext


class BaseEvaluator:
    """
    Base class to evaluate ReturnValues
    """

    PREFIX = "evaluators."

    def __init__(self, name, steps, priority: int, enabled=True):
        self.name = BaseEvaluator.get_name(name)
        self.short_name = name
        self.steps = steps
        self.priority = priority
        self.enabled = enabled

    def __repr__(self):
        return f"{self.name} ({self.priority})"

    def __eq__(self, other):
        if not isinstance(other, BaseEvaluator):
            return False

        return self.name == other.name and \
               self.priority == other.priority and \
               self.steps == other.steps and \
               self.enabled == other.enabled

    def __hash__(self):
        return hash((self.name, self.priority, self.steps, self.enabled))

    def reset(self):
        pass

    @staticmethod
    def get_name(name):
        return BaseEvaluator.PREFIX + name


class OneReturnValueEvaluator(BaseEvaluator):
    """
    Evaluate one specific return value
    """

    def matches(self, context: ExecutionContext, return_value):
        pass

    def eval(self, context: ExecutionContext, return_value):
        pass


class AllReturnValuesEvaluator(BaseEvaluator):
    """
    Evaluates the groups of ReturnValues
    """

    def __init__(self, name, steps, priority: int, enabled=True):
        super().__init__(name, steps, priority, enabled)
        self.eaten = []

    def matches(self, context: ExecutionContext, return_values):
        pass

    def eval(self, context: ExecutionContext, return_values):
        pass

    def reset(self):
        self.eaten.clear()

    @staticmethod
    def valid_parser_results(context, return_values):
        return [ret for ret in return_values if
                ret.status and context.sheerka.isinstance(ret.body, BuiltinConcepts.PARSER_RESULT)]