import pytest
from cache.Cache import Cache
from cache.CacheManager import CacheManager, ConceptNotFound
from cache.DictionaryCache import DictionaryCache
from cache.ListCache import ListCache
from cache.ListIfNeededCache import ListIfNeededCache
from core.concept import Concept

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestCacheManager(TestUsingMemoryBasedSheerka):
    def test_i_do_not_push_into_sdp_when_cache_only(self):
        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)

        cache_manager = CacheManager(True)
        cache_manager.register_cache("test", Cache(), persist=True)
        cache_manager.put("test", "key", "value")

        cache_manager.commit(context)
        assert not sheerka.sdp.exists("test", "key")

    def test_i_do_not_get_value_from_sdp_when_cache_only_is_true(self):
        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)
        with sheerka.sdp.get_transaction(context.event) as transaction:
            transaction.add("test", "key", "value")

        cache = Cache(default=lambda k: sheerka.sdp.get("test", k))

        cache_manager = CacheManager(True)
        cache_manager.register_cache("test", cache, persist=True)

        assert cache_manager.get("test", "key") is None

    def test_i_can_get_value_from_sdp_when_cache_only_is_false(self):
        sheerka = self.get_sheerka()
        context = self.get_context(sheerka)
        with sheerka.sdp.get_transaction(context.event) as transaction:
            transaction.add("test", "key", "value")

        cache = Cache(default=lambda k: sheerka.sdp.get("test", k))

        cache_manager = CacheManager(False)
        cache_manager.register_cache("test", cache, persist=True)

        assert cache_manager.get("test", "key") == "value"

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

        cache_manager = CacheManager(False)
        cache_manager.register_cache("test", Cache(), persist=True)
        cache = cache_manager.caches["test"].cache

        cache_manager.put("test", "key", "value")

        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == "value"

        cache.update("key", "value", "key", "another_value")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == "another_value"

        cache.update("key", "another_value", "key2", "another_value")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") is None
        assert sheerka.sdp.get("test", "key2") == "another_value"

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

        cache_manager = CacheManager(False)
        cache_manager.register_cache("test", ListCache(), persist=True)
        cache = cache_manager.caches["test"].cache

        cache.put("key", "value")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == ["value"]

        cache.put("key", "value2")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == ["value", "value2"]

        cache.update("key", "value2", "key2", "value2")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == ["value"]
        assert sheerka.sdp.get("test", "key2") == ["value2"]

        cache.update("key2", "value2", "key3", "value2")
        cache_manager.commit(context)
        assert sheerka.sdp.get("test", "key") == ["value"]
        assert sheerka.sdp.get("test", "key2") is None
        assert sheerka.sdp.get("test", "key3") == ["value2"]

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

        cache_manager = CacheManager(False)
        cache_manager.register_cache("test", DictionaryCache(), persist=True)
        cache = cache_manager.caches["test"].cache

        cache.put(False, {"key": "value", "key2": "value2"})
        cache_manager.commit(context)
        assert sheerka.sdp.get("test") == {"key": "value", "key2": "value2"}
        assert sheerka.sdp.get("test", "key") == "value"

        cache.put(False, {"key": "value", "key2": "value2", "key3": "value3"})
        cache_manager.commit(context)
        assert sheerka.sdp.get("test") == {"key": "value", "key2": "value2", "key3": "value3"}

    def test_i_can_remove_a_concept_from_concepts_caches(self):
        cache_manager = CacheManager(True)
        cache_manager.register_concept_cache("id", Cache(), lambda c: c.id, True)
        cache_manager.register_concept_cache("key", ListIfNeededCache(), lambda c: c.key, True)

        sheerka, context, one, two, three, two_bis = self.init_concepts("one", "two", "three", Concept("two", body="2"))

        for concept in [one, two, three, two_bis]:
            cache_manager.add_concept(concept)

        # sanity check
        cache_def = cache_manager.caches["id"]
        assert cache_def.cache.copy() == {one.id: one, two.id: two, three.id: three, two_bis.id: two_bis}
        cache_def = cache_manager.caches["key"]
        assert cache_def.cache.copy() == {one.key: one, two.key: [two, two_bis], three.key: three}

        for cache_name in cache_manager.concept_caches:
            cache_manager.caches[cache_name].cache.reset_events()

        cache_manager.remove_concept(sheerka.new(("two", two_bis.id)))

        cache_def = cache_manager.caches["id"]
        assert cache_def.cache.copy() == {one.id: one, two.id: two, three.id: three}
        assert cache_def.cache.to_remove == {two_bis.id}
        assert cache_def.cache.to_add == set()
        assert len(cache_def.cache) == 3

        cache_def = cache_manager.caches["key"]
        assert cache_def.cache.copy() == {one.key: one, two.key: two, three.key: three}
        assert cache_def.cache.to_remove == set()
        assert cache_def.cache.to_add == {"two"}
        assert len(cache_def.cache) == 3

    def test_i_cannot_remove_a_concept_that_does_not_exists(self):
        cache_manager = CacheManager(True)
        cache_manager.register_concept_cache("id", Cache(), lambda c: c.id, True)
        cache_manager.register_concept_cache("key", ListIfNeededCache(), lambda c: c.key, True)

        with pytest.raises(ConceptNotFound) as ex:
            cache_manager.remove_concept(Concept("foo", id="1001"))

        assert ex.value.concept == Concept("foo", id="1001")