import types

import pytest
from core.builtin_concepts import BuiltinConcepts
from core.sheerka.ExecutionContext import ExecutionContext
from core.sheerka.services.SheerkaResultManager import SheerkaResultConcept
from sdp.sheerkaDataProvider import Event

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestSheerkaResultManager(TestUsingMemoryBasedSheerka):
    io_cache = None

    @classmethod
    def setup_class(cls):
        sheerka = cls().get_sheerka()
        sheerka.save_execution_context = True
        sheerka.evaluate_user_input("def concept one as 1")
        cls.io_cache = sheerka.sdp.io.cache.copy()

    @classmethod
    def teardown_class(cls):
        sheerka = cls().get_sheerka()
        sheerka.save_execution_context = False

    def init_test(self):
        sheerka, context = self.init_concepts()
        sheerka.sdp.io.cache = self.io_cache.copy()
        return sheerka, context

    def test_i_can_get_the_result_by_digest(self):
        sheerka, context = self.init_test()

        digest = sheerka.get_last_execution().event.get_digest()

        res = sheerka.get_results_by_digest(context, digest)

        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "def concept one as 1"
        assert res.digest == digest
        assert isinstance(res.body, types.GeneratorType)

        assert sheerka.load_var(SheerkaResultConcept.NAME, "digest") == digest

        previous_results = list(res.body)

        # Second test,
        # I can get the result from the recorded digest
        res = sheerka.get_results(context)
        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "def concept one as 1"
        assert res.digest == digest
        assert isinstance(res.body, types.GeneratorType)

        assert list(res.body) == previous_results

    def test_i_cannot_get_result_by_digest_if_the_digest_does_not_exist(self):
        sheerka, context = self.init_concepts()

        res = sheerka.get_results_by_digest(context, "fake digest")
        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {'digest': 'fake digest'}

    def test_i_cannot_get_results_if_no_previous_digest(self):
        sheerka, context = self.init_concepts()
        assert sheerka.get_results(context) is None

    def test_i_can_get_the_result_by_command_name(self):
        sheerka, context = self.init_test()

        digest = sheerka.get_last_execution().event.get_digest()
        sheerka.evaluate_user_input("one")  # another command

        res = sheerka.get_results_by_command(context, "def concept")
        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "def concept one as 1"
        assert res.digest == digest
        assert isinstance(res.body, types.GeneratorType)

    def test_i_can_get_the_result_by_command_when_not_in_the_same_page_size(self):
        sheerka, context = self.init_test()

        sheerka.evaluate_user_input("one")
        sheerka.evaluate_user_input("one")
        sheerka.evaluate_user_input("one")

        service = SheerkaResultConcept(sheerka, 2)
        res = service.get_results_by_command(context, "def concept")
        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "def concept one as 1"

    def test_i_cannot_get_results_from_command_if_the_command_does_not_exist(self):
        sheerka, context = self.init_concepts()

        res = sheerka.get_results_by_command(context, "def concept")
        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {'command': 'def concept'}

    def test_i_cannot_get_result_from_command_if_the_command_does_not_exists_multiple_pages(self):
        sheerka, context = self.init_test()

        sheerka.evaluate_user_input("one")
        sheerka.evaluate_user_input("one")
        sheerka.evaluate_user_input("one")

        service = SheerkaResultConcept(sheerka, 2)
        res = service.get_results_by_command(context, "fake command")
        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {'command': 'fake command'}

    def test_i_can_get_last_results(self):
        sheerka, context = self.init_test()

        sheerka.evaluate_user_input("one")

        res = sheerka.get_last_results(context)
        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "one"

    def test_i_can_get_last_results_when_event_with_no_result(self):
        sheerka, context = self.init_concepts()

        sheerka.sdp.save_event(Event("event 1"))
        sheerka.sdp.save_event(Event("event 2"))
        sheerka.sdp.save_event(Event("event 3"))
        sheerka.evaluate_user_input("def concept one as 1")

        res = sheerka.get_last_results(context)
        assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
        assert res.command == "def concept one as 1"

    def test_i_cannot_get_last_results_when_no_result(self):
        sheerka, context = self.init_concepts()

        res = sheerka.get_last_results(context)
        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {'query': 'last'}

    def test_i_cannot_get_last_results_when_only_events(self):
        sheerka, context = self.init_concepts()

        sheerka.sdp.save_event(Event("event 1"))
        sheerka.sdp.save_event(Event("event 2"))
        sheerka.sdp.save_event(Event("event 3"))

        res = sheerka.get_last_results(context)
        assert sheerka.isinstance(res, BuiltinConcepts.NOT_FOUND)
        assert res.body == {'query': 'last'}

    @pytest.mark.parametrize('kwargs', [
        {"desc": "Evaluating 'def concept one as 1'"},
        {"id": 0},
        {"desc": "Evaluating 'def concept one as 1'", "id": 0}
    ])
    def test_i_can_get_last_results_using_kwarg(self, kwargs):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()

        res = sheerka.get_last_results(context, **kwargs)
        items = list(res.body)

        assert len(items) == 1
        for k, v in kwargs.items():
            assert getattr(items[0], k) == v

    @pytest.mark.parametrize('predicate, expected', [
        ('desc.startswith("Evaluating \'def concept one as 1\'")', {"desc": "Evaluating 'def concept one as 1'"}),
        ("id == 0", {"id": 0}),
        ("'def concept one as 1' in desc and id == 0", {"desc": "Evaluating 'def concept one as 1'", "id": 0})
    ])
    def test_i_can_get_last_results_using_filter(self, predicate, expected):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()

        res = sheerka.get_last_results(context, filter=predicate)
        items = list(res.body)

        assert len(items) == 1
        for k, v in expected.items():
            assert getattr(items[0], k) == v

    @pytest.mark.parametrize('predicate, expected', [
        ('desc.startswith("Evaluating \'def concept one as 1\'")', {"desc": "Evaluating 'def concept one as 1'"}),
        ("id == 0", {"id": 0}),
        ("'def concept one as 1' in desc and id == 0", {"desc": "Evaluating 'def concept one as 1'", "id": 0})
    ])
    def test_i_can_get_last_results_using_the_first_argument_to_filter(self, predicate, expected):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()

        res = sheerka.get_last_results(context, predicate)
        items = list(res.body)

        assert len(items) == 1
        for k, v in expected.items():
            assert getattr(items[0], k) == v

    @pytest.mark.parametrize('kwargs', [
        {"desc": "Evaluating 'def concept one as 1'"},
        {"id": 0},
        {"desc": "Evaluating 'def concept one as 1'", "id": 0}
    ])
    def test_i_can_get_results_using_kwarg(self, kwargs):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()
        sheerka.get_last_results(context)

        res = sheerka.get_results(context, **kwargs)
        items = list(res.body)

        assert len(items) == 1
        for k, v in kwargs.items():
            assert getattr(items[0], k) == v

    @pytest.mark.parametrize('predicate, expected', [
        ('desc.startswith("Evaluating \'def concept one as 1\'")', {"desc": "Evaluating 'def concept one as 1'"}),
        ("id == 0", {"id": 0}),
        ("'def concept one as 1' in desc and id == 0", {"desc": "Evaluating 'def concept one as 1'", "id": 0})
    ])
    def test_i_can_get_results_using_filter(self, predicate, expected):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()
        sheerka.get_last_results(context)

        res = sheerka.get_results(context, filter=predicate)
        items = list(res.body)

        assert len(items) == 1
        for k, v in expected.items():
            assert getattr(items[0], k) == v

    @pytest.mark.parametrize('predicate, expected', [
        ('desc.startswith("Evaluating \'def concept one as 1\'")', {"desc": "Evaluating 'def concept one as 1'"}),
        ("id == 0", {"id": 0}),
        ("'def concept one as 1' in desc and id == 0", {"desc": "Evaluating 'def concept one as 1'", "id": 0})
    ])
    def test_i_can_get_results_using_the_first_argument_to_filter(self, predicate, expected):
        sheerka, context = self.init_test()
        ExecutionContext.ids.clear()
        sheerka.get_last_results(context)

        res = sheerka.get_results(context, predicate)
        items = list(res.body)

        assert len(items) == 1
        for k, v in expected.items():
            assert getattr(items[0], k) == v

    def test_i_can_manage_invalid_predicates(self):
        predicate = {"filter": "a b c"}
        with pytest.raises(SyntaxError):
            SheerkaResultConcept.get_predicate(**predicate)