__author__ = 'Lukas Leufen'
__date__ = '2019-11-22'

import pytest

from mlair.helpers.datastore import AbstractDataStore, DataStoreByVariable, DataStoreByScope
from mlair.helpers.datastore import CorrectScope, TrackParameter
from mlair.helpers.datastore import NameNotFoundInDataStore, NameNotFoundInScope, EmptyScope


class TestAbstractDataStore:

    @pytest.fixture
    def ds(self):
        return AbstractDataStore()

    def test_init(self, ds):
        assert ds._store == {}

    def test_clear_data_store(self, ds):
        ds._store["test"] = "test2"
        assert len(ds._store.keys()) == 1
        ds.clear_data_store()
        assert len(ds._store.keys()) == 0


class TestDataStoreByVariable:

    @pytest.fixture
    def ds(self):
        return DataStoreByVariable()

    @pytest.fixture
    def ds_with_content(self, ds):
        ds.set("tester1", 1, "general")
        ds.set("tester2", 11, "general")
        ds.set("tester2", 10, "general.sub")
        ds.set("tester3", 21, "general")
        return ds

    def test_put(self, ds):
        ds.set("number", 3, "general.subscope")
        assert ds._store["number"]["general.subscope"] == 3

    def test_get(self, ds):
        ds.set("number", 3, "general.subscope")
        assert ds.get("number", "general.subscope") == 3

    def test_get_with_sub_scope(self, ds):
        ds.set("number", 3, "general")
        ds.set("number", 10, "general.subscope")
        assert ds.get("number", "general.subscope") == 10
        assert ds.get("number", "general") == 3

    def test_get_with_not_existing_sub_scope(self, ds):
        ds.set("number", 3, "general")
        ds.set("number2", 10, "general.subscope")
        ds.set("number2", 1, "general")
        assert ds.get("number", "general.subscope") == 3

    def test_raise_not_in_data_store(self, ds):
        ds.set("number", 22, "general")
        with pytest.raises(NameNotFoundInDataStore) as e:
            ds.get("number3", "general")
        assert "Couldn't find number3 in data store" in e.value.args[0]

    def test_get_default(self, ds):
        ds.set("number", 3, "general")
        assert ds.get_default("number", "general", 45) == 3
        assert ds.get_default("number", "general.sub", 45) == 3
        assert ds.get_default("other", 45) == 45

    def test_search(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 22, "general2")
        ds.set("number", 22, "general.sub")
        assert ds.search_name("number") == ["general", "general.sub", "general2"]

    def test_raise_not_in_scope(self, ds):
        ds.set("number", 11, "general.sub")
        with pytest.raises(NameNotFoundInScope) as e:
            ds.get("number", "general.sub2")
        assert "Couldn't find number in scope general.sub2 . number is only defined in ['general.sub']" in e.value.args[
            0]

    def test_list_all_scopes(self, ds):
        ds.set("number", 22, "general2")
        ds.set("number", 11, "general.sub")
        ds.set("number2", 2, "general.sub")
        ds.set("number", 3, "general.sub3")
        ds.set("number", 1, "general")
        assert ds.list_all_scopes() == ['general', 'general.sub', 'general.sub3', 'general2']

    def test_search_scope(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub") == ["number", "number1"]

    def test_search_empty_scope(self, ds):
        ds.set("number", 22, "general2")
        ds.set("number", 11, "general.sub")
        with pytest.raises(EmptyScope) as e:
            ds.search_scope("general.sub2")
        assert "Given scope general.sub2 is not part of the data store." in e.value.args[0]
        assert "Available scopes are: ['general.sub', 'general2']" in e.value.args[0]

    def test_list_all_names(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.list_all_names() == ["number", "number1", "number2"]

    def test_search_scope_and_all_superiors(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub", current_scope_only=False) == ["number", "number1"]
        assert ds.search_scope("general.sub.sub", current_scope_only=False) == ["number", "number1", "number2"]

    def test_search_scope_return_all(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub", return_all=True) == [("number", "general.sub", 11),
                                                                   ("number1", "general.sub", 22)]

    def test_search_scope_and_all_superiors_return_all(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        ds.set("number", "ABC", "general.sub.sub")
        assert ds.search_scope("general.sub", current_scope_only=False, return_all=True) == \
               [("number", "general.sub", 11), ("number1", "general.sub", 22)]
        assert ds.search_scope("general.sub.sub", current_scope_only=False, return_all=True) == \
               [("number", "general.sub.sub", "ABC"), ("number1", "general.sub", 22), ("number2", "general.sub.sub", 3)]

    def test_create_args_dict_default_scope(self, ds_with_content):
        args = ["tester1", "tester2", "tester3", "tester4"]
        assert ds_with_content.create_args_dict(args) == {"tester1": 1, "tester2": 11, "tester3": 21}

    def test_create_args_dict_given_scope(self, ds_with_content):
        args = ["tester1", "tester2", "tester3", "tester4"]
        assert ds_with_content.create_args_dict(args, "general.sub") == {"tester1": 1, "tester2": 10, "tester3": 21}

    def test_create_args_dict_missing_entry(self, ds_with_content):
        args = ["tester1", "notAvail", "tester4"]
        assert ds_with_content.create_args_dict(["notAvail", "alsonot"]) == {}
        assert ds_with_content.create_args_dict(args) == {"tester1": 1}

    def test_set_args_from_dict(self, ds):
        ds.set_from_dict({"tester1": 1, "tester2": 10, "tester3": 21})
        assert ds.get("tester1", "general") == 1
        assert ds.get("tester2", "general") == 10
        assert ds.get("tester3", "general") == 21
        ds.set_from_dict({"tester1": 111}, "general.sub")
        assert ds.get("tester1", "general.sub") == 111
        assert ds.get("tester3", "general.sub") == 21

    def test_no_scope_given(self, ds):
        ds.set("tester", 34)
        assert ds._store["tester"]["general"] == 34
        assert ds.get("tester") == 34
        assert ds.get("tester", "sub") == 34
        ds.set("tester", 99, "sub")
        assert ds.list_all_scopes() == ["general", "general.sub"]
        assert ds.get_default("test2", 4) == 4
        assert ds.get_default("tester", "sub", 4) == 99
        ds.set("test2", 4)
        assert sorted(ds.search_scope(current_scope_only=False)) == sorted(["tester", "test2"])
        assert ds.search_scope("sub", current_scope_only=True) == ["tester"]


class TestDataStoreByScope:

    @pytest.fixture
    def ds(self):
        return DataStoreByScope()

    @pytest.fixture
    def ds_with_content(self, ds):
        ds.set("tester1", 1, "general")
        ds.set("tester2", 11, "general")
        ds.set("tester2", 10, "general.sub")
        ds.set("tester3", 21, "general")
        return ds

    def test_put_with_scope(self, ds):
        ds.set("number", 3, "general.subscope")
        assert ds._store["general.subscope"]["number"] == 3

    def test_get(self, ds):
        ds.set("number", 3, "general.subscope")
        assert ds.get("number", "general.subscope") == 3

    def test_get_with_sub_scope(self, ds):
        ds.set("number", 3, "general")
        ds.set("number", 10, "general.subscope")
        assert ds.get("number", "general.subscope") == 10
        assert ds.get("number", "general") == 3

    def test_get_with_not_existing_sub_scope(self, ds):
        ds.set("number", 3, "general")
        ds.set("number2", 10, "general.subscope")
        ds.set("number2", 1, "general")
        assert ds.get("number", "general.subscope") == 3

    def test_raise_not_in_data_store(self, ds):
        ds.set("number", 22, "general")
        with pytest.raises(NameNotFoundInDataStore) as e:
            ds.get("number3", "general")
        assert "Couldn't find number3 in data store" in e.value.args[0]

    def test_get_default(self, ds):
        ds.set("number", 3, "general")
        assert ds.get_default("number", "general", 45) == 3
        assert ds.get_default("number", "general.sub", 45) == 3
        assert ds.get_default("other", "other", 45) == 45

    def test_search(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 22, "general2")
        ds.set("number", 22, "general.sub")
        assert ds.search_name("number") == ["general", "general.sub", "general2"]

    def test_raise_not_in_scope(self, ds):
        ds.set("number", 11, "general.sub")
        with pytest.raises(NameNotFoundInScope) as e:
            ds.get("number", "general.sub2")
        assert "Couldn't find number in scope general.sub2 . number is only defined in ['general.sub']" in e.value.args[
            0]

    def test_list_all_scopes(self, ds):
        ds.set("number", 22, "general2")
        ds.set("number", 11, "general.sub")
        ds.set("number2", 2, "general.sub")
        ds.set("number", 3, "general.sub3")
        ds.set("number", 1, "general")
        assert ds.list_all_scopes() == ['general', 'general.sub', 'general.sub3', 'general2']

    def test_search_scope(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub") == ["number", "number1"]

    def test_search_empty_scope(self, ds):
        ds.set("number", 22, "general2")
        ds.set("number", 11, "general.sub")
        with pytest.raises(EmptyScope) as e:
            ds.search_scope("general.sub2")
        assert "Given scope general.sub2 is not part of the data store." in e.value.args[0]
        assert "Available scopes are: ['general.sub', 'general2']" in e.value.args[0]

    def test_list_all_names(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.list_all_names() == ["number", "number1", "number2"]

    def test_search_scope_and_all_superiors(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub", current_scope_only=False) == ["number", "number1"]
        assert ds.search_scope("general.sub.sub", current_scope_only=False) == ["number", "number1", "number2"]

    def test_search_scope_return_all(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        assert ds.search_scope("general.sub", return_all=True) == [("number", "general.sub", 11),
                                                                   ("number1", "general.sub", 22)]

    def test_search_scope_and_all_superiors_return_all(self, ds):
        ds.set("number", 22, "general")
        ds.set("number", 11, "general.sub")
        ds.set("number1", 22, "general.sub")
        ds.set("number2", 3, "general.sub.sub")
        ds.set("number", "ABC", "general.sub.sub")
        assert ds.search_scope("general.sub", current_scope_only=False, return_all=True) == \
               [("number", "general.sub", 11), ("number1", "general.sub", 22)]
        assert ds.search_scope("general.sub.sub", current_scope_only=False, return_all=True) == \
               [("number", "general.sub.sub", "ABC"), ("number1", "general.sub", 22), ("number2", "general.sub.sub", 3)]

    def test_create_args_dict_default_scope(self, ds_with_content):
        args = ["tester1", "tester2", "tester3", "tester4"]
        assert ds_with_content.create_args_dict(args) == {"tester1": 1, "tester2": 11, "tester3": 21}

    def test_create_args_dict_given_scope(self, ds_with_content):
        args = ["tester1", "tester2", "tester3", "tester4"]
        assert ds_with_content.create_args_dict(args, "general.sub") == {"tester1": 1, "tester2": 10, "tester3": 21}

    def test_create_args_dict_missing_entry(self, ds_with_content):
        args = ["tester1", "notAvail", "tester4"]
        assert ds_with_content.create_args_dict(["notAvail", "alsonot"]) == {}
        assert ds_with_content.create_args_dict(args) == {"tester1": 1}

    def test_set_args_from_dict(self, ds):
        ds.set_from_dict({"tester1": 1, "tester2": 10, "tester3": 21})
        assert ds.get("tester1", "general") == 1
        assert ds.get("tester2", "general") == 10
        assert ds.get("tester3", "general") == 21
        ds.set_from_dict({"tester1": 111}, "general.sub")
        assert ds.get("tester1", "general.sub") == 111
        assert ds.get("tester3", "general.sub") == 21

    def test_no_scope_given(self, ds):
        ds.set("tester", 34)
        assert ds._store["general"]["tester"] == 34
        assert ds.get("tester") == 34
        assert ds.get("tester", "sub") == 34
        ds.set("tester", 99, "sub")
        assert ds.list_all_scopes() == ["general", "general.sub"]
        assert ds.get_default("test2", 4) == 4
        assert ds.get_default("tester", "sub", 4) == 99
        ds.set("test2", 4)
        assert sorted(ds.search_scope(current_scope_only=False)) == sorted(["tester", "test2"])
        assert ds.search_scope("sub", current_scope_only=True) == ["tester"]


class TestCorrectScope:

    @staticmethod
    @CorrectScope
    def function1(a, scope, b=44):
        return a, scope, b

    def test_init(self):
        assert self.function1(22, "general") == (22, "general", 44)
        assert self.function1(21) == (21, "general", 44)
        assert self.function1(55, "sub", 34) == (55, "general.sub", 34)
        assert self.function1("string", b=99, scope="tester") == ("string", "general.tester", 99)


class TestTracking:
    class Tracker:
        def __init__(self):
            self.tracker = [{}]

        @TrackParameter
        def function2(self, arg1, arg2, arg3):
            return

    @staticmethod
    def function1():
        return

    def test_init(self):
        track = self.Tracker()
        track.function2(1, "2", "scopy")
        assert track.tracker == [{1: [{"method": "function2", "scope": "scopy"}]}]

    def test_track_first_entry(self):
        track = object.__new__(TrackParameter)
        track.__wrapped__ = self.function1
        tracker_obj = self.Tracker()
        assert len(tracker_obj.tracker[-1].keys()) == 0
        track.track(tracker_obj, "eins", 2)
        assert len(tracker_obj.tracker[-1].keys()) == 1
        assert tracker_obj.tracker == [{"eins": [{"method": "function1", "scope": 2}]}]
        track.track(tracker_obj, "zwei", 20)
        assert len(tracker_obj.tracker[-1].keys()) == 2
        assert tracker_obj.tracker == [{"eins": [{"method": "function1", "scope": 2}],
                                        "zwei": [{"method": "function1", "scope": 20}]}]

    def test_track_second_entry(self):
        track = object.__new__(TrackParameter)
        track.__wrapped__ = self.function1
        tracker_obj = self.Tracker()
        assert len(tracker_obj.tracker[-1].keys()) == 0
        track.track(tracker_obj, "eins", 2)
        track.track(tracker_obj, "eins", 23)
        assert len(tracker_obj.tracker[-1].keys()) == 1
        assert tracker_obj.tracker == [{"eins": [{"method": "function1", "scope": 2},
                                                 {"method": "function1", "scope": 23}]}]

    def test_decrypt_args(self):
        track = object.__new__(TrackParameter)
        assert track._decrypt_args(23) == (23,)
        assert track._decrypt_args("test", 33, 4) == ("test", 33, 4)
        assert track._decrypt_args("eins", 2) == ("eins", None, 2)