import ast

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
from core.concept import Concept
from core.sheerka.ExecutionContext import ExecutionContext
from parsers.BnfParser import BnfParser
from sdp.sheerkaDataProvider import Event


class BaseTest:
    def get_sheerka(self, **kwargs):
        pass

    def get_context(self, sheerka=None):
        return ExecutionContext("test", Event(), sheerka or self.get_sheerka())

    def get_default_concept(self):
        concept = Concept(
            name="a + b",
            where="isinstance(a, int) and isinstance(b, int)",
            pre="isinstance(a, int) and isinstance(b, int)",
            post="isinstance(res, int)",
            body="def func(x,y):\n    return x+y\nfunc(a,b)",
            desc="specific description")
        concept.def_prop("a", "value1")
        concept.def_prop("b", "value2")

        return concept

    def dump_ast(self, node):
        dump = ast.dump(node)
        for to_remove in [", ctx=Load()", ", kind=None", ", type_ignores=[]"]:
            dump = dump.replace(to_remove, "")
        return dump

    def init_concepts(self, *concepts, **kwargs):
        sheerka = self.get_sheerka(**kwargs)
        context = self.get_context(sheerka)
        create_new = kwargs.get("create_new", False)

        result = []
        for c in concepts:
            if isinstance(c, str):
                c = Concept(c)

            if c.metadata.definition:
                bnf_parser = BnfParser()
                res = bnf_parser.parse(context, c.metadata.definition)
                if res.status:
                    c.bnf = res.value.value
                sheerka.create_new_concept(context, c)
            elif create_new:
                sheerka.create_new_concept(context, c)
            else:
                c.init_key()
                sheerka.set_id_if_needed(c, False)
                sheerka.add_in_cache(c)

            result.append(c)

        return sheerka, context, *result

    @staticmethod
    def retval(obj, who="who", status=True):
        """ret_val"""
        return ReturnValueConcept.ret(who, status, obj)

    @staticmethod
    def tretval(sheerka, obj, who="who"):
        """True ret_val + add concept in cache"""
        if isinstance(obj, Concept):
            obj.init_key()
            if obj.key not in sheerka.cache_by_key:
                sheerka.cache_by_key[obj.key] = obj
        return sheerka.ret(who, True, obj)

    @staticmethod
    def pretval(concept, source=None, parser="parsers.name"):
        """ParserResult ret_val (p stands for ParserResult)"""
        return ReturnValueConcept(
            "some_name",
            True,
            ParserResultConcept(parser=parser,
                                source=source or concept.name,
                                value=concept,
                                try_parsed=concept))