import ast
import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.concept import Concept, ConceptParts, DoNotResolve
from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, StrMatch, UnrecognizedTokensNode, SourceCodeNode
from parsers.PythonParser import PythonNode
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):

    def from_parsing(self, context, grammar, expression):
        parser = ConceptLexerParser()
        parser.initialize(context, grammar)

        ret_val = parser.parse(context, 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))

    def init(self, concept, grammar, text):
        context = self.get_context()
        if isinstance(concept, list):
            for c in concept:
                context.sheerka.add_in_cache(c)
        else:
            context.sheerka.add_in_cache(concept)
        ret_val = self.from_parsing(context, grammar, text)
        node = ret_val.value.value[0]

        return context, node

    @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):
        context = self.get_context()
        assert LexerNodeEvaluator().matches(context, ret_val) == expected

    def test_concept_is_returned_when_only_one_in_the_list(self):
        foo = Concept("foo")
        context = self.get_context()
        context.sheerka.add_in_cache(foo)

        ret_val = self.from_parsing(context, {foo: StrMatch("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 == Concept("foo").init_key()
        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]