from core.builtin_concepts import ParserResultConcept, BuiltinConcepts
from evaluators.BaseEvaluator import OneReturnValueEvaluator
from parsers.ConceptLexerParser import ConceptNode, UnrecognizedTokensNode


class ConceptNodeEvaluator(OneReturnValueEvaluator):
    """
    After a BNF is recognized, generates the concept or the list concepts
    """

    NAME = "ConceptNode"

    def __init__(self):
        super().__init__(self.NAME, [BuiltinConcepts.EVALUATION], 60)

    def matches(self, context, return_value):
        if not return_value.status:
            return False

        if not isinstance(return_value.value, ParserResultConcept):
            return False

        return (
            isinstance(return_value.value.value, ConceptNode) or
            isinstance(return_value.value.value, UnrecognizedTokensNode) or
            (
                hasattr(return_value.value.value, "__iter__") and
                len(return_value.value.value) > 0 and
                (
                    isinstance(return_value.value.value[0], ConceptNode) or
                    isinstance(return_value.value.value[0], UnrecognizedTokensNode)
                )
            )
        )

    def eval(self, context, return_value):
        """
        From a concept node, creates a new concept
        and makes sure that the properties are correctly set
        """
        sheerka = context.sheerka
        nodes = return_value.value.value
        if not hasattr(nodes, "__iter__"):
            nodes = [nodes]

        concepts = []
        error_found = False
        source = ""
        for node in nodes:
            if isinstance(node, ConceptNode):
                source += node.source if source == "" else (" " + node.source)
                concepts.append(node.concept)
            else:
                error_found = True

        if len(concepts) == 1:
            return sheerka.ret(
                self.name,
                not error_found,
                context.sheerka.new(
                    BuiltinConcepts.PARSER_RESULT,
                    parser=self,
                    source=source,
                    body=concepts[0],
                    try_parsed=None),
                parents=[return_value])

        return sheerka.ret(self.name, False, sheerka.new(BuiltinConcepts.NOT_FOR_ME), parents=[return_value])