from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept, ConceptParts

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


class TestSheerkaModifyConcept(TestUsingMemoryBasedSheerka):

    def test_i_can_modify_a_concept(self):
        sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True, cache_only=False)

        foo_instance = sheerka.new("foo")
        foo_instance.metadata.body = "metadata value"  # modify metadata
        foo_instance.def_var("var_name", "default value")  # modify definition of variables
        foo_instance.add_prop(BuiltinConcepts.ISA, bar)  # modify property
        foo_instance.set_value(ConceptParts.BODY, "body value")  # modify value
        foo_instance.set_value("var_name", "var value")  # modify value
        res = sheerka.modify_concept(context, foo_instance)

        assert res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
        assert res.body.body.metadata.body == "metadata value"
        assert res.body.body.metadata.variables == [("var_name", "default value")]
        assert res.body.body.get_prop(BuiltinConcepts.ISA) == {bar}
        assert res.body.body.body == "body value"
        assert res.body.body.get_value("var_name") == "var value"

        # test that object
        foo_from_sheerka = sheerka.get_by_key("foo")
        assert foo_from_sheerka.metadata.body == "metadata value"
        assert foo_from_sheerka.metadata.variables == [("var_name", "default value")]
        assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == {bar}
        assert foo_from_sheerka.body == "body value"
        assert foo_from_sheerka.get_value("var_name") == "var value"

        # other caches are also updated
        assert sheerka.get_by_id(foo.id).metadata.body == "metadata value"
        assert sheerka.get_by_name(foo.name).metadata.body == "metadata value"
        assert sheerka.get_by_hash(foo_instance.get_definition_hash()).metadata.body == "metadata value"

        # sdp can be updated
        sheerka.cache_manager.commit(context)
        from_sdp = sheerka.sdp.get(sheerka.CONCEPTS_BY_ID_ENTRY, foo.id)
        assert from_sdp.metadata.body == "metadata value"
        assert from_sdp.metadata.variables == [("var_name", "default value")]
        assert from_sdp.get_prop(BuiltinConcepts.ISA) == {bar}
        assert from_sdp.body == "body value"
        assert from_sdp.get_value("var_name") == "var value"

    def test_i_cannot_modify_a_concept_that_does_not_exists(self):
        sheerka, context = self.init_concepts()

        foo = Concept("foo").init_key()
        sheerka.set_id_if_needed(foo, False)

        res = sheerka.modify_concept(context, foo)
        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.UNKNOWN_CONCEPT)
        assert res.body.body == ("id", foo.id)

    def test_i_cannot_modify_a_concept_that_returns_an_error(self):
        sheerka, context = self.init_concepts()

        foo = Concept("foo").init_key()
        res = sheerka.modify_concept(context, foo)

        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)

    def test_i_cannot_modify_if_the_concept_has_not_changed(self):
        sheerka, context, foo = self.init_concepts("foo", create_new=True)
        res = sheerka.modify_concept(context, foo)

        assert not res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.ALREADY_DEFINED)

    def test_i_can_modify_a_concept_that_is_in_a_list(self):
        sheerka, context, foo1, foo2 = self.init_concepts(
            Concept("foo", body="1"),
            Concept("foo", body="2"), create_new=True)

        foo2_instance = sheerka.new("foo")[1]
        foo2_instance.metadata.body = "value"

        res = sheerka.modify_concept(context, foo2_instance)
        assert res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
        assert res.body.body.metadata.body == "value"

        foo_from_sheerka = sheerka.new("foo")
        assert foo_from_sheerka[0].metadata.body == "1"
        assert foo_from_sheerka[1].metadata.body == "value"

    def test_i_can_get_and_set_attribute(self):
        sheerka, context = self.init_concepts()
        foo = Concept("foo")
        prop = Concept("property")
        bar = Concept("bar")

        res = sheerka.set_attr(foo, prop, bar)
        assert res.status
        assert sheerka.isinstance(res.body, BuiltinConcepts.SUCCESS)

        assert sheerka.get_attr(foo, prop) == bar


class TestSheerkaModifyConceptUsingFile(TestUsingFileBasedSheerka):

    def test_i_can_modify_a_concept_from_a_new_sheerka(self):
        sheerka, context, foo = self.init_concepts("foo", create_new=True)
        sheerka.cache_manager.commit(context)

        sheerka = self.get_sheerka()
        foo.add_prop("a", "b")
        res = sheerka.modify_concept(context, foo)

        assert res.status