# encoding=utf-8
# MIT License
#
# Copyright (c) 2023 TommyLemon
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import asyncio
import builtins
import json
import os
import re
import time
import inspect
import types
import typing
from typing import Type

null = None
false = False
true = True

KEY_OK = 'ok'
KEY_CODE = 'code'
KEY_MSG = 'msg'
KEY_THROW = 'throw'
KEY_TRACE = 'trace'

CODE_SUCCESS = 200
CODE_SERVER_ERROR = 500
MSG_SUCCESS = 'success'
LANGUAGE = 'Python'

KEY_LANGUAGE = "language"
KEY_REUSE = "reuse"
KEY_UI = "ui"
KEY_TIME = "time"
KEY_TIMEOUT = "timeout"
KEY_PACKAGE = "package"
KEY_THIS = "this"
KEY_CLASS = "class"
KEY_CONSTRUCTOR = "constructor"
KEY_KEY = "key"
KEY_TYPE = "type"
KEY_AT_TYPE = "@type"
KEY_VALUE = "value"
KEY_WARN = "warn"
KEY_STATIC = "static"
KEY_ASYNC = "async"
KEY_NAME = "name"
KEY_METHOD = "method"
KEY_MOCK = "mock"
KEY_QUERY = "query"
KEY_DEPTH = "depth"
KEY_RETURN = "return"
KEY_TIME_DETAIL = "time:start|duration|end"
KEY_CLASS_ARGS = "classArgs"
KEY_METHOD_ARGS = "methodArgs"
KEY_ARGS = "args"
KEY_CALLBACK = "callback"
KEY_GLOBAL = "global"

KEY_CALL_LIST = "call()[]"
KEY_CALL_MAP = "call(){}"
KEY_PACKAGE_TOTAL = "packageTotal"
KEY_CLASS_TOTAL = "classTotal"
KEY_METHOD_TOTAL = "methodTotal"
KEY_PACKAGE_LIST = "packageList"
KEY_CLASS_LIST = "classList"
KEY_METHOD_LIST = "methodList"

MILLIS_TIME = 1000000

PATTERN_ALPHABET = re.compile('^[A-Za-z]+$')
PATTERN_UPPER_ALPHABET = re.compile('^[A-Z]+$')
PATTERN_LOWER_ALPHABET = re.compile('^[a-z]+$')
PATTERN_NUMBER = re.compile('^[0-9]+$')
PATTERN_NAME = re.compile('^[A-Za-z0-9_]+$')


class Config:
    DEFAULT_MODULE_PATH: str = ''


config = Config()


PRIMITIVE_CLASS_MAP = {
    None: any,
    'None': any,
    'any': any,
    'bool': bool,
    'False': bool,
    'True': bool,
    'int': int,
    'float': float,
    'str': str
}

CLASS_MAP = dict(PRIMITIVE_CLASS_MAP, **{
    'object': object,
    'list': list,
    'tuple': tuple,
    'range': range,
    'slice': slice,
    'set': set,
    'reversed': reversed,
    'dict': dict,
    'map': map,
    'bytes': bytes,
    'bytearray': bytearray,
    'frozenset': frozenset,
    'enumerate': enumerate,
    'filter': filter,
    'complex': complex,
    'Exception': Exception,
    'BaseException': BaseException,
    'OSError': OSError,
    'IOError': IOError,
    'BlockingIOError': BlockingIOError,
    'EnvironmentError': EnvironmentError,
    'ConnectionError': ConnectionError,
    'BrokenPipeError': BrokenPipeError,
    'BufferError': BufferError,
    'EOFError': EOFError,
    'SyntaxError': SyntaxError,
    'FileExistsError': FileExistsError,
    'FileNotFoundError': FileNotFoundError,
    'Warning': Warning,
    'BytesWarning': BytesWarning,
    'ChildProcessError': ChildProcessError,
    'property': property,
    'classmethod': classmethod,
    'staticmethod': staticmethod,
    'super': super,
    'type': type,
    'zip': zip,
})


class InterfaceProxy:
    pass


INSTANCE_MAP = {}


def get_instance(
    clazz, value: any = null, constructor: callable = null, class_args: list = null,
    reuse: bool = false, module=null, import_fun: callable = null
):
    reuse = reuse or false
    key = str(clazz) + ('' if is_none(constructor) else '.' + str(constructor))\
        + '(' + str(class_args) + ')' if reuse else null

    instance = INSTANCE_MAP[key] if reuse else null

    if is_none(instance):
        cal = size(class_args)
        ca_keys = [null] * cal
        ca_types = [null] * cal
        ca_values = [null] * cal
        c_kwargs = {}
        init_args(class_args, ca_keys, ca_types, ca_values, c_kwargs, import_fun=import_fun)
        if constructor is None:
            instance = clazz(*ca_values, **c_kwargs)
        else:
            try:
                instance = constructor(*ca_values, **c_kwargs)
            except Exception as e:
                print(e)
                try:
                    instance = clazz.constructor(*ca_values, **c_kwargs)  # @staticmethod in class
                except Exception as e2:
                    raise Exception(
                        str(module) + ' does not have such a function, and ' + str(clazz)
                        + ' does not have a @staticmethod called ' + str(constructor)
                        + '! ' + str(e) + '; ' + str(e2)
                    )

        if reuse and not_none(instance):
            INSTANCE_MAP[key] = instance

    return instance


def on_complete(data: any, method: callable, proxy: InterfaceProxy, *extras: any):
    pass


def on_callback(data: any, method: callable, proxy: InterfaceProxy, *extras: any):
    pass


class Listener:
    complete: callable = on_complete
    callback: callable = on_callback
    getinstance: callable = get_instance


listener = Listener()


def list_method(req, import_fun: callable = null) -> dict:
    start_time = cur_time_in_millis()
    try:
        if is_str(req):
            req = parse_json(req)

        mock = req.get(KEY_MOCK)
        assert mock in [null, true, false], KEY_MOCK + ' must be in [true, false]!'

        query = req.get(KEY_QUERY)
        assert query in [null, 0, 1, 2], KEY_QUERY + ' must be in [0, 1, 2]! 0-Data, 1-Total count, 2-Both above'

        depth = req.get(KEY_DEPTH)
        assert is_int(depth, false), KEY_DEPTH + ' must be int!'

        package = req.get(KEY_PACKAGE)
        assert is_str(package), KEY_PACKAGE + ' must be str!'

        clazz = req.get(KEY_CLASS)
        assert is_str(clazz), KEY_CLASS + ' must be str!'

        method = req.get(KEY_METHOD)
        assert is_str(method), KEY_METHOD + ' must be str!'

        types = req.get('types')
        assert is_list(types), 'types must be list!'

        is_all_pkg = is_empty(package)
        is_all_cls = is_empty(clazz)
        is_all_mtd = is_empty(method)

        fl = split(clazz, '$')

        module_list = []
        import_fun = import_fun or __import__

        depth = depth or 0
        d = 0
        for root, dirs, files in os.walk(package.replace('.', '/')):
            d += 1
            if depth > 0 and d > depth:
                break

            # for name in dirs:
            #     m = import_fun(('' if is_empty(root) else root.replace('/', '.') + '.') + name.replace('/', '.'), fromlist=['__init__'])
            #     if not_none(m) and not module_list.__contains__(m):
            #         module_list.append(m)

            for name in files:
                if size(name) <= 3 or not name.endswith('.py'):
                    continue

                name = name[:-3]
                p = os.path.join(root, name).replace('/', '.')
                m = import_fun(p, fromlist=name)
                if is_none(m) or module_list.__contains__(m) or m in module_list:
                    continue

                module_list.append(m)

        if is_empty(module_list):
            try:
                mn = package if is_empty(fl) else package + '.' + fl[0]
                root_module = import_fun(mn, fromlist=['__init__'] if is_empty(fl) else fl[0])

                module_list.append(root_module)
                mdl_dict = root_module.__dict__
                vs = mdl_dict.values()
                for v in vs:
                    if type(v).__name__ == 'module' and str(v).endswith("/__init__.py'>"):  # if is_instance(v, module):
                        module_list.append(v)
                        pass

            except Exception as e:
                print(e)

        pkg_list = []

        for module_item in module_list:
            cl = []
            pkg = module_item.__name__
            pkg_str = str(module_item)
            is_file = pkg_str.endswith(".py'>") and not pkg_str.endswith("/__init__.py'>")
            file_name = null

            if is_file:
                ns = split(pkg, '.')  # 不存在这个函数 ind = last_index(pkg, '.')
                file_name = ns[-1]
                pkg = pkg[:-1-len(ns[-1])]
                # module_item = import_fun(pkg)
                # if module_item not in cl and not cl.__contains__(module_item):
                cl.append(module_item)

            if pkg.endswith('.__init__'):
                pkg = pkg[:-len('.__init__')]

            if is_empty(pkg):
                continue

            mdl_list = dir(module_item)
            l = size(mdl_list)

            cls_list = []

            if l > 1 and not is_all_cls:
                try:
                    cls = module_item
                    i = -1
                    for n in fl:
                        i += 1
                        if i <= 0:
                            continue
                        cls = getattr(cls, n)
                    cl = [cls]
                except Exception as e:
                    print(e)
            else:
                for mdl in mdl_list:
                    pn = str(mdl)
                    if is_empty(pn) or pn.startswith('_') or pn.endswith('_'):
                        continue
                    try:
                        cls = getattr(module_item, pn)
                        cm = cls.__module__ if hasattr(cls, '__module__') else null
                        if is_empty(cm) or not cm.startswith(pkg):
                            continue

                        ct = type(cls).__name__
                        s = str(cls)
                        if ct == 'function':
                            if is_file:
                                continue

                            mtd = parse_method(cls, import_fun=import_fun) if is_all_mtd or cls.__name__ == method else null
                            if is_empty(mtd):
                                continue

                            cls_list.append({
                                KEY_CLASS: file_name,
                                KEY_METHOD_LIST: [mtd]
                            })
                        if ct == 'class' or ct == 'type':
                            if cls not in cl and not cl.__contains__(cls):
                                cl.append(cls)
                        elif ct == 'module':
                            if is_file or (s.endswith(".py'>") and not s.endswith("/__init__.py'>")):
                                if cls not in cl and not cl.__contains__(cls):
                                    cl.append(cls)
                            # elif not (cls in module_list):
                            #     module_list.append(cls)
                    except Exception as e:
                        print(e)

            for cls in cl:
                cn = cls.__name__

                cs = str(cls).strip()  # 一样 cs = cls.__str__()
                ind = index(cs, "'")
                if ind >= 0:
                    cs = cs[ind + 1:]

                ind = index(cs, "'")
                if ind >= 0:
                    cs = cs[:ind]

                if not cs.startswith(pkg + '.'):
                    continue

                cs = cs[len(pkg + '.'):]
                if is_empty(cs):
                    continue

                if true:
                    ml = []
                    if callable(cls) and type(cls).__name__ == 'function':
                        if is_all_mtd or cn == method:
                            ml = [cls]
                        else:
                            continue
                    elif not is_all_mtd:
                        try:
                            func = getattr(cls, method)
                            if callable(func) and type(func).__name__ == 'function':
                                ml = [func]
                        except Exception as e:
                            print(e)
                    else:
                        ns = dir(cls)
                        if not_empty(ns):
                            for n in ns:
                                if is_empty(n) or n.startswith('_') or n.endswith('_'):
                                    continue

                                try:
                                    func = getattr(cls, n)
                                    if callable(func):
                                        ft = type(func).__name__
                                        if ft == 'function':
                                            ml.append(func)
                                        # elif ft in ('type', 'class') and str(func) == ("<class '" + cn + "." + func.__name__ + "'>"):
                                        #     cl.append(func)
                                except Exception as e:
                                    print(e)
                        # cls.__class__.methods

                    mtd_list = []
                    for mtd in ml:
                        m = parse_method(mtd, import_fun=import_fun)
                        if not_empty(m):
                            mtd_list.append(m)

                    # 不存在这个函数 ind = cn.lastindex('.')
                    # <module 'unitauto.test.testutil' from 'unitauto/test/testutil.py'>
                    # if cs.startswith("class <'"):
                    #     cs = cs[len("class <'"):]
                    # if cs.endswith("'>"):
                    #     cs = cs[:-len("'>")]

                    if is_empty(mtd_list):
                        continue

                    cls_list.append({
                        # KEY_CLASS: cn if ind < 0 else cn[ind+1:],
                        KEY_CLASS: cs.replace('.', '$'),
                        KEY_METHOD_LIST: mtd_list
                    })

            if is_empty(cls_list):
                continue

            pkg_list.append({
                KEY_PACKAGE: pkg,
                KEY_CLASS_LIST: cls_list
            })

        time_detail = get_time_detail(start_time)
        return {
            KEY_LANGUAGE: LANGUAGE,
            KEY_OK: true,
            KEY_CODE: CODE_SUCCESS,
            KEY_MSG: MSG_SUCCESS,
            KEY_PACKAGE_LIST: pkg_list,
            KEY_TIME_DETAIL: time_detail
        }
    except Exception as e:
        return {
            KEY_LANGUAGE: LANGUAGE,
            KEY_OK: false,
            KEY_CODE: CODE_SERVER_ERROR,
            KEY_MSG: str(e),
            KEY_TIME_DETAIL: get_time_detail(start_time),
            KEY_THROW: e.__class__.__name__,
            # KEY_TRACE: e.__traceback__.__str__
        }


def get_type_str_by_str(s: str, keep_prefix: bool = false, import_fun: callable = null) -> str:
    start = s.index("'") if is_contain(s, "'") else -1
    if start >= 0:
        s = s[start + 1:]
        end = s.index("'") if is_contain(s, "'") else -1
        if end >= 0:
            s = s[:end]
        s = s.strip()

    if s in (null, '', '_empty', 'inspect._empty', 'NoneType', 'POSITIONAL_OR_KEYWORD'):
        return null

    dmp = null if keep_prefix else config.DEFAULT_MODULE_PATH
    if not_empty(dmp) and s.startswith(dmp):
        s = s[len(dmp) + 1:]

    # if s.startswith('__init__.'):
    #     return s[len('__init__.'):]

    s = s.replace('.__init__.', '$')
    if '$' not in s and '.' in s:
        ks = split(s, '.')
        # util.Test.Test2 会误判为 util.Test$Test2，实际应该为 util$Test.Test2  s = '.'.join(ks[:-1]) + '$' + ks[-1]

        ns = ks[0]
        ks = ks[1:]
        is_inner_cls = false
        for k in ks:
            if (not is_inner_cls) and not is_module_path(ns + '.' + k, import_fun):  # is_big_name(k)
                is_inner_cls = true

            ns += ('$' if is_inner_cls else '.') + k

        return ns

    return s


def is_module_path(path: str, import_fun: callable = null) -> bool:
    try:
        import_fun = import_fun or __import__
        m = import_fun(path)
        return not_none(m)
    except Exception as e:
        print(e)
    return false


def get_type_str(return_annotation, instance: any = null, keep_prefix: bool = false, import_fun: callable = null) -> str:
    rt = get_type_str_by_str(str(return_annotation), keep_prefix=keep_prefix, import_fun=import_fun)
    if is_empty(rt):
        rt = get_type_str_by_str(str(type(instance)), keep_prefix=keep_prefix, import_fun=import_fun)
    return rt


def parse_method(func, import_fun: callable = null) -> dict:
    signature = null if func is None else inspect.signature(func)
    if signature is None:
        return {}

    return_annotation = signature.return_annotation
    rt = get_type_str(return_annotation, keep_prefix=true, import_fun=import_fun)

    types = []
    for param in signature.parameters.values():
        a = null if param is None else param.annotation
        n = null
        if a is not None:
            try:
                n = a.__name__
            except Exception as e:
                n = str(a)

        types.append('any' if is_empty(n) or n in ('_empty', 'POSITIONAL_OR_KEYWORD') else n)

    names = [param.name for param in signature.parameters.values()]
    static = is_empty(names) or names[0] != 'self'
    name = func.__name__
    return {
        KEY_STATIC: static,
        'returnType': rt,
        'genericReturnType': rt,
        KEY_METHOD: name,
        KEY_NAME: name,
        'parameterTypeList': types if static else types[1:],
        'genericParameterTypeList': types if static else types[1:],
        'parameterNameList': names if static else names[1:],
        'parameterDefaultValueList': null
    }


def wrap_result(
    instance, func, method_args, ma_types, ma_values, result, start_time,
    json_dumps: callable = null, json_loads: callable = null, import_fun: callable = null
):
    time_detail = get_time_detail(start_time)

    signature = inspect.signature(func)
    return_annotation = null if signature is None else signature.return_annotation
    rt = get_type_str(return_annotation, result, import_fun=import_fun)

    mal = size(method_args)
    mas = [null] * mal

    json_dumps = json_dumps or json.dumps
    if mal > 0:  # bug 要及时发现 and size(ma_values) == mal:
        i = -1
        for v in ma_values:
            i += 1

            if callable(v):
                mas[i] = method_args[i]
                continue

            t = ma_types[i]

            try:
                json_dumps(v)
            except Exception as e:
                print(e)
                v = str(v)

            mas[i] = {
                KEY_TYPE: t.__name__ if t is not None else type(v),
                KEY_VALUE: v
            }

    if is_none(instance):
        if result is None and is_empty(rt):
            return {
                KEY_LANGUAGE: LANGUAGE,
                KEY_OK: true,
                KEY_CODE: CODE_SUCCESS,
                KEY_MSG: MSG_SUCCESS,
                KEY_METHOD_ARGS: mas,
                KEY_TIME_DETAIL: time_detail
            }

        return {
            KEY_LANGUAGE: LANGUAGE,
            KEY_OK: true,
            KEY_CODE: CODE_SUCCESS,
            KEY_MSG: MSG_SUCCESS,
            KEY_TYPE: rt,
            KEY_RETURN: result,
            KEY_METHOD_ARGS: mas,
            KEY_TIME_DETAIL: time_detail
        }

    cls = type(instance)
    this = {
        KEY_TYPE: cls.__name__,
    }

    json_loads = json_loads or json.loads
    try:
        json_dumps(instance)
        this[KEY_VALUE] = instance
    except Exception as e:
        print(e)
        try:
            this[KEY_VALUE] = json_loads(json_dumps(instance, cls=cls))
        except Exception as e2:
            print(e2)
            try:
                this[KEY_VALUE] = json_loads(instance.encode(null))
            except Exception as e3:
                print(e3)  # FIXME instance.__dict__ , dir(instance)
                this[KEY_VALUE] = str(instance)
                this[KEY_WARN] = str(e)

    if result is None and is_empty(rt):
        return {
            KEY_LANGUAGE: LANGUAGE,
            KEY_OK: true,
            KEY_CODE: CODE_SUCCESS,
            KEY_MSG: MSG_SUCCESS,
            KEY_METHOD_ARGS: mas,
            KEY_THIS: this,
            KEY_TIME_DETAIL: time_detail
        }

    return {
        KEY_LANGUAGE: LANGUAGE,
        KEY_OK: true,
        KEY_CODE: CODE_SUCCESS,
        KEY_MSG: MSG_SUCCESS,
        KEY_TYPE: rt,
        KEY_RETURN: result,
        KEY_METHOD_ARGS: mas,
        KEY_THIS: this,
        KEY_TIME_DETAIL: time_detail
    }


def invoke_method(
    req: any, callback: callable = null, getinstance: callable = null,
    json_dumps: callable = null, json_loads: callable = null, import_fun: callable = null
) -> dict:
    start_time = time.time_ns()
    is_wait = false
    try:
        getinstance = getinstance or get_instance
        json_dumps = json_dumps or to_json_str
        json_loads = json_loads or parse_json
        import_fun = import_fun or __import__

        assert is_none(callback) or callable(callback)

        if is_str(req):
            req = json_loads(req)

        reuse = req.get(KEY_REUSE)
        assert is_bool(reuse), (KEY_REUSE + ' must be bool!')

        static = req.get(KEY_STATIC)
        assert is_bool(static), (KEY_STATIC + ' must be bool!')

        is_async = req.get(KEY_ASYNC)
        assert is_bool(is_async), (KEY_ASYNC + ' must be bool!')

        package = req.get(KEY_PACKAGE)
        assert is_str(package), (KEY_PACKAGE + ' must be str!')

        clazz = req.get(KEY_CLASS)
        assert is_str(clazz), (KEY_CLASS + ' must be str!')

        method = req.get(KEY_METHOD)
        assert is_str(method), (KEY_METHOD + ' must be str!')
        assert not_empty(method), (KEY_CLASS + ' method be empty!')

        class_args = req.get(KEY_CLASS_ARGS)
        assert is_list(class_args), (KEY_CLASS_ARGS + ' must be list!')

        args = req.get(KEY_ARGS)
        assert is_list(args), (KEY_ARGS + ' must be list!')

        method_args = req.get(KEY_METHOD_ARGS)
        assert is_list(method_args), (KEY_METHOD_ARGS + ' must be list!')

        assert args is None or method_args is None, (KEY_ARGS + ', ' + KEY_METHOD_ARGS + ' cannot both be not null!')

        constructor = req.get(KEY_CONSTRUCTOR)
        assert is_str(constructor), (KEY_CONSTRUCTOR + ' must be str!')

        this = req.get(KEY_THIS)
        assert is_dict(this), (KEY_THIS + ' must be dict!')

        instance = None
        if this is not None:
            assert not static, KEY_STATIC + ' cannot appear together with ' + KEY_THIS + '!'
            assert class_args is None, KEY_THIS + ' cannot appear together with ' + KEY_CLASS_ARGS + '!'
            assert constructor is None, KEY_THIS + ' cannot appear together with ' + KEY_CONSTRUCTOR + '!'

            this_keys = [null]
            this_types = [null]
            this_values = [null]
            this_kwargs = {}
            init_args([this], this_keys, this_types, this_values, this_kwargs, import_fun=import_fun)
            instance = this_values[0]

        if class_args is not None:
            assert not static, KEY_CLASS_ARGS + ' cannot appear together with ' + KEY_STATIC + '!'
            assert this is None, KEY_CLASS_ARGS + ' cannot appear together with ' + KEY_THIS + '!'

        method_args = method_args or args
        mal = size(method_args)
        ma_keys = [null] * mal
        ma_types = [null] * mal
        ma_values = [null] * mal
        m_kwargs = {}

        final_result = {}

        def final_callback(*args, **kwargs):
            if not_none(callback):  # callable(callback):
                callback(wrap_result(
                    final_result.get(KEY_THIS), func, method_args, ma_types, ma_values,
                    final_result.get(KEY_VALUE), start_time, import_fun=import_fun
                ))

        is_wait = init_args(method_args, ma_keys, ma_types, ma_values, m_kwargs, true, final_callback, import_fun=import_fun)

        fl = split(clazz, '$')
        l = size(fl)

        mn = package if l <= 0 else package + '.' + fl[0]
        module = import_fun(mn, fromlist=['__init__'] if l <= 0 else fl[0])

        cls: any = null
        if l > 1:
            i = -1
            m = module
            for n in fl:
                i += 1
                if i <= 0:
                    continue
                # if i > 1:
                #     n = 'Test$InnerTest'  # 'Test.InnerTest'
                #     # 'Test' object has no attribute 'InnerTest'  #     m = m()
                m = getattr(m, n)  # FIXME Test.InnerTest raise Exception: type object 'Test' has no attribute 'InnerTest'

            cls = m
            # 'testutil' object has no attribute 'Test.InnerTest'  cls = getattr(module, '.'.join(fl[1:]))
            # 'testutil' object has no attribute 'Test.InnerTest'  cls = getattr(module, '$'.join(fl[1:]))

        if cls is None:
            func = getattr(module, method)
        elif static:
            func = getattr(cls, method)
        else:
            if instance is None:
                constructor_func = None if is_empty(constructor) else getattr(module, constructor)
                instance = getinstance(
                    cls, null, constructor_func, class_args, reuse=reuse, module=module, import_fun=import_fun
                )

            func = getattr(instance, method)

        final_result[KEY_THIS] = instance
        ksl = size(m_kwargs)
        start_time = cur_time_in_millis()

        result = func(*ma_values[:mal - ksl], **m_kwargs)  # asyncio.run 只允许调 async 函数 is_async != false

        # 自动识别 async 关键词
        is_async = is_async or (is_async is None and is_instance(result, (types.CoroutineType, types.AsyncGeneratorType)))
        if is_async:
            result = asyncio.run(result)

        final_result[KEY_VALUE] = result
        res = wrap_result(
            instance, func, method_args, ma_types, ma_values, result, start_time,
            json_dumps=json_dumps, json_loads=json_loads, import_fun=import_fun
        )
    except Exception as e:
        res = {
            KEY_LANGUAGE: LANGUAGE,
            KEY_OK: false,
            KEY_CODE: CODE_SERVER_ERROR,
            KEY_MSG: str(e),
            KEY_TIME_DETAIL: get_time_detail(start_time),
            KEY_THROW: e.__class__.__name__,
            # KEY_TRACE: e.__traceback__.__str__()
        }

    if (not is_wait) and callable(callback):
        callback(res)
    return res


def init_args(
    method_args: list, ma_keys: list, ma_types: list, ma_values: list,
    ma_kwargs: dict, keep_kwargs_in_types_and_values: bool = false,
    callback: callable = null, import_fun: callable = null
):
    is_wait = false
    mal = size(method_args)
    if mal > 0:
        i = -1
        for arg in method_args:
            i += 1
            value = null
            is_fun = false

            if is_str(arg) and (arg.__contains__(':') or arg.__contains__('=')):
                ind = index(arg, ':')
                eq_ind = index(arg, '=')
                key = (arg[:eq_ind] if ind < 0 else arg[ind+1:eq_ind]) if eq_ind >= 0 else null
                typ = arg[:ind] if ind >= 0 else null
                # ma_types.append(arg[:ind] if ind >= 0 else 'str')
                value = arg[eq_ind+1:] if eq_ind >= 0 else (arg[ind+1:] if ind >= 0 else arg)
                # ma_values.append(arg[ind + 1:] if ind >= 0 else arg)
            else:
                id = is_dict(arg)
                key = arg.get(KEY_KEY) if id else null
                typ = arg.get(KEY_TYPE) if id else null
                # ma_types.append(arg.get(KEY_TYPE) if id else type(arg))
                value = arg.get(KEY_VALUE) if id else arg
                # ma_values.append(arg.get(KEY_VALUE) if id else arg)

                start = index(typ, '(')
                end = last_index(typ, ')')
                if start >= 0 and end > start:  # 命名函数 或 lambda 匿名函数
                    assert is_dict(value, true), '{"type": "def(arg0,arg1...)", "value": value} 中 value 类型错误，' \
                        '必须为 dict！且格式必须为 {"type": returnType, "return": returnValue, "callback": bool}'
                    cb = value.get(KEY_CALLBACK)
                    assert is_bool(cb, false), '{"type": "def(arg0,arg1...)", "value": {"callback": bool}} 中' \
                        ' value/callback 类型错误，必须为 true 或 false ！'

                    is_fun = true
                    is_wait = is_wait or cb

                    fun = typ[:start] if start > 0 else null
                    # assert is_none(fun) or is_name(fun), '{"type": "fun(arg0,arg1...)"} 必须是函数名，或者关键词 def '
                    assert fun == 'def', '{"type": "fun(arg0,arg1...)"} 必须是函数名，或者关键词 def '

                    aks = split(typ[start+1:end])
                    akl = size(aks)
                    fa_types = [null] * akl
                    fa_keys = [null] * akl
                    for j in range(akl):
                        ak = aks[j]
                        ak_ind = index(ak, ':')
                        fa_types[j] = null if ak_ind < 0 else ak[:ak_ind]
                        fa_keys[j] = ak if ak_ind < 0 else ak[ak_ind+1:]

                    rtn_type = value.get(KEY_TYPE)
                    rtn_val = value.get(KEY_RETURN)

                    raw_val: dict = value

                    def cb_fun(*args, **kwargs):
                        mas: list = []
                        if not_empty(args):
                            for arg in args:
                                mas.append({
                                    KEY_TYPE: type(arg).__name__,
                                    KEY_VALUE: arg
                                })

                        if not_empty(kwargs):
                            for k in kwargs:
                                v = kwargs[k]
                                mas.append({
                                    KEY_KEY: k,
                                    KEY_TYPE: type(v).__name__,
                                    KEY_VALUE: v
                                })

                        call_list: list = raw_val.get(KEY_CALL_LIST) or []
                        call_list.append({
                            KEY_TIME: cur_time_in_millis(),
                            KEY_METHOD_ARGS: mas
                        })
                        raw_val[KEY_CALL_LIST] = call_list

                        if cb:
                            callback(*args, **kwargs)

                        rv = rtn_val
                        if is_str(rv, true):
                            try:
                                fn = '__unitauto_return_' + str(i) + '__'
                                to_eval = 'def ' + fn + '('
                                k = 0
                                first = true
                                for ak in fa_keys:
                                    if ak in kwargs:
                                        arg = kwargs.get(ak)
                                    else:
                                        arg = args[k]
                                        k += 1
                                    to_eval += ('' if first else ', ') + ak + '=' + str(arg)
                                    first = false
                                    # to_eval += ak + ' = ' + str(arg) + ';'
                                    # exec(ak + ' = ' + str(arg))
                                to_eval += '):\n    return ' + rv
                                exec(to_eval)
                                # to_eval += rv
                                nrv = eval(fn + '()')  # eval(rv)  # eval(to_eval)  # exec(to_eval)
                                return cast(nrv, get_class(rtn_type, nrv))
                            except Exception as e:
                                print(e)

                        return cast(rv, get_class(rtn_type, rv))

                    value = cb_fun  # eval('lambda ' + ', '.join(fa_keys) + ': ' + str(rtn_val))

            clazz = type(value) if is_fun else get_class(typ, value, import_fun)
            value = cast(value, clazz) if not is_fun else value

            ma_keys[i] = key
            if is_none(key):
                if is_empty(ma_kwargs):
                    ma_types[i] = clazz
                    ma_values[i] = value
                    continue
                raise Exception('所有已经有 key 的参数，必须后面也跟着有 key，对应调用 fun(key=value, key2=value2...) ！')

            assert key not in ma_kwargs, '调函数传参，所有 key 不允许重名！必须有唯一的不同名称！'
            ma_kwargs[key] = value

            if keep_kwargs_in_types_and_values:
                ma_types[i] = clazz
                ma_values[i] = value
            else:
                del ma_types[-1]
                del ma_values[-1]

    return is_wait


def cast(value, clazz, json_dumps: callable = null, json_loads: callable = null):
    if value is not None and not is_instance(value, clazz):
        json_dumps = json_dumps or json.dumps
        json_loads = json_loads or json.loads

        s = ''
        try:
            s = value if is_str(value) else json_dumps(value)
            if PRIMITIVE_CLASS_MAP.__contains__(clazz.__name__):
                value = eval(clazz.__name__ + '(' + s + ')')
            else:
                value = json_loads(s, cls=clazz)  # FIXME 目前仅支持继承 JSONDecoder 且重写了 decode 方法的类
        except Exception as e:
            print(e)
            if is_str(value):
                value = json_loads(value)

            if not is_instance(value, clazz):
                if is_list(value):
                    value = clazz(*value)
                elif is_dict(value):
                    value = clazz(**value)  # FIXME 目前仅支持继承 __init__ 传完整参数且顺序一致的类
                else:
                    pass

    return value


def get_class(typ: str, value: any = None, import_fun: callable = null) -> Type:
    fl = split(typ, '$')
    if is_empty(fl):
        return type(value)

    import_fun = import_fun or __import__

    path = typ
    clazz = CLASS_MAP.get(path)
    if clazz is None:
        fl = split(path, '$')
        pkg = fl[0]

        pl = split(pkg, '.')
        end = size(pl) - 1
        cn = null if end < 0 else pl[end]
        # pkg = pkg[:-len(cn)]

        l = size(fl)
        mn = fl[0]  # pkg if is_empty(fl) else pkg + '.' + cn
        module = import_fun(mn, fromlist=cn)
        if l <= 1:
            clazz = getattr(module, cn)
        else:
            j = -1
            for n in fl:
                j += 1
                if j <= 0:
                    continue
                clazz = getattr(module, n)

        CLASS_MAP[path] = clazz

    return clazz


def split(s: str, seperator: str = ',') -> list:
    if s is None:
        return null
    if is_contain(s, seperator):
        return s.split(seperator)
    return [s]


def is_contain(s: str, seperator: str = ',') -> bool:
    return false if is_empty(s) else seperator in s  # s.__contains__(seperator)


def is_bool(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, bool)


def is_int(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, int)


def is_float(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, float)


def is_str(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, str)


def is_list(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, list)


def is_dict(obj, strict: bool = false) -> bool:
    return (not strict) if obj is None else is_instance(obj, dict)


def not_none(obj):
    return not is_none(obj)


def is_none(obj):
    return obj is None


def not_empty(obj) -> bool:
    return not is_empty(obj)


def is_empty(obj) -> bool:
    if obj is None:
        return true
    if is_int(obj) or is_float(obj):
        return obj <= 0

    return size(obj) <= 0


def is_instance(obj, typ):
    if typ in [null, any, typing.Any]:  # fix isinstance() arg 2 must be a type or tuple of types
        return true
    return isinstance(obj, typ)


def is_name(s: str) -> bool:
    if is_empty(s) or PATTERN_NUMBER.match(s[:1]):
        return false
    return not_none(PATTERN_NAME.match(s))


def is_big_name(s: str) -> bool:
    if is_empty(s) or not PATTERN_UPPER_ALPHABET.match(s[:1]):
        return false
    return not_none(PATTERN_NAME.match(s))


def size(obj) -> int:
    if obj is None:
        return 0

    if is_bool(obj) or is_int(obj) or is_float(obj):
        raise Exception('obj cannot be any one of [bool, int, float]!')

    return len(obj)


def index(s: str, sub: str) -> int:
    try:
        return s.index(sub)
    except Exception:
        return -1


def last_index(s: str, sub: str) -> int:
    ws = split(s, sub)
    if size(ws) <= 1:
        return -1
    return size(s) - size(ws[-1]) - 1


def cur_time_in_millis() -> int:
    return round(time.time_ns()/MILLIS_TIME)


def get_time_detail(start_time: int, end_time: int = 0):
    if end_time is None or end_time <= 0:
        end_time = cur_time_in_millis()
    duration = end_time - start_time
    return str(round(start_time)) + '|' + str(round(duration)) + '|' + str(round(end_time))


def parse_json(s: str):
    return json.loads(s)


def to_json_str(obj, indent: int = 2) -> str:
    return json.dumps(obj, ensure_ascii=false, indent=indent)