from core.builtin_concepts_ids import BuiltinConcepts
from core.concept import Concept
from core.sheerka.services.SheerkaErrorManager import SheerkaErrorManager
from core.utils import no_color_str
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestSheerkaNonRegDisplay(TestUsingMemoryBasedSheerka):

    def test_i_can_display_results_when_return_values_processing_is_on(self, capsys):
        init = [
            "def concept one as 1",
        ]

        sheerka = self.init_scenario(init)
        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("one")

        captured = capsys.readouterr()
        assert captured.out == "ReturnValue(who=evaluators.OneSuccess, status=True, value=(1001)one)\n"

    def test_i_can_display_multiple_concepts_description(self, capsys):
        init = [
            "def concept foo as 1",
            "def concept foo as 2",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("desc(foo)")

        captured = capsys.readouterr()
        assert captured.out == """id        : 1001
name      : foo
key       : foo
definition: None
type      : None
hash      : 632c9ac7f3a08777918aeee4bb53712caedc634a863ae39a641f69055ae2e238
body      : 1
where     : None
pre       : None
post      : None
ret       : None
vars      : []
props     : {}
id        : 1002
name      : foo
key       : foo
definition: None
type      : None
hash      : 23a1a8bc5966982471aa19b8452e22d414a55d704431866e198570913d47fd7d
body      : 2
where     : None
pre       : None
post      : None
ret       : None
vars      : []
props     : {}
"""

    def test_i_can_display_multiple_concepts_description_when_concept_definition(self, capsys):
        init = [
            "def concept foo as 1",
            "def concept foo as 2 where True",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("desc(c:foo:)")
        captured = capsys.readouterr()
        assert captured.out == """id        : 1001
name      : foo
key       : foo
definition: None
type      : None
hash      : 632c9ac7f3a08777918aeee4bb53712caedc634a863ae39a641f69055ae2e238
body      : 1
where     : None
pre       : None
post      : None
ret       : None
vars      : []
props     : {}
id        : 1002
name      : foo
key       : foo
definition: None
type      : None
hash      : 60e442c59940a2616a3783d2e34f428f4a5ae456a88539bba9a5e87cf77060a6
body      : 2 
where     : True
pre       : None
post      : None
ret       : None
vars      : []
props     : {}
"""

    def test_i_can_describe_a_rule(self, capsys):
        sheerka = self.get_sheerka()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("desc(r:|1:)")
        captured = capsys.readouterr()

        assert captured.out == """id       : 1
name     : Print return values
type     : print
predicate: __rets
action   : list(__rets)
priority : 4
compiled : True
enabled  : True
"""

    def test_i_can_display_multiple_success(self, capsys):
        init = [
            "def concept foo as 1",
            "def concept foo as 2",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("foo")

        captured = capsys.readouterr()
        assert captured.out == """ReturnValue(who=evaluators.Concept, status=True, value=(1001)foo)
ReturnValue(who=evaluators.Concept, status=True, value=(1002)foo)
"""

    def test_i_can_list_ontologies(self, capsys):
        init = [
            "push_ontology('test 1')",
            "push_ontology('test 2')",
            "pop_ontology()",
            "push_ontology('test 3')",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("ontologies()")

        captured = capsys.readouterr()
        assert captured.out == """test 3
test 1
#unit_test#
__default__
"""

    def test_i_can_display_objects_in_memory(self, capsys):
        init = [
            "def concept one as 1",
            "def concept two as 2",
            "eval one",
            "eval two"
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("in_memory()")
        captured = capsys.readouterr()
        assert captured.out == """one: (1001)one
two: (1002)two
"""

    def test_i_can_retrieve_history(self, capsys):
        init = [
            "test()",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        res = sheerka.evaluate_user_input(f"history()")

        assert len(res) == 1
        assert res[0].status

        captured = capsys.readouterr()
        assert " : test()" in captured.out
        assert " : history()" in captured.out

    def test_i_can_list_debug_settings(self, capsys):
        init = [
            "set_debug_var('Sya.parsers.*', 45)",
            "set_debug_concept('c:|1015', '13+')",
            "set_debug_rule('Out')",
        ]
        sheerka = self.init_scenario(init)
        capsys.readouterr()

        sheerka.enable_process_return_values = True
        res = sheerka.evaluate_user_input(f"list_debug_settings()")

        assert len(res) == 1
        assert res[0].status

        captured = capsys.readouterr()
        assert captured.out == """DebugItem(type=vars, setting=Sya.parsers.*, context_id=45, debug_id=None, context_children=False, debug_children=False (enabled=True))
DebugItem(type=concepts, setting=c:|1015.*.*, context_id=13, debug_id=None, context_children=True, debug_children=False (enabled=True))
DebugItem(type=rules, setting=Out.*.*, context_id=None, debug_id=None, context_children=False, debug_children=False (enabled=True))
"""

    def test_i_can_display_errors(self, capsys):
        sheerka = self.get_sheerka()
        context = self.get_context(message="xxxTESTxxx::get_last_errors()")
        service = sheerka.services[SheerkaErrorManager.NAME]

        simple_error = sheerka.new(BuiltinConcepts.UNKNOWN_CONCEPT, body=Concept("foo"))
        ret1 = sheerka.ret("Test1", False, simple_error)

        multiple_level_errors1 = sheerka.err("Err1")
        multiple_level_errors2 = sheerka.err(multiple_level_errors1)
        multiple_level_errors3 = sheerka.err(multiple_level_errors2)
        ret2 = sheerka.ret("Test5", False, multiple_level_errors3)

        context.add_values(return_values=[ret1, ret2])
        service.on_user_input_evaluated(context)

        sheerka.enable_process_return_values = True
        sheerka.evaluate_user_input("get_last_errors(level=0)")

        captured = capsys.readouterr()
        colorless_captured = no_color_str(captured.out)
        assert colorless_captured == """xxx : xxxTESTxxx::get_last_errors()
[  0] Test1 (47)__UNKNOWN_CONCEPT: (None)foo
[  1] Test5 (46)__ERROR: (46)__ERROR: (46)__ERROR: Err1
"""

        sheerka.evaluate_user_input("get_last_errors(id=1, depth=3)")
        captured = capsys.readouterr()
        colorless_captured = no_color_str(captured.out)
        assert colorless_captured == """xxx : xxxTESTxxx::get_last_errors()
[  1] Test5 (46)__ERROR: (46)__ERROR: (46)__ERROR: Err1
[  2]   Test5 (46)__ERROR: (46)__ERROR: Err1
[  3]     Test5 (46)__ERROR: Err1
"""