from core.BuiltinConcepts import BuiltinConcepts
from core.ExecutionContext import ContextActions, ExecutionContext
from core.ReturnValue import ReturnValue
from core.concept import Concept
from evaluators.base_evaluator import EvaluatorEvalResult, EvaluatorMatchResult, NotForMe, OneReturnValueEvaluator
from parsers.SimpleConceptsParser import SimpleConceptsParser
from parsers.state_machine import MetadataToken


class RecognizeSimpleConcept(OneReturnValueEvaluator):
    """
    class that recognizes concepts in the input
    It only focuses on concepts thot do not require parameter
    """
    NAME = "RecognizeSimpleConcept"

    def __init__(self):
        super().__init__(self.NAME, ContextActions.PARSING, 80)
        self.parser = SimpleConceptsParser()

    def matches(self, context: ExecutionContext, return_value: ReturnValue) -> EvaluatorMatchResult:
        return EvaluatorMatchResult(return_value.status and
                                    context.sheerka.isinstance(return_value.value, BuiltinConcepts.PARSER_INPUT))

    def eval(self, context: ExecutionContext,
             evaluation_context: object,
             return_value: ReturnValue) -> EvaluatorEvalResult:
        parser_input = return_value.value.body
        parser_input.reset()

        error_sink = []
        parsed = self.parser.parse(context, parser_input, error_sink)

        if len(parsed.items) == 0:
            not_for_me = ReturnValue(self.NAME, False, NotForMe(self.NAME, return_value.value))
            return EvaluatorEvalResult([not_for_me], [])

        new = []
        for sequence in parsed.items:
            instantiated = []
            has_unrecognized = False
            for item in sequence:
                # instantiate the concept
                if isinstance(item, MetadataToken):
                    concept = context.sheerka.newi(item.metadata.id)
                    concept.get_runtime_info().info["resolution_method"] = item.resolution_method
                    instantiated.append(concept)
                else:
                    instantiated.append(item.buffer)
                    has_unrecognized = True

            if has_unrecognized:
                parser_result = context.sheerka.newn(BuiltinConcepts.PARSER_RESULT, result=instantiated)
                new.append(ReturnValue(self.NAME, False, parser_result, [return_value]))
            else:
                # remove whitespaces first
                instantiated = [item for item in instantiated if isinstance(item, Concept) or not item.isspace()]
                to_return = instantiated[0] if len(instantiated) == 1 else instantiated
                new.append(ReturnValue(self.NAME, True, to_return, [return_value]))

        return EvaluatorEvalResult(new, [return_value])