import ast

import pytest
import os
from os import path
import shutil

from core import utils
from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
from core.concept import Concept, ConceptParts
from core.sheerka import Sheerka, ExecutionContext
from evaluators.MutipleSameSuccessEvaluator import MultipleSameSuccessEvaluator
from parsers.DefaultParser import DefaultParser
from parsers.PythonParser import PythonParser
from sdp.sheerkaDataProvider import SheerkaDataProvider, SheerkaDataProviderDuplicateKeyError

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 test_root_folder_is_created_after_initialization():
    return_value = Sheerka().initialize(root_folder)
    assert return_value.status, "initialisation should be successful"
    assert os.path.exists(root_folder), "init folder should be created"


def test_i_can_list_builtin_concepts():
    sheerka = get_sheerka()
    builtins = list(sheerka.get_builtins_classes_as_dict())

    assert str(BuiltinConcepts.ERROR) in builtins
    assert str(BuiltinConcepts.RETURN_VALUE) in builtins


def test_builtin_concepts_are_initialized():
    sheerka = get_sheerka()
    assert len(sheerka.concepts_cache) == len(BuiltinConcepts)
    for concept_name in BuiltinConcepts:
        assert str(concept_name) in sheerka.concepts_cache
        assert sheerka.sdp.get_safe(sheerka.CONCEPTS_ENTRY, str(concept_name)) is not None

    for key, concept_class in sheerka.get_builtins_classes_as_dict().items():
        assert isinstance(sheerka.concepts_cache[key], concept_class)


def test_builtin_concepts_can_be_updated():
    sheerka = get_sheerka()
    loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)
    loaded_sheerka.desc = "I have a description"
    sheerka.sdp.modify("Test", sheerka.CONCEPTS_ENTRY, loaded_sheerka.key, loaded_sheerka)

    sheerka = get_sheerka()
    loaded_sheerka = sheerka.get(BuiltinConcepts.SHEERKA)

    assert loaded_sheerka.desc == "I have a description"


def test_i_can_add_a_concept():
    sheerka = get_sheerka()
    concept = get_default_concept()

    res = sheerka.create_new_concept(get_context(sheerka), concept)

    assert res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.NEW_CONCEPT)

    concept_found = res.value.body
    for prop in Concept.props_to_serialize:
        assert getattr(concept_found, prop) == getattr(concept, prop)

    assert concept_found.key == "__var__0 + __var__1"
    assert concept_found.id == "1001"

    assert concept.key in sheerka.concepts_cache
    assert path.exists(sheerka.sdp.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_digest()))


def test_i_cannot_add_the_same_concept_twice():
    """
    Checks that duplicated concepts are managed by sheerka, not by sheerka.sdp
    :return:
    """
    sheerka = get_sheerka()
    concept = get_default_concept()

    sheerka.create_new_concept(get_context(sheerka), concept)
    res = sheerka.create_new_concept(get_context(sheerka), concept)

    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.ERROR)
    assert res.value.body.args[0] == "Duplicate object."


def test_i_can_get_a_builtin_concept_by_their_enum_or_the_string():
    """
    Checks that a concept can be found its name
    even when there are variables in the name (ex 'hello + a' or 'a + b' )
    :return:
    """
    sheerka = get_sheerka()
    for key in sheerka.get_builtins_classes_as_dict():
        assert sheerka.get(key) is not None
        assert sheerka.get(str(key)) is not None


def test_i_can_get_new_concept():
    sheerka = get_sheerka()
    concept = get_default_concept()

    sheerka.create_new_concept(get_context(sheerka), concept)

    from_cache = sheerka.get(concept.key)
    assert from_cache is not None
    assert from_cache.key == concept.key
    assert from_cache == concept


def test_i_first_look_in_local_cache():
    sheerka = get_sheerka()
    concept = get_default_concept()

    sheerka.create_new_concept(get_context(sheerka), concept)
    sheerka.concepts_cache[concept.key].pre = "I have modified the concept in cache"

    from_cache = sheerka.get(concept.key)
    assert from_cache is not None
    assert from_cache.key == concept.key
    assert from_cache.pre == "I have modified the concept in cache"


def test_i_can_get_a_known_concept_when_not_in_cache():
    """
    When not in cache, uses sdp
    :return:
    """
    sheerka = get_sheerka()
    concept = get_default_concept()
    sheerka.create_new_concept(get_context(sheerka), concept)

    sheerka.concepts_cache = {}  # reset the cache
    loaded = sheerka.get(concept.key)

    assert loaded is not None
    assert loaded == concept


def test_i_can_get_list_of_concept_when_same_key_when_no_cache():
    sheerka = get_sheerka()
    concept1 = get_default_concept()
    concept2 = get_default_concept()
    concept2.body = "a+b"

    res1 = sheerka.create_new_concept(get_context(sheerka), concept1)
    res2 = sheerka.create_new_concept(get_context(sheerka), concept2)

    assert res1.value.body.key == res2.value.body.key  # same key

    sheerka.concepts_cache = {}  # reset the cache

    from_cache = sheerka.get(concept1.key)
    assert len(from_cache) == 2
    assert from_cache[0] == concept1
    assert from_cache[1] == concept2


def test_i_can_get_list_of_concept_when_same_key_when_cache():
    sheerka = get_sheerka()
    concept1 = get_default_concept()
    concept2 = get_default_concept()
    concept2.body = "a+b"

    res1 = sheerka.create_new_concept(get_context(sheerka), concept1)
    res2 = sheerka.create_new_concept(get_context(sheerka), concept2)

    assert res1.value.body.key == res2.value.body.key  # same key

    # sheerka.concepts_cache = {}  # Do not reset the cache

    from_cache = sheerka.get(concept1.key)
    assert len(from_cache) == 2
    assert from_cache[0] == concept1
    assert from_cache[1] == concept2


def test_unknown_concept_is_return_when_the_concept_is_not_found():
    sheerka = get_sheerka()

    loaded = sheerka.get("fake_key")

    assert loaded is not None
    assert sheerka.isinstance(loaded, BuiltinConcepts.UNKNOWN_CONCEPT)
    assert loaded.body == "fake_key"


def test_i_can_instantiate_a_builtin_concept_when_it_has_its_own_class():
    sheerka = get_sheerka()
    ret = sheerka.new(BuiltinConcepts.RETURN_VALUE, who="who", status="status", value="value", message="message")

    assert isinstance(ret, ReturnValueConcept)
    assert ret.key == str(BuiltinConcepts.RETURN_VALUE)
    assert ret.who == "who"
    assert ret.status == "status"
    assert ret.value == "value"
    assert ret.message == "message"


def test_i_can_instantiate_a_builtin_concept_when_no_specific_class():
    sheerka = get_sheerka()
    ret = sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT, body="fake_concept")

    assert isinstance(ret, Concept)
    assert ret.key == str(BuiltinConcepts.UNKNOWN_CONCEPT)
    assert ret.body == "fake_concept"


def test_i_can_instantiate_a_concept():
    sheerka = get_sheerka()
    concept = get_default_concept()
    sheerka.create_new_concept(get_context(sheerka), concept)

    new = sheerka.new(concept.key, a=10, b="value")

    assert sheerka.isinstance(new, concept)
    for prop in Concept.props_to_serialize:
        assert getattr(new, prop) == getattr(concept, prop)

    assert new.props["a"].value == 10
    assert new.props["b"].value == "value"


def test_instances_are_different_when_asking_for_new():
    sheerka = get_sheerka()
    concept = get_default_concept()
    sheerka.create_new_concept(get_context(sheerka), concept)

    new1 = sheerka.new(concept.key, a=10, b="value")
    new2 = sheerka.new(concept.key, a=10, b="value")

    assert new1 == new2
    assert id(new1) != id(new2)


def test_i_get_the_same_instance_when_is_unique_is_true():
    sheerka = get_sheerka()
    concept = get_unique_concept()
    sheerka.create_new_concept(get_context(sheerka), concept)

    new1 = sheerka.new(concept.key, a=10, b="value")
    new2 = sheerka.new(concept.key, a=10, b="value")

    assert new1 == new2
    assert id(new1) == id(new2)


def test_i_cannot_instantiate_an_unknown_concept():
    sheerka = get_sheerka()

    new = sheerka.new("fake_concept")

    assert sheerka.isinstance(new, BuiltinConcepts.UNKNOWN_CONCEPT)
    assert new.body == "fake_concept"


def test_i_cannot_instantiate_when_properties_are_not_recognized():
    sheerka = get_sheerka()
    concept = get_default_concept()
    sheerka.create_new_concept(get_context(sheerka), concept)

    new = sheerka.new(concept.key, a=10, c="value")

    assert sheerka.isinstance(new, BuiltinConcepts.UNKNOWN_PROPERTY)
    assert new.property_name == "c"
    assert sheerka.isinstance(new.concept, concept)


def test_i_can_use_expect_one_when_empty():
    sheerka = get_sheerka()

    res = sheerka.expect_one(get_context(sheerka), [])
    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.IS_EMPTY)


def test_i_can_use_expect_one_when_too_many_success():
    sheerka = get_sheerka()

    items = [
        ReturnValueConcept("who", True, None),
        ReturnValueConcept("who", True, None),
    ]
    res = sheerka.expect_one(get_context(sheerka), items)
    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.TOO_MANY_SUCCESS)
    assert res.value.obj == items


def test_i_can_use_expect_when_only_errors_1():
    sheerka = get_sheerka()

    items = [
        ReturnValueConcept("who", False, None),
    ]
    res = sheerka.expect_one(get_context(sheerka), items)
    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.TOO_MANY_ERRORS)
    assert res.value.obj == items


def test_i_can_use_expect_when_only_errors_2():
    sheerka = get_sheerka()

    items = [
        ReturnValueConcept("who", False, None),
        ReturnValueConcept("who", False, None),
    ]
    res = sheerka.expect_one(get_context(sheerka), items)
    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.TOO_MANY_ERRORS)
    assert res.value.obj == items


def test_i_can_use_expect_one_when_one_success_1():
    sheerka = get_sheerka()

    items = [
        ReturnValueConcept("who", True, None),
    ]
    res = sheerka.expect_one(get_context(sheerka), items)
    assert res.status
    assert res == items[0]


def test_i_can_use_expect_one_when_one_success_2():
    sheerka = get_sheerka()

    items = [
        ReturnValueConcept("who", False, None),
        ReturnValueConcept("who", True, None),
        ReturnValueConcept("who", False, None),
    ]
    res = sheerka.expect_one(get_context(sheerka), items)
    assert res.status
    assert res == items[1]


def test_i_can_use_expect_one_when_not_a_list_true():
    sheerka = get_sheerka()

    res = sheerka.expect_one(get_context(sheerka), ReturnValueConcept("who", True, None))
    assert res.status
    assert res == ReturnValueConcept("who", True, None)


def test_i_can_use_expect_one_when_not_a_list_false():
    sheerka = get_sheerka()

    res = sheerka.expect_one(get_context(sheerka), ReturnValueConcept("who", False, None))

    assert not res.status
    assert sheerka.isinstance(res.value, BuiltinConcepts.TOO_MANY_ERRORS)
    assert res.value.obj == [ReturnValueConcept("who", False, None)]


@pytest.mark.parametrize("text, expected", [
    ("1 + 1", 2),
    ("sheerka.test()", 'I have access to Sheerka !')
])
def test_i_can_eval_python_expressions_with_no_variable(text, expected):
    sheerka = get_sheerka()

    res = sheerka.eval(text)

    assert len(res) == 1
    assert res[0].status
    assert res[0].value == expected


def test_i_can_eval_concept_with_python_body():
    sheerka = get_sheerka()
    concept = Concept(name="one", body="1")
    sheerka.add_in_cache(concept)

    text = "one"
    res = sheerka.eval(text)
    assert len(res) == 1
    assert res[0].status
    assert res[0].value == 1


def test_i_can_eval_concept_with_concept_body():
    sheerka = get_sheerka()
    concept_one = Concept(name="one")
    concept_un = Concept(name="un", body="one")
    sheerka.add_in_cache(concept_one)
    sheerka.add_in_cache(concept_un)

    res = sheerka.eval("un")
    return_value = res[0].value
    assert len(res) == 1
    assert res[0].status
    assert sheerka.isinstance(return_value, concept_one)


def test_i_can_eval_concept_with_no_body():
    sheerka = get_sheerka()
    concept = Concept(name="one")
    sheerka.add_in_cache(concept)

    text = "one"
    res = sheerka.eval(text)
    assert len(res) == 1
    assert res[0].status
    assert res[0].value == concept
    assert id(res[0].value) != id(concept)


def test_is_unique_property_is_used_when_evaluating():
    sheerka = get_sheerka()
    concept = Concept(name="one", is_unique=True)
    sheerka.add_in_cache(concept)

    text = "one"
    res = sheerka.eval(text)
    assert len(res) == 1
    assert res[0].status
    assert res[0].value == concept
    assert id(res[0].value) == id(concept)


def test_i_can_eval_def_concept_request():
    text = """
def concept a + b
where isinstance(a, int) and isinstance(b, int)
pre isinstance(a, int) and isinstance(b, int)
post isinstance(res, int)
as:
    def func(x,y):
        return x+y
    func(a,b)
    """

    expected = get_default_concept()
    expected.id = "1001"
    expected.desc = None
    expected.init_key()

    sheerka = get_sheerka()
    res = sheerka.eval(text)

    assert len(res) == 1
    assert res[0].status
    assert sheerka.isinstance(res[0].value, BuiltinConcepts.NEW_CONCEPT)

    concept_saved = res[0].value.body

    for prop in Concept.props_to_serialize:
        assert getattr(concept_saved, prop) == getattr(expected, prop)

    assert concept_saved.key in sheerka.concepts_cache
    assert path.exists(sheerka.sdp.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_saved.get_digest()))


def test_i_can_eval_def_concept_part_when_one_part_is_a_ref_of_another_concept():
    """
    In this test, we test that the properties of 'concept a xx b' (which are 'a' and 'b')
    are correctly detected, because of the concept 'a plus b' in its body
    :return:
    """
    sheerka = get_sheerka()

    # concept 'a plus b' is known
    concept_a_plus_b = Concept(name="a plus b").set_prop("a").set_prop("b")
    sheerka.add_in_cache(concept_a_plus_b)

    res = sheerka.eval("def concept a xx b as a plus b")
    expected = Concept(name="a xx b", body="a plus b").set_prop("a").set_prop("b").init_key()
    expected.id = "1001"

    assert len(res) == 1
    assert res[0].status
    assert sheerka.isinstance(res[0].value, BuiltinConcepts.NEW_CONCEPT)

    concept_saved = res[0].value.body

    for prop in Concept.props_to_serialize:
        assert getattr(concept_saved, prop) == getattr(expected, prop)

    assert concept_saved.key in sheerka.concepts_cache
    assert path.exists(sheerka.sdp.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_saved.get_digest()))


def test_i_cannot_eval_the_same_def_concept_twice():
    text = """
def concept a + b
where isinstance(a, int) and isinstance(b, int)
pre isinstance(a, int) and isinstance(b, int)
post isinstance(res, int)
as:
    def func(x,y):
        return x+y
    func(a,b)
        """

    sheerka = get_sheerka()
    sheerka.eval(text)
    res = sheerka.eval(text)

    assert len(res) == 1
    assert not res[0].status
    assert sheerka.isinstance(res[0].value, BuiltinConcepts.CONCEPT_ALREADY_DEFINED)


@pytest.mark.parametrize("text", [
    "",
    "   ",
    "\n",
])
def test_i_can_eval_a_empty_input(text):
    sheerka = get_sheerka()

    res = sheerka.eval(text)

    assert len(res) == 1
    assert res[0].status
    assert sheerka.isinstance(res[0].value, BuiltinConcepts.NOP)


def test_i_can_eval_concept_with_variable():
    sheerka = get_sheerka()
    concept_hello = Concept(name="hello a").set_prop("a")
    concept_foo = Concept(name="foo")
    sheerka.add_in_cache(concept_hello)
    sheerka.add_in_cache(concept_foo)

    res = sheerka.eval("hello foo")
    return_value = res[0].value
    assert len(res) == 1
    assert res[0].status
    assert sheerka.isinstance(return_value, concept_hello)
    assert return_value.props["a"].value == concept_foo


def test_i_can_eval_concept_with_variable_and_python_as_body():
    sheerka = get_sheerka()
    sheerka.add_in_cache(Concept(name="hello a", body="'hello ' + a").set_prop("a"))
    sheerka.add_in_cache(Concept(name="foo", body="'foo'"))

    res = sheerka.eval("hello foo")
    assert len(res) == 1
    assert res[0].status
    assert res[0].value, "hello foo"


def test_i_can_eval_duplicate_concepts_with_same_value():
    sheerka = get_sheerka()

    sheerka.add_in_cache(Concept(name="hello a", body="'hello ' + a").set_prop("a"))
    sheerka.add_in_cache(Concept(name="hello foo", body="'hello foo'"))
    sheerka.add_in_cache(Concept(name="foo", body="'foo'"))

    res = sheerka.eval("hello foo")
    assert len(res) == 1
    assert res[0].status
    assert res[0].value, "hello foo"
    assert res[0].who == sheerka.get_evaluator_name(MultipleSameSuccessEvaluator.NAME)


def test_i_cannot_manage_duplicate_concepts_when_the_values_are_different():
    sheerka = get_sheerka()

    sheerka.add_in_cache(Concept(name="hello a", body="'hello ' + a").set_prop("a"))
    sheerka.add_in_cache(Concept(name="hello foo", body="'hello foo'"))
    sheerka.add_in_cache(Concept(name="foo", body="'another value'"))

    res = sheerka.eval("hello foo")
    assert len(res) == 1
    assert not res[0].status
    assert sheerka.isinstance(res[0].value, BuiltinConcepts.TOO_MANY_SUCCESS)

    concepts = res[0].value.obj
    assert len(concepts) == 2
    sorted_values = sorted(concepts, key=lambda x: x.value)
    assert sorted_values[0].value == "hello another value"
    assert sorted_values[1].value == "hello foo"


def test_i_can_manage_concepts_with_the_same_key_when_values_are_the_same():
    sheerka = get_sheerka()
    context = get_context(sheerka)

    sheerka.create_new_concept(context, Concept(name="hello a", body="'hello ' + a").set_prop("a"))
    sheerka.create_new_concept(context, Concept(name="hello b", body="'hello ' + b").set_prop("b"))

    res = sheerka.eval("hello 'foo'")
    assert len(res) == 1
    assert res[0].status
    assert res[0].value, "hello foo"
    assert res[0].who == sheerka.get_evaluator_name(MultipleSameSuccessEvaluator.NAME)


def get_sheerka():
    sheerka = Sheerka()
    sheerka.initialize(root_folder)

    return sheerka


def get_context(sheerka):
    return ExecutionContext("test", "xxx", sheerka)


def get_default_concept():
    concept = Concept(
        name="a + b",
        where="isinstance(a, int) and isinstance(b, int)",
        pre="isinstance(a, int) and isinstance(b, int)",
        post="isinstance(res, int)",
        body="def func(x,y):\n    return x+y\nfunc(a,b)",
        desc="specific description")
    concept.set_prop("a", "value1")
    concept.set_prop("b", "value2")

    return concept


def get_unique_concept():
    return Concept(name="unique", is_unique=True)