import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
from core.concept import Concept
from core.sheerka import Sheerka, ExecutionContext
from evaluators.BaseEvaluator import BaseEvaluator
from evaluators.ConceptComposerEvaluator import ConceptComposerEvaluator
from parsers.BaseParser import BaseParser
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence
from sdp.sheerkaDataProvider import Event

concept_lexer_name = ConceptLexerParser().name


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


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

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


def init(concepts, grammar, expression):
    context = get_context()
    for c in concepts:
        context.sheerka.add_in_cache(c)
    return_values = get_return_values(context, grammar, expression)

    return context, return_values


@pytest.mark.parametrize("return_values, expected", [
    ([
         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
         ReturnValueConcept("not a parser", True, "some value"),
     ], True),
    ([
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
     ], True),
    ([
         ReturnValueConcept(BaseParser.PREFIX + "some_name", True, "not in error"),
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
     ], False),
    ([
         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
         ReturnValueConcept(concept_lexer_name, True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
     ], False),
    ([
         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
         ReturnValueConcept(concept_lexer_name, False, "some value"),
     ], False),
    ([
         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=["not a concept"])),
     ], False),
    ([
         ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", False, "evaluator in error"),
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
         ReturnValueConcept("not a parser", True, "some value"),
     ], False),
    ([
         ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, "evaluator"),
         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
         ReturnValueConcept("not a parser", True, "some value"),
     ], False),
])
def test_i_can_match(return_values, expected):
    context = get_context()
    assert ConceptComposerEvaluator().matches(context, return_values) == expected


def test_i_can_eval_simple_concepts():
    foo = Concept("foo", body="'foo'")
    bar = Concept("bar", body="'bar'")
    grammar = {}
    context, return_values = init([foo, bar], grammar, "bar foo")

    composer = ConceptComposerEvaluator()
    assert composer.matches(context, return_values)

    ret_val = composer.eval(context, return_values)
    assert ret_val.status
    assert ret_val.who == composer.name
    assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
    assert ret_val.value[0].metadata.is_evaluated
    assert ret_val.value[1].metadata.is_evaluated
    assert ret_val.parents == [return_values[0]]


def test_i_can_eval_simple_concepts_when_some_are_bnf():
    foo = Concept("foo", body="'foo'")
    bar = Concept("bar", body="'bar'")
    grammar = {foo: "foo"}
    context, return_values = init([foo, bar], grammar, "bar foo")

    composer = ConceptComposerEvaluator()
    assert composer.matches(context, return_values)

    ret_val = composer.eval(context, return_values)
    assert ret_val.status
    assert ret_val.who == composer.name
    assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
    assert ret_val.value[0].metadata.is_evaluated
    assert ret_val.value[1].metadata.is_evaluated
    assert ret_val.parents == [return_values[0]]


def test_i_can_eval_simple_concept_and_text():
    foo = Concept("foo", body="'foo'")
    grammar = {}
    context, return_values = init([foo], grammar, "'bar' foo")

    composer = ConceptComposerEvaluator()
    assert composer.matches(context, return_values)

    ret_val = composer.eval(context, return_values)
    assert ret_val.status
    assert ret_val.who == composer.name
    assert ret_val.value == "bar foo"
    assert ret_val.parents == [return_values[0]]