import pytest

from core.concept import Concept, ConceptParts, DEFINITION_TYPE_DEF


@pytest.mark.parametrize("name, variables, expected", [
    ("foo", [], "foo"),
    ("foo(bar)", [], "foo ( bar )"),
    ("foo a", ["a"], "foo __var__0"),
    ("a foo b", ["a", "b"], "__var__0 foo __var__1"),
    ("a foo b", ["b", "a"], "__var__1 foo __var__0"),
    ("foo", ["foo"], "foo"),
    ("foo a", ["foo"], "__var__0 a"),
    ("foo       a   b", ["a"], "foo __var__0 b"),
    ("'foo'", [], "'foo'"),
    ("my name is a", ["a"], "my name is __var__0"),
    ("a b c d", ["b", "c"], "a __var__0 __var__1 d"),
    ("a 'b c' d", ["b", "c"], "a 'b c' d"),
    ("a | b", ["a", "b"], "__var__0 | __var__1"),
    ("a b a c", ["a", "b"], "__var__0 __var__1 __var__0 c"),
    ("a b a c", ["b", "a"], "__var__1 __var__0 __var__1 c"),
    ("def concept a", ["a"], "def concept __var__0"),
])
def test_i_can_compute_the_key(name, variables, expected):
    concept = Concept(name)
    for var_name in variables:
        concept.metadata.variables.append((var_name, None))
    concept.init_key()

    assert concept.key == expected


def test_i_can_compute_the_key_when_from_definition():
    # if definition is not defined, use the name
    concept = Concept()
    concept.metadata.name = "hello a"
    concept.metadata.variables = [("a", None)]
    concept.init_key()
    assert concept.key == "hello __var__0"

    # if definition is defined, use it
    concept = Concept()
    concept.metadata.name = "greetings"
    concept.metadata.definition = "hello a"
    concept.metadata.definition_type = DEFINITION_TYPE_DEF
    concept.metadata.variables = [("a", None)]
    concept.init_key()
    assert concept.key == "hello __var__0"


def test_key_does_not_use_variable_when_definition_is_set():
    concept = Concept("plus").def_var('plus')

    concept.init_key()
    assert concept.metadata.key == "plus"


def test_i_can_serialize():
    """
    Test concept.to_dict()
    :return:
    """
    concept = Concept(
        name="concept_name",
        is_builtin=True,
        is_unique=True,
        key="concept_key",
        body="definition of the body",
        where="definition of the where",
        pre="definition of the pre",
        post="definition of the post",
        definition="bnf definition",
        definition_type="def type",
        desc="this this the desc",
        id="123456"
    ).def_var("a", "10").def_var("b", None)

    to_dict = concept.to_dict()
    assert to_dict == {
        'body': 'definition of the body',
        'definition': 'bnf definition',
        'definition_type': 'def type',
        'desc': 'this this the desc',
        'id': '123456',
        'is_builtin': True,
        'is_unique': True,
        'key': 'concept_key',
        'name': 'concept_name',
        'post': 'definition of the post',
        'pre': 'definition of the pre',
        'props': {},
        'variables': [('a', "10"), ('b', None)],
        'where': 'definition of the where'
    }


def test_i_can_deserialize():
    """
    Test concept.from_dict()
    :return:
    """

    from_dict = {
        'body': 'definition of the body',
        'definition': 'bnf definition',
        'definition_type': 'def type',
        'desc': 'this this the desc',
        'id': '123456',
        'is_builtin': True,
        'is_unique': True,
        'key': 'concept_key',
        'name': 'concept_name',
        'post': 'definition of the post',
        'pre': 'definition of the pre',
        'props': {},
        'variables': [('a', "10"), ('b', None)],
        'where': 'definition of the where'
    }

    concept = Concept().from_dict(from_dict)

    assert concept == Concept(
        name="concept_name",
        is_builtin=True,
        is_unique=True,
        key="concept_key",
        body="definition of the body",
        where="definition of the where",
        pre="definition of the pre",
        post="definition of the post",
        definition="bnf definition",
        definition_type="def type",
        desc="this this the desc",
        id="123456"
    ).def_var("a", "10").def_var("b", None)


def test_i_can_deserialize_variables_coming_from_sdp():
    from_dict = {
        'variables': [['a', "10"], ['b', None]],  # JSON transform set into list
    }

    concept = Concept().from_dict(from_dict)
    assert concept == Concept().def_var("a", "10").def_var("b", None)


def test_i_can_compare_concepts():
    concept_a = Concept(
        name="concept_name",
        is_builtin=True,
        is_unique=True,
        key="concept_key",
        body="definition of the body",
        where="definition of the where",
        pre="definition of the pre",
        post="definition of the post",
        definition="bnf definition",
        definition_type="def type",
        desc="this this the desc",
        id="123456"
    ).def_var("a", "10").def_var("b", None).add_prop("prop", "prop_val")

    concept_b = Concept(
        name="concept_name",
        is_builtin=True,
        is_unique=True,
        key="concept_key",
        body="definition of the body",
        where="definition of the where",
        pre="definition of the pre",
        post="definition of the post",
        definition="bnf definition",
        definition_type="def type",
        desc="this this the desc",
        id="123456"
    ).def_var("a", "10").def_var("b", None).add_prop("prop", "prop_val")

    assert concept_a == concept_b


def test_i_can_detect_concept_differences():
    assert Concept(name="concept_name") != Concept()
    assert Concept(is_builtin=True) != Concept()
    assert Concept(is_unique=True) != Concept()
    assert Concept(key="concept_key") != Concept()
    assert Concept(body="concept_body") != Concept()
    assert Concept(where="concept_where") != Concept()
    assert Concept(pre="concept_pre") != Concept()
    assert Concept(post="concept_post") != Concept()
    assert Concept(definition="def") != Concept()
    assert Concept(definition_type="def type") != Concept()
    assert Concept(desc="desc") != Concept()
    assert Concept(id="concept_id") != Concept()
    assert Concept().def_var("a") != Concept()
    assert Concept().add_prop("a", "b") != Concept()
    assert Concept().set_value("a", "b") != Concept()

    concept = Concept()
    concept.compiled["foo"] = "value"
    assert concept == Concept()  # compiled is not used in the comparison


def test_i_can_compare_concept_with_circular_reference():
    foo = Concept("foo")
    foo.metadata.body = foo

    assert foo == foo


def test_i_can_compare_concept_with_sophisticated_circular_reference():
    foo = Concept("foo")
    bar = Concept("foo", body=foo)
    baz = Concept("foo", body=bar)
    foo.metadata.body = baz

    assert foo != bar


def test_i_can_compare_concept_with_sophisticated_circular_reference_in_other_metadata():
    foo = Concept("foo")
    bar = Concept("foo", pre=foo)
    baz = Concept("foo", pre=bar)
    foo.metadata.pre = baz

    assert foo != bar


def test_i_can_update_from():
    template = Concept(
        name="concept_name",
        is_builtin=True,
        is_unique=True,
        key="concept_key",
        body="definition of the body",
        where="definition of the where",
        pre="definition of the pre",
        post="definition of the post",
        definition="bnf definition",
        definition_type="def type",
        desc="this this the desc",
        id="123456"
    ).def_var("a", "10").def_var("b", None)

    # make sure origin is preserved
    setattr(template, "##origin##", "digest")

    template.set_value(ConceptParts.BODY, "value in body")
    template.set_value(ConceptParts.WHERE, "value in where")
    template.set_value(ConceptParts.PRE, "value in pre")
    template.set_value(ConceptParts.POST, "value in post")
    template.set_value("a", 10)
    template.set_value("b", 20)

    concept = Concept().update_from(template)

    assert concept == template
    assert getattr(concept, "##origin##") == "digest"