from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept
from core.global_symbols import NotFound
from core.sheerka.ExecutionContext import ExecutionContext
from core.sheerka.services.SheerkaMemory import SheerkaMemory, MemoryObject

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


class TestSheerkaMemory(TestUsingMemoryBasedSheerka):
    def test_i_can_add_to_global_short_term_memory(self):
        sheerka = self.get_sheerka()
        service = sheerka.services[SheerkaMemory.NAME]

        foo = Concept("foo")
        sheerka.add_to_short_term_memory(None, "a", foo)

        assert service.short_term_objects.copy() == {'global': {'a': foo}}
        assert id(sheerka.get_from_short_term_memory(None, "a")) == id(foo)

    def test_i_can_add_context_short_term_memory(self):
        sheerka, context = self.init_test().unpack()
        service = sheerka.services[SheerkaMemory.NAME]

        foo = Concept("foo")
        sheerka.add_to_short_term_memory(context, "a", foo)

        context_id = ExecutionContext.ids[context.event.get_digest()]
        assert service.short_term_objects.copy() == {context_id: {'a': foo}}
        assert id(sheerka.get_from_short_term_memory(context, "a")) == id(foo)
        assert sheerka.get_from_short_term_memory(None, "a") is NotFound

    def test_i_can_add_many(self):
        sheerka, context = self.init_test().unpack()
        bag = {"a": "foo", "b": "bar", }
        context_id = ExecutionContext.ids[context.event.get_digest()]
        service = sheerka.services[SheerkaMemory.NAME]

        sheerka.add_many_to_short_term_memory(context, bag)
        assert service.short_term_objects.copy() == {context_id: bag}

    def test_i_can_get_obj_from_parents(self):
        sheerka, context = self.init_test().unpack()
        foo = Concept("foo")

        sheerka.add_to_short_term_memory(None, "a", foo)
        sheerka.add_to_short_term_memory(context, "b", foo)

        with context.push(BuiltinConcepts.TESTING, None) as sub_context:
            assert id(sheerka.get_from_short_term_memory(sub_context, "a")) == id(foo)
            assert id(sheerka.get_from_short_term_memory(context, "a")) == id(foo)
            assert id(sheerka.get_from_short_term_memory(None, "a")) == id(foo)

            assert id(sheerka.get_from_short_term_memory(sub_context, "b")) == id(foo)
            assert id(sheerka.get_from_short_term_memory(context, "b")) == id(foo)
            assert sheerka.get_from_short_term_memory(None, "b") is NotFound

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

        with context.push(BuiltinConcepts.TESTING, None) as sub_context:
            foo = Concept("foo")
            sheerka.add_to_short_term_memory(sub_context, "a", foo)
            assert id(sheerka.get_from_short_term_memory(sub_context, "a")) == id(foo)

        assert sheerka.get_from_short_term_memory(sub_context, "a") is NotFound

    def test_short_term_memory_entries_are_removed_on_context_exit_2(self):
        # this time we test the bulk insert
        sheerka, context = self.init_test().unpack()

        with context.push(BuiltinConcepts.TESTING, None) as sub_context:
            foo = Concept("foo")
            sheerka.add_many_to_short_term_memory(sub_context, {"a": foo})
            assert id(sheerka.get_from_short_term_memory(sub_context, "a")) == id(foo)

        assert sheerka.get_from_short_term_memory(sub_context, "a") is NotFound

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

        assert sheerka.get_from_memory(context, "a") is NotFound

        foo = Concept("foo")
        sheerka.add_to_memory(context, "a", foo)

        assert sheerka.om.copy(SheerkaMemory.OBJECTS_ENTRY) == {"a": MemoryObject(context.event.get_digest(), foo)}
        assert id(sheerka.get_from_memory(context, "a").obj) == id(foo)


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

        foo = Concept("foo")
        sheerka.add_to_memory(context, "foo", foo)

        assert sheerka.memory(context, "foo") == foo

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

        foo = Concept("foo")
        sheerka.add_to_memory(context, "foo", foo)

        assert sheerka.memory(context, Concept("foo")) == foo

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

        res = sheerka.memory(context, "foo")

        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {"#name": "foo"}

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

        foo = Concept("foo")
        bar = Concept("bar")

        sheerka.add_to_memory(context, "item", foo)
        sheerka.add_to_memory(context, "item", bar)

        assert sheerka.memory(context, "item") == bar

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

        assert len(sheerka.om.get_all(SheerkaMemory.OBJECTS_ENTRY)) == 0


class TestSheerkaMemoryUsingFileBase(TestUsingFileBasedSheerka):
    def test_i_can_record_memory_objects(self):
        sheerka, context = self.init_test().unpack()

        sheerka.add_to_memory(context, "item", Concept("foo"))
        sheerka.om.commit(context)

        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)
        assert sheerka.get_from_memory(context, "item").obj == Concept("foo")