import os
import shutil
from os import path

import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.concept import Concept
from core.sheerka import Sheerka, ExecutionContext
from evaluators.ConceptEvaluator import ConceptEvaluator
from parsers.BaseParser import BaseParser

tests_root = path.abspath("../build/tests")
root_folder = "init_folder"


@pytest.fixture(autouse=True)
def init_test():
    if path.exists(tests_root):
        shutil.rmtree(tests_root)

    if not path.exists(tests_root):
        os.makedirs(tests_root)
    current_pwd = os.getcwd()
    os.chdir(tests_root)

    yield None
    os.chdir(current_pwd)


def get_context():
    sheerka = Sheerka()
    sheerka.initialize(root_folder)
    return ExecutionContext("test", "xxx", sheerka)


@pytest.mark.parametrize("ret_val, expected", [
    (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, Concept()), True),
    (ReturnValueConcept(BaseParser.PREFIX + "some_name", False, Concept()), False),
    (ReturnValueConcept("Not a parser", True, Concept()), False),
    (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, "not a concept"), False),
    (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, ParserResultConcept()), False),
])
def test_i_can_match(ret_val, expected):
    context = get_context()
    assert ConceptEvaluator().matches(context, ret_val) == expected


def test_concept_is_returned_when_no_body():
    context = get_context()
    concept = Concept(name="one").init_key()

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept)
    result = evaluator.eval(context, item)

    assert result.who == evaluator.name
    assert result.status
    assert result.value == concept
    assert result.parents == [item]


def test_body_is_evaluated_when_python_body():
    context = get_context()
    concept = Concept(name="one", body="1").init_key()

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept)
    result = evaluator.eval(context, item)

    assert result.who == evaluator.name
    assert result.status
    assert result.value == 1
    assert result.parents == [item]


def test_body_is_evaluated_when_concept_body():
    context = get_context()
    concept_one = Concept(name="one").init_key()
    context.sheerka.add_in_cache(concept_one)
    concept_un = Concept(name="un", body="one").init_key()

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_un)
    result = evaluator.eval(context, item)

    assert result.who == evaluator.name
    assert result.status
    assert result.value == concept_one
    assert result.parents == [item]


def test_body_is_evaluated_when_concept_body_with_a_body():
    """
    The concept refers to another concept which has a body
    :return:
    """
    context = get_context()
    concept_one = Concept(name="one", body="1").init_key()
    context.sheerka.add_in_cache(concept_one)
    concept_un = Concept(name="un", body="one").init_key()

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_un)
    result = evaluator.eval(context, item)

    assert result.who == evaluator.name
    assert result.status
    assert result.value == 1
    assert result.parents == [item]


def test_i_can_evaluate_longer_chains():
    context = get_context()
    context.sheerka.add_in_cache(Concept(name="a", body="'a'").init_key())
    context.sheerka.add_in_cache(Concept(name="b", body="a").init_key())
    context.sheerka.add_in_cache(Concept(name="c", body="b").init_key())
    concept_d = context.sheerka.add_in_cache(Concept(name="d", body="c").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_d)
    result = evaluator.eval(context, item)

    assert result.status
    assert result.value == 'a'


def test_i_can_evaluate_longer_chains_2():
    context = get_context()
    concept_a = context.sheerka.add_in_cache(Concept(name="a").init_key())
    context.sheerka.add_in_cache(Concept(name="b", body="a").init_key())
    context.sheerka.add_in_cache(Concept(name="c", body="b").init_key())
    concept_d = context.sheerka.add_in_cache(Concept(name="d", body="c").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_d)
    result = evaluator.eval(context, item)

    assert result.status
    assert result.value == concept_a


def test_i_can_recognize_concept_properties():
    """
    The concept 'plus' has some properties.
    Let's check if they are recognized as concepts
    :return:
    """
    context = get_context()
    concept_one = context.sheerka.add_in_cache(Concept(name="one").init_key())
    concept_two = context.sheerka.add_in_cache(Concept(name="two").init_key())
    concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b")
                                                .set_prop("a", "one")
                                                .set_prop("b", "two").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_plus)
    result = evaluator.eval(context, item)

    assert result.status
    assert context.sheerka.isinstance(result.value, concept_plus)
    assert result.value.props["a"].value == concept_one
    assert result.value.props["b"].value == concept_two


def test_i_can_recognize_concept_properties_with_body():
    """
    The concept 'plus' has some properties.
    Let's check if they are recognized as concepts with Python code
    :return:
    """
    context = get_context()
    context.sheerka.add_in_cache(Concept(name="one", body="1").init_key())
    context.sheerka.add_in_cache(Concept(name="two", body="2").init_key())
    concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b")
                                                .set_prop("a", "one")
                                                .set_prop("b", "two").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_plus)
    result = evaluator.eval(context, item)

    assert result.status
    assert context.sheerka.isinstance(result.value, concept_plus)
    assert result.value.props["a"].value == 1
    assert result.value.props["b"].value == 2


def test_i_can_recognize_concept_properties_with_body_when_concept_has_a_body():
    context = get_context()
    context.sheerka.add_in_cache(Concept(name="one", body="1").init_key())
    context.sheerka.add_in_cache(Concept(name="two", body="2").init_key())
    concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b", body="a + b")
                                                .set_prop("a", "one")
                                                .set_prop("b", "two").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_plus)
    result = evaluator.eval(context, item)

    assert result.status
    assert result.value == 3


def test_i_cannot_recognize_a_concept_if_one_of_the_prop_is_unknown():
    context = get_context()
    context.sheerka.add_in_cache(Concept(name="one").init_key())
    concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b")
                                                .set_prop("a", "one")
                                                .set_prop("b", "two").init_key())

    evaluator = ConceptEvaluator()
    item = ReturnValueConcept(BaseParser.PREFIX + "some_name", True, concept_plus)
    result = evaluator.eval(context, item)

    assert not result.status
    assert context.sheerka.isinstance(result.value, BuiltinConcepts.PROPERTY_EVAL_ERROR)
    assert result.value.property_name == "b"
    assert context.sheerka.isinstance(result.value.error, BuiltinConcepts.TOO_MANY_ERRORS)
    assert result.value.concept == concept_plus