import pytest
from os import path
import shutil
import os

from core.concept import Concept, Property
from core.sheerka import Sheerka, ExecutionContext
from parsers.DefaultParser import DefaultParser
from parsers.ExactConceptParser import ExactConceptParser

tests_root = path.abspath("../build/tests")
root_folder = "init_folder"


@pytest.fixture(autouse=True)
def init_test():
    if path.exists(tests_root):
        shutil.rmtree(tests_root)

    if not path.exists(tests_root):
        os.makedirs(tests_root)
    current_pwd = os.getcwd()
    os.chdir(tests_root)

    yield None

    os.chdir(current_pwd)


def test_i_can_compute_combinations():
    parser = ExactConceptParser()
    res = parser.combinations(["foo", "bar", "baz"])

    assert res == {('foo', 'bar', 'baz'),
                   ('__var__0', 'bar', 'baz'),
                   ('foo', '__var__0', 'baz'),
                   ('foo', 'bar', '__var__0'),
                   ('__var__0', '__var__1', 'baz'),
                   ('__var__0', 'bar', '__var__1'),
                   ('foo', '__var__0', '__var__1'),
                   ('__var__0', '__var__1', '__var__2')}


def test_i_can_compute_combinations_with_duplicates():
    parser = ExactConceptParser()
    res = parser.combinations(["foo", "bar", "foo"])

    assert res == {('foo', 'bar', 'foo'),
                   ('__var__0', 'bar', '__var__0'),
                   ('foo', '__var__0', 'foo'),
                   ('__var__0', '__var__1', '__var__0'),
                   ('__var__1', '__var__0', '__var__1')}
    # TODO: the last tuple is not possible, so the algo can be improved


def test_i_can_recognize_a_simple_concept():
    sheerka = get_sheerka()
    concept = get_concept("hello world", [])
    sheerka.add_in_cache(concept)
    source = "hello world"
    context = ExecutionContext(sheerka, "xxxx")
    results = ExactConceptParser().parse(context, source)

    assert len(results) == 1
    assert results[0].status
    assert results[0].value.key == concept.key


def test_i_can_recognize_concepts_defined_several_times():
    sheerka = get_sheerka()
    sheerka.add_in_cache(get_concept("hello world", []))
    sheerka.add_in_cache(get_concept("hello a", ["a"]))

    source = "hello world"
    context = ExecutionContext(sheerka, "xxxx")
    results = ExactConceptParser().parse(context, source)

    assert len(results) == 2
    results = sorted(results, key=lambda x: x.value.name) # because of the usage of sets

    assert results[0].status
    assert results[0].value.name == "hello a"
    assert results[0].value.props["a"].value == "world"

    assert results[1].status
    assert results[1].value.name == "hello world"


def test_i_can_recognize_a_concept_with_variables():
    sheerka = get_sheerka()
    concept = get_concept("a + b", ["a", "b"])
    sheerka.concepts_cache[concept.key] = concept
    source = "10 + 5"
    context = ExecutionContext(sheerka, "xxxx")
    results = ExactConceptParser().parse(context, source)

    assert len(results) == 1
    assert results[0].status
    assert results[0].value.key == concept.key
    assert results[0].value.props["a"].value == "10"
    assert results[0].value.props["b"].value == "5"


def test_i_can_recognize_a_concept_with_duplicate_variables():
    sheerka = get_sheerka()
    concept = get_concept("a + b + a", ["a", "b"])
    sheerka.concepts_cache[concept.key] = concept
    source = "10 + 5 + 10"
    context = ExecutionContext(sheerka, "xxxx")
    results = ExactConceptParser().parse(context, source)

    assert len(results) == 1
    assert results[0].status
    assert results[0].value.key == concept.key
    assert results[0].value.props["a"].value == "10"
    assert results[0].value.props["b"].value == "5"


def test_i_can_manage_unknown_concept():
    sheerka = get_sheerka()
    source = "def concept hello world"  # this is not a concept by itself
    context = ExecutionContext(sheerka, "xxxx")
    res = ExactConceptParser().parse(context, source)

    assert not res.status
    assert sheerka.isinstance(res.value, Sheerka.UNKNOWN_CONCEPT_NAME)


def test_i_can_detect_concepts_too_long():
    sheerka = get_sheerka()
    source = "a very very long concept that cannot be an unique one"
    context = ExecutionContext(sheerka, "xxxx")
    res = ExactConceptParser().parse(context, source)

    assert not res.status
    assert sheerka.isinstance(res.value, Sheerka.CONCEPT_TOO_LONG_CONCEPT_NAME)


def get_concept(name, variables):
    c = Concept(name=name)
    if variables:
        for v in variables:
            c.props[v] = Property(v, None)
    c.init_key()
    return c


def get_sheerka():
    sheerka = Sheerka()
    sheerka.initialize(root_folder)

    return sheerka