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


def get_sheerka():
    sheerka = Sheerka()
    sheerka.initialize("mem://")
    return sheerka


def get_context(sheerka):
    return ExecutionContext("test", Event(), sheerka)


def test_i_can_transform_an_unknown_concept():
    sheerka = 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"
    ).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,
        'name': 'concept_name',
        'key': 'concept_key',
        'is_builtin': True,
        'is_unique': True,
        'definition': 'it is a definition',
        'definition_type': 'def type',
        'desc': 'this this the desc',
        'where': [{OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                   OBJ_ID_KEY: 1,
                   'body': 'body',
                   'name': 'foo'}, 1, '1', True, 1.0],
        'pre': {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1},
        'body': {
            OBJ_TYPE_KEY: SheerkaTransformType.Concept,
            OBJ_ID_KEY: 2,
            'name': 'concept_with_sub',
            'body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference, OBJ_ID_KEY: 1}},
        '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():
    sheerka = 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, 'name': 'foo'}


def test_i_can_transform_known_concept_when_the_values_are_the_same():
    sheerka = 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"
    ).set_prop("a").set_prop("b")
    sheerka.create_new_concept(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():
    sheerka = 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"
    ).set_prop("a").set_prop("b")
    sheerka.create_new_concept(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():
    sheerka = 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,
        'name': 'foo',
        'body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                 OBJ_ID_KEY: 1,
                 'name': 'bar',
                 'body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
                          OBJ_ID_KEY: 0},
                 },
    }


def test_i_can_transform_concept_with_circular_reference_2():
    sheerka = 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,
        'name': 'foo',
        'body': {OBJ_TYPE_KEY: SheerkaTransformType.Concept,
                 OBJ_ID_KEY: 1,
                 'name': 'foo',
                 'body': {OBJ_TYPE_KEY: SheerkaTransformType.Reference,
                          OBJ_ID_KEY: 0},
                 },
    }


def test_i_can_transform_the_unknown_concept():
    sheerka = get_sheerka()

    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():
    sheerka = get_sheerka()
    ExecutionContextIdManager.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():
    sheerka = get_sheerka()
    ExecutionContextIdManager.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():
    sheerka = get_sheerka()
    ExecutionContextIdManager.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():
    sheerka = get_sheerka()
    ExecutionContextIdManager.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(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():
    sheerka = get_sheerka()
    ExecutionContextIdManager.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