import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.concept import Concept
from core.sheerka import Sheerka, ExecutionContext
from evaluators.ConceptNodeEvaluator import ConceptNodeEvaluator
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence, TerminalNode, \
    StrMatch, Optional, OrderedChoice, ZeroOrMore, UnrecognizedTokensNode, ConceptMatch
from sdp.sheerkaDataProvider import Event


def get_context():
    sheerka = Sheerka(skip_builtins_in_db=True)
    sheerka.initialize("mem://")
    return ExecutionContext("test", Event(), sheerka)


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

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


def init(concept, grammar, text):
    context = 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 = 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=[UnrecognizedTokensNode(0, 0, [])])), True),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), True),
    (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=[UnrecognizedTokensNode(0, 0, [])])), False),
    (ReturnValueConcept("some_name", False, ParserResultConcept(value=UnrecognizedTokensNode(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(ret_val, expected):
    context = get_context()
    assert ConceptNodeEvaluator().matches(context, ret_val) == expected


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

    evaluator = ConceptNodeEvaluator()
    ret_val = from_parsing(context, {foo: StrMatch("foo")}, "foo")

    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", body="foo").init_key()
    assert return_value.metadata.is_evaluated
    assert result.parents == [ret_val]