import ast

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


class BaseTest:
    def get_sheerka(self):
        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

    @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"""
        return ReturnValueConcept(
            "some_name",
            True,
            ParserResultConcept(parser=parser,
                                source=source or concept.name,
                                value=concept,
                                try_parsed=concept))