import pytest

from core.concept import Concept, ConceptParts
from core.global_symbols import NotFound
from core.sheerka.services.SheerkaVariableManager import SheerkaVariableManager

from tests.TestUsingFileBasedSheerka import TestUsingFileBasedSheerka
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestSheerkaVariable(TestUsingMemoryBasedSheerka):
    def test_i_can_record_and_load_a_constant(self):
        sheerka = self.get_sheerka(cache_only=False)
        context = self.get_context(sheerka)

        sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 1)
        res = sheerka.load_var("TestSheerkaVariable", "my_variable")
        assert res == 1

        # I can persist in db
        sheerka.om.commit(context)

        assert sheerka.om.current_sdp().exists(SheerkaVariableManager.VARIABLES_ENTRY,
                                               "TestSheerkaVariable|my_variable")
        loaded = sheerka.om.current_sdp().get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable|my_variable")
        assert loaded.event_id == context.event.get_digest()
        assert loaded.key == "my_variable"
        assert loaded.value == 1
        assert loaded.who == "TestSheerkaVariable"
        assert loaded.parents is None

    def test_i_can_record_and_load_a_concept(self):
        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)

        concept = Concept("foo").set_value("a", "alpha").set_value(ConceptParts.BODY, 3.14)

        sheerka.record_var(context, "TestSheerkaVariable", "my_variable", concept)
        res = sheerka.load_var("TestSheerkaVariable", "my_variable")

        assert res == concept
        assert res.body == concept.body
        assert res.a == concept.a

    def test_i_can_delete_an_entry(self):
        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)

        concept = Concept("foo")

        sheerka.record_var(context, "TestSheerkaVariable", "my_variable", concept)
        assert sheerka.load_var("TestSheerkaVariable", "my_variable") == concept

        sheerka.delete_var(context, "TestSheerkaVariable", "my_variable")
        assert sheerka.load_var("TestSheerkaVariable", "my_variable") is NotFound

    def test_i_can_set_and_get_a_value(self):
        sheerka = self.get_sheerka(cache_only=False)
        context = self.get_context(sheerka)
        context.event.user_id = "Test_user"

        sheerka.set_var(context, "my_variable", "my value")
        res = sheerka.get_var(context, "my_variable")
        assert res == "my value"

        # I can persist in db
        sheerka.om.commit(context)

        assert sheerka.om.current_sdp().exists(SheerkaVariableManager.VARIABLES_ENTRY, "Test_user|my_variable")
        loaded = sheerka.om.current_sdp().get(SheerkaVariableManager.VARIABLES_ENTRY, "Test_user|my_variable")
        assert loaded.event_id == context.event.get_digest()
        assert loaded.key == "my_variable"
        assert loaded.value == "my value"
        assert loaded.who == "Test_user"
        assert loaded.parents is None

    def test_i_can_record_and_load_internal_variables(self):
        sheerka = self.get_sheerka(cache_only=False)
        context = self.get_context(sheerka)

        sheerka.record_internal_var(context, "TestSheerkaVariable", "my_variable", 1)
        res = sheerka.load_internal_var("TestSheerkaVariable", "my_variable")
        assert res == 1

        sheerka.record_internal_var(context, "TestSheerkaVariable", "lambda", lambda x: x + 1)
        res = sheerka.load_internal_var("TestSheerkaVariable", "lambda")
        assert res(10) == 11

    def test_i_can_record_and_load_in_multiple_ontology_layers(self):
        sheerka = self.get_sheerka(cache_only=False)
        context = self.get_context(sheerka)

        sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 1)
        sheerka.record_internal_var(context, "TestSheerkaVariable", "lambda", lambda x: x + 1)
        sheerka.om.commit(context)

        sheerka.push_ontology(context, "new ontology")
        sheerka.push_ontology(context, "another ontology")

        # I can still access to the previous values
        assert sheerka.load_var("TestSheerkaVariable", "my_variable") == 1
        assert sheerka.load_internal_var("TestSheerkaVariable", "lambda")(10) == 11

        # I can modify the current values
        sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 2)
        sheerka.record_internal_var(context, "TestSheerkaVariable", "lambda", lambda x: x + 2)
        sheerka.om.commit(context)

        assert sheerka.load_var("TestSheerkaVariable", "my_variable") == 2
        assert sheerka.load_internal_var("TestSheerkaVariable", "lambda")(10) == 12

        # I can revert back
        sheerka.pop_ontology()
        assert sheerka.load_var("TestSheerkaVariable", "my_variable") == 1
        assert sheerka.load_internal_var("TestSheerkaVariable", "lambda")(10) == 11

        sheerka.pop_ontology()
        assert sheerka.load_var("TestSheerkaVariable", "my_variable") == 1
        assert sheerka.load_internal_var("TestSheerkaVariable", "lambda")(10) == 11


class TestSheerkaVariableUsingFileBasedSdp(TestUsingFileBasedSheerka):

    def test_i_can_bound_variables_to_sheerka(self):
        sheerka, context = self.init_test().unpack()

        old_value = sheerka.enable_process_return_values
        new_value = not old_value
        sheerka.record_var(context, sheerka.name, "enable_process_return_values", new_value)
        sheerka.om.commit(context)

        assert sheerka.enable_process_return_values == new_value

        # the modification is persisted upon new Sheerka creation
        sheerka = self.new_sheerka_instance(False)
        assert sheerka.load_var(sheerka.name, "enable_process_return_values") == new_value
        assert sheerka.enable_process_return_values == new_value

        # reset old value
        sheerka.record_var(context, sheerka.name, "enable_process_return_values", old_value)

    def test_i_can_bound_variables_to_sheerka_when_ontology_layer(self):
        sheerka, context = self.init_test().unpack()

        old_value = sheerka.enable_process_return_values
        new_value = not old_value
        sheerka.record_var(context, sheerka.name, "enable_process_return_values", new_value)
        sheerka.om.commit(context)

        # sanity
        assert sheerka.enable_process_return_values == new_value
        assert sheerka.load_var(sheerka.name, "enable_process_return_values") == new_value

        # the modification is seen even when there is an ontology layer
        sheerka.push_ontology(context, "new ontology")
        sheerka = self.new_sheerka_instance(False)
        assert sheerka.load_var(sheerka.name, "enable_process_return_values") == new_value
        assert sheerka.enable_process_return_values == new_value

        # reset old value
        sheerka.record_var(context, sheerka.name, "enable_process_return_values", old_value)

    # def test_i_can_get_the_parent_when_modified(self):
    #     sheerka = self.get_sheerka()
    #     context = self.get_context(sheerka)
    #
    #     sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 1)
    #     sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 2)
    #     res = sheerka.load_var("TestSheerkaVariable", "my_variable")
    #     assert res == 2
    #
    #     loaded = sheerka.om.current_sdp().get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
    #     assert loaded.event_id == context.event.get_digest()
    #     assert loaded.key == "my_variable"
    #     assert loaded.value == 2
    #     assert loaded.who == "TestSheerkaVariable"
    #     assert loaded.parents == ['8c9ada7bf488d84229f6539f76042431638f16d600fe3b7ec7e7161043a40d59']
    #
    #     parent = sheerka.om.current_sdp().load_obj(loaded.parents[0])
    #     assert parent.event_id == context.event.get_digest()
    #     assert parent.key == "my_variable"
    #     assert parent.value == 1
    #     assert parent.who == "TestSheerkaVariable"
    #     assert parent.parents is None

    # def test_variable_is_not_persisted_if_the_value_is_the_same(self):
    #     sheerka = self.get_sheerka(singleton=True)
    #     context = self.get_context(sheerka)
    #
    #     sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 1)
    #     sheerka.record_var(context, "TestSheerkaVariable", "my_variable", 1)
    #
    #     loaded = sheerka.om.current_sdp().get(SheerkaVariableManager.VARIABLES_ENTRY, "TestSheerkaVariable.my_variable")
    #     assert loaded.event_id == context.event.get_digest()
    #     assert loaded.key == "my_variable"
    #     assert loaded.value == 1
    #     assert loaded.who == "TestSheerkaVariable"
    #     assert loaded.parents is None