import ast

import pytest
from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.concept import Concept, ConceptParts, DoNotResolve
from core.sheerka.services.SheerkaExecute import ParserInput
from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
from parsers.BaseNodeParser import SourceCodeNode, ConceptNode, UnrecognizedTokensNode
from parsers.BnfNodeParser import BnfNodeParser
from parsers.PythonParser import PythonNode

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):

    def init_from_concepts(self, context, concepts, expression):
        parser = BnfNodeParser()
        parser.init_from_concepts(context, concepts)

        ret_val = parser.parse(context, ParserInput(expression))
        assert ret_val.status
        return ret_val

    def from_fragments(self, *fragments):
        nodes = []
        for fragment in fragments:
            if isinstance(fragment, str):
                node = PythonNode(fragment, ast.parse(fragment.strip(), mode="eval"))
                nodes.append(SourceCodeNode(node, 0, 0, [], fragment))
            else:
                nodes.append(ConceptNode(fragment, 0, 0, [], fragment.name))

        return ReturnValueConcept("somme_name", True, ParserResultConcept(value=nodes))

    @pytest.mark.parametrize("ret_val, expected", [
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), True),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), True),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=[SourceCodeNode(0, 0, [])])), True),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=SourceCodeNode(0, 0, []))), True),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=[UnrecognizedTokensNode(0, 0, [])])), False),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=[SourceCodeNode(0, 0, [])])), False),
        (ReturnValueConcept("some_name", False, ParserResultConcept(value=SourceCodeNode(0, 0, []))), False),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value="Not a concept node")), False),
        (ReturnValueConcept("some_name", True, ParserResultConcept(value=["Not a concept node"])), False),
        (ReturnValueConcept("some_name", True, [ConceptNode(Concept(), 0, 0)]), False),
        (ReturnValueConcept("some_name", True, ConceptNode(Concept(), 0, 0)), False),
    ])
    def test_i_can_match(self, ret_val, expected):
        sheerka = self.get_sheerka(singleton=True)
        context = self.get_context(sheerka)
        assert LexerNodeEvaluator().matches(context, ret_val) == expected

    def test_concept_is_returned_when_only_one_in_the_list(self):
        sheerka, context, foo = self.init_concepts(self.bnf_concept("foo"), singleton=True)
        ret_val = self.init_from_concepts(context, [foo], "foo")

        evaluator = LexerNodeEvaluator()
        result = evaluator.eval(context, ret_val)
        wrapper = result.body
        return_value = result.body.body

        assert result.who == evaluator.name
        assert result.status
        assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
        assert wrapper.parser == evaluator
        assert wrapper.source == "foo"
        assert return_value == foo
        assert return_value.compiled[ConceptParts.BODY] == DoNotResolve("foo")
        assert result.parents == [ret_val]

    def test_concept_python_node_is_returned_when_source_code(self):
        context = self.get_context()
        foo = Concept("foo")
        ret_val = self.from_fragments(foo, " + 1")

        evaluator = LexerNodeEvaluator()
        result = evaluator.eval(context, ret_val)
        wrapper = result.body
        return_value = result.body.body

        assert result.who == evaluator.name
        assert result.status
        assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
        assert wrapper.parser == evaluator
        assert wrapper.source == "foo + 1"

        assert return_value == PythonNode('foo + 1', ast.parse("__C__foo__C__ + 1", mode="eval"))
        assert return_value.concepts == {"__C__foo__C__": foo}
        assert result.parents == [ret_val]