from core.builtin_concepts import BuiltinConcepts
from core.concept import Concept, ConceptParts
from core.sheerka.ExecutionContext import ExecutionContext
from core.sheerka_transform import SheerkaTransform, OBJ_TYPE_KEY, SheerkaTransformType, OBJ_ID_KEY
from sdp.sheerkaDataProvider import Event

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestSheerkaTransform(TestUsingMemoryBasedSheerka):
    def test_i_can_transform_an_unknown_concept(self):
        sheerka = self.get_sheerka()

        foo = Concept("foo", body="body")
        concept_with_sub = Concept("concept_with_sub", body=foo)

        concept = Concept(
            name="concept_name",
            is_builtin=True,
            is_unique=True,
            key="concept_key",
            body=concept_with_sub,
            where=[foo, 1, "1", True, 1.0],
            pre=foo,
            post=None,  # will not appear
            definition="it is a definition",
            definition_type="def type",
            desc="this this the desc"
        ).def_prop("a", "10").def_prop("b", "foo").def_prop("c", "concept_with_sub")

        # add values and props
        concept.values[ConceptParts.BODY] = Concept().update_from(concept_with_sub).auto_init()
        concept.values[ConceptParts.WHERE] = [foo, 1, "1", True, 1.0]
        concept.values[ConceptParts.PRE] = Concept().update_from(foo).auto_init()
        concept.values[ConceptParts.POST] = "a value for POST"
        concept.set_prop("a", 10).set_prop("b", foo).set_prop("c", concept_with_sub)

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(concept)

        assert to_dict == {
            OBJ_TYPE_KEY: SheerkaTransformType.Concept,
            OBJ_ID_KEY: 0,
            'meta.name': 'concept_name',
            'meta.key': 'concept_key',
            'meta.is_builtin': True,
            'meta.is_unique': True,
            'meta.definition': 'it is a definition',
            'meta.definition_type': 'def type',
            'meta.desc': 'this this the desc',
            'meta.where': [{OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                            OBJ_ID_KEY: 1,
                            'meta.body': 'body',
                            'meta.name': 'foo'}, 1, '1', True, 1.0],
            'meta.pre': {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1},
            'meta.body': {
                '__type__': SheerkaTransformType.Concept,
                '__id__': 2,
                'meta.name': 'concept_with_sub',
                'meta.body': {
                    '__type__': SheerkaTransformType.Reference,
                    '__id__': 1}},
            'meta.props': [['a', '10'], ['b', 'foo'], ['c', 'concept_with_sub']],
            'pre': {'__type__': SheerkaTransformType.Concept,
                    '__id__': 4,
                    'meta.body': 'body',
                    'meta.name': 'foo',
                    'body': 'body'},
            'post': "a value for POST",
            'body': {'__type__': SheerkaTransformType.Concept,
                     '__id__': 3,
                     'meta.body': {'__id__': 1, '__type__': SheerkaTransformType.Reference},
                     'meta.name': 'concept_with_sub',
                     'body': {'__id__': 1, '__type__': SheerkaTransformType.Reference}},
            'where': [{OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1}, 1, '1', True, 1.0],
            'props': [('a', 10),
                      ('b', {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1}),
                      ('c', {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 2})],
        }

    def test_i_can_transform_unknown_concept_with_almost_same_value(self):
        sheerka = self.get_sheerka()
        concept = Concept("foo")

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(concept)

        assert to_dict == {OBJ_TYPE_KEY: SheerkaTransformType.Concept, OBJ_ID_KEY: 0, 'meta.name': 'foo'}

    def test_i_can_transform_known_concept_when_the_values_are_the_same(self):
        """
        Values are the same means that we are serializing a concept which has kept all its default values
        There is not diff between the concept to serialize and the one which was registered with create_new_concept()
        We serialize only the id of the concept
        :return:
        """
        sheerka = self.get_sheerka()

        concept = Concept(
            name="concept_name",
            is_builtin=True,
            is_unique=False,
            key="concept_key",
            body="body definition",
            where="where definition",
            pre="pre definition",
            post="post definition",
            definition="it is a definition",
            definition_type="def type",
            desc="this this the desc"
        ).def_prop("a").def_prop("b")
        sheerka.create_new_concept(self.get_context(sheerka), concept)

        new_concept = sheerka.new(concept.key)
        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(new_concept)

        assert to_dict == {OBJ_TYPE_KEY: SheerkaTransformType.Concept, OBJ_ID_KEY: 0, "id": "1001"}

    def test_i_can_transform_known_concept_when_the_values_are_different(self):
        """
        Values are the different means the concept was modified.
        It's different from the one which was registered with create_new_concept()
        We serialize only the differences
        :return:
        """
        sheerka = self.get_sheerka()

        concept = Concept(
            name="concept_name",
            is_builtin=True,
            is_unique=False,
            key="concept_key",
            body="body definition",
            where="where definition",
            pre="pre definition",
            post="post definition",
            definition="it is a definition",
            definition_type="def type",
            desc="this this the desc"
        ).def_prop("a").def_prop("b")
        sheerka.create_new_concept(self.get_context(sheerka), concept)

        new_concept = sheerka.new(concept.key, body="another", a=10, pre="another pre")
        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(new_concept)

        assert to_dict == {
            OBJ_TYPE_KEY: SheerkaTransformType.Concept,
            OBJ_ID_KEY: 0,
            "id": "1001",
            'pre': 'another pre',
            "body": "another",
            'props': [('a', 10)]
        }

    def test_i_can_transform_concept_with_circular_reference(self):
        sheerka = self.get_sheerka()
        foo = Concept("foo")
        bar = Concept("bar", body=foo)
        foo.metadata.body = bar

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(foo)

        assert to_dict == {
            OBJ_TYPE_KEY: SheerkaTransformType.Concept,
            OBJ_ID_KEY: 0,
            'meta.name': 'foo',
            'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                          OBJ_ID_KEY: 1,
                          'meta.name': 'bar',
                          'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
                                        OBJ_ID_KEY: 0},
                          },
        }

    def test_i_can_transform_concept_with_circular_reference_2(self):
        sheerka = self.get_sheerka()
        foo = Concept("foo")
        bar = Concept("foo", body=foo)
        foo.metadata.body = bar

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(foo)

        assert to_dict == {
            OBJ_TYPE_KEY: SheerkaTransformType.Concept,
            OBJ_ID_KEY: 0,
            'meta.name': 'foo',
            'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                          OBJ_ID_KEY: 1,
                          'meta.name': 'foo',
                          'meta.body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
                                        OBJ_ID_KEY: 0},
                          },
        }

    def test_i_can_transform_the_unknown_concept(self):
        sheerka = self.get_sheerka(False)

        unknown = sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT)

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(unknown)

        assert len(to_dict) == 3
        assert to_dict[OBJ_TYPE_KEY] == SheerkaTransformType.Concept
        assert to_dict[OBJ_ID_KEY] == 0
        assert "id" in to_dict

    def test_i_can_transform_simple_execution_context(self):
        sheerka = self.get_sheerka()
        ExecutionContext.ids = {}
        context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(context)

        assert to_dict == {
            OBJ_TYPE_KEY: SheerkaTransformType.ExecutionContext,
            OBJ_ID_KEY: 0,
            '_parent': None,
            '_id': 0,
            '_tab': '',
            '_bag': {},
            '_start': 0,
            '_stop': 0,
            'who': 'requester',
            'event': {OBJ_TYPE_KEY: SheerkaTransformType.Event, OBJ_ID_KEY: 1, 'digest': 'xxx'},
            'desc': 'this is the desc',
            'children': [],
            'preprocess': None,
            'inputs': {},
            'values': {},
            'obj': None,
            'concepts': {}
        }

    def test_i_can_transform_list(self):
        sheerka = self.get_sheerka()
        ExecutionContext.ids = {}
        context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict([context])

        assert len(to_dict) == 1
        assert isinstance(to_dict, list)
        assert to_dict[0]["who"] == "requester"
        assert to_dict[0]["desc"] == "this is the desc"

    def test_i_can_transform_set(self):
        sheerka = self.get_sheerka()
        ExecutionContext.ids = {}
        context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict({context})

        assert len(to_dict) == 1
        assert isinstance(to_dict, list)
        assert to_dict[0]["who"] == "requester"
        assert to_dict[0]["desc"] == "this is the desc"

    def test_i_can_transform_dict(self):
        sheerka = self.get_sheerka()
        ExecutionContext.ids = {}
        context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
        known_concept = Concept("foo", body="foo").set_prop("a", "value_of_a").init_key()
        sheerka.create_new_concept(self.get_context(sheerka), known_concept)
        unknown_concept = Concept("bar")
        known = sheerka.new("foo")

        bag = {
            "context": context,
            "known_concept": known_concept,
            "unknown_concept": unknown_concept,
            "True": True,
            "Number": 1.1,
            "String": "a string value",
            "None": None,
            unknown_concept: "hello",
            known: "world"
        }

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(bag)

        assert isinstance(to_dict, dict)
        assert to_dict['Number'] == 1.1
        assert to_dict['String'] == 'a string value'
        assert to_dict['True']
        assert to_dict['None'] is None
        assert to_dict["context"][OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
        assert to_dict["known_concept"][OBJ_TYPE_KEY] == SheerkaTransformType.Concept
        assert to_dict["known_concept"]["id"] == '1001'
        assert to_dict["unknown_concept"][OBJ_TYPE_KEY] == SheerkaTransformType.Concept
        assert to_dict["(None)bar"] == "hello"
        assert to_dict["(1001)foo"] == "world"

    def test_i_can_transform_when_circular_references(self):
        sheerka = self.get_sheerka()
        ExecutionContext.ids = {}
        context = ExecutionContext("requester", Event(), sheerka, 'this is the desc')
        context.push("another requester", "another desc")

        st = SheerkaTransform(sheerka)
        to_dict = st.to_dict(context)

        assert isinstance(to_dict, dict)
        assert to_dict[OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
        assert len(to_dict["children"]) == 1
        assert to_dict["children"][0][OBJ_TYPE_KEY] == SheerkaTransformType.ExecutionContext
        assert to_dict["children"][0]['_parent'][OBJ_TYPE_KEY] == SheerkaTransformType.Reference
        assert to_dict["children"][0]['_parent'][OBJ_ID_KEY] == 0
        assert to_dict["children"][0]['event'][OBJ_TYPE_KEY] == SheerkaTransformType.Reference
        assert to_dict["children"][0]['event'][OBJ_ID_KEY] == 1