from core.concept import Concept, ConceptParts, CC
from core.sheerka.services.SheerkaExecute import ParserInput
from parsers.BaseNodeParser import CNC
from parsers.BnfNodeParser import BnfNodeParser
from parsers.SyaNodeParser import SyaNodeParser
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
from tests.parsers.parsers_utils import get_test_obj


class TestParsersUtils(TestUsingMemoryBasedSheerka):

    def test_i_can_get_test_obj_when_CNC_from_sya(self):
        sheerka, context, one, two, plus = self.init_concepts(
            "one",
            "two",
            Concept("a plus b").def_var("a").def_var("b")
        )

        parser = SyaNodeParser().init_from_concepts(context, [one, two, plus])
        cnode = parser.parse(context, ParserInput("one plus two")).body.body[0]

        # compare all attributes
        cnc_res = get_test_obj(CNC(concept_key="key", start=0, end=1, source="", exclude_body=False), cnode)
        assert isinstance(cnc_res, CNC)
        assert cnc_res == CNC("__var__0 plus __var__1", 0, 4, "one plus two", False, **cnode.concept.get_compiled())

        # I can discard start, end and source
        cnc_res = get_test_obj(CNC(concept_key="key"), cnode)
        assert isinstance(cnc_res, CNC)
        assert cnc_res == CNC("__var__0 plus __var__1", None, None, None, False, **cnode.concept.get_compiled())

    def test_i_can_get_test_obj_when_CNC_from_bnf(self):
        sheerka, context, one, two, plus = self.init_concepts(
            "one",
            "two",
            Concept("twenties", definition="'twenty' (one | two)=unit").def_var("unit").def_var("one").def_var("two")
        )

        parser = BnfNodeParser().init_from_concepts(context, [one, two, plus])
        cnode = parser.parse(context, ParserInput("twenty one")).body.body[0]

        # compare all attributes
        cnc_res = get_test_obj(CNC(concept_key="key", start=0, end=1, source="", exclude_body=False), cnode)
        assert isinstance(cnc_res, CNC)
        assert cnc_res == CNC("twenties", 0, 2, "twenty one", False, **cnode.concept.get_compiled())

        # I can exclude body
        cnc_res = get_test_obj(CNC(concept_key="key", exclude_body=True), cnode)
        expected_compiled = {k: v for k, v in cnode.concept.get_compiled().items()}
        del expected_compiled[ConceptParts.BODY]
        assert isinstance(cnc_res, CNC)
        assert cnc_res == CNC("twenties", None, None, None, False, **expected_compiled)

    def test_i_can_get_test_obj_when_list(self):
        sheerka, context, one, two, plus = self.init_concepts(
            "one",
            "two",
            Concept("a plus b").def_var("a").def_var("b")
        )

        parser = SyaNodeParser().init_from_concepts(context, [one, two, plus])
        cnode = parser.parse(context, ParserInput("one plus two")).body.body[0]

        res = get_test_obj([CNC("key1"), CNC("key", 0, 1, "")], [cnode, cnode])

        assert len(res) == 2
        assert isinstance(res[0], CNC)
        assert res[0] == CNC("__var__0 plus __var__1", None, None, None, False, **cnode.concept.get_compiled())
        assert isinstance(res[1], CNC)
        assert res[1] == CNC("__var__0 plus __var__1", 0, 4, "one plus two", False, **cnode.concept.get_compiled())

    def test_i_can_get_test_obj_when_dict(self):
        sheerka, context, one, two, plus = self.init_concepts(
            "one",
            "two",
            Concept("a plus b").def_var("a").def_var("b")
        )

        parser = SyaNodeParser().init_from_concepts(context, [one, two, plus])
        cnode = parser.parse(context, ParserInput("one plus two")).body.body[0]

        res = get_test_obj({"key1": CNC("key1"), "key2": CNC("key", 0, 1, "")}, {"key1": cnode, "key2": cnode})
        assert len(res) == 2
        assert isinstance(res["key1"], CNC)
        assert res["key1"] == CNC("__var__0 plus __var__1", None, None, None, False, **cnode.concept.get_compiled())
        assert isinstance(res["key2"], CNC)
        assert res["key2"] == CNC("__var__0 plus __var__1", 0, 4, "one plus two", False, **cnode.concept.get_compiled())

    def test_i_can_get_test_obj_when_CC(self):
        sheerka, context, one, two, plus = self.init_concepts(
            "one",
            "two",
            Concept("twenties", definition="'twenty' (one | two)=unit").def_var("unit").def_var("one").def_var("two")
        )

        parser = BnfNodeParser().init_from_concepts(context, [one, two, plus])
        cc = parser.parse(context, ParserInput("twenty one")).body.body[0].concept

        # compare all attributes
        cc_res = get_test_obj(CC(concept="key", source="", exclude_body=False), cc)
        assert isinstance(cc_res, CC)
        assert cc_res == CC("twenties", "twenty one", False, **cc.get_compiled())

        # I can exclude body
        cnc_res = get_test_obj(CC(concept="key", exclude_body=True), cc)
        expected_compiled = {k: v for k, v in cc.get_compiled().items()}
        del expected_compiled[ConceptParts.BODY]
        assert isinstance(cnc_res, CC)
        assert cnc_res == CC("twenties", "twenty one", True, **expected_compiled)