"""
日志
"""
import queue
import sys
import time

from loguru import logger
import constant
from utils import tool


class MyLogger:
    def __init__(self):
        logger.remove()

        # 显示在控制台
        # logger.add(sys.stdout,
        #           filter=lambda record: record["extra"].get("name") == "l2_trade", enqueue=True)

        logger.add(self.get_path("first_code", "first_code_record"),
                   filter=lambda record: record["extra"].get("name") == "first_code_record",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("debug", "debug"),
                   filter=lambda record: record["extra"].get("name") == "debug",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("kpl", "kpl_limit_up_reason_change"),
                   filter=lambda record: record["extra"].get("name") == "kpl_limit_up_reason_change",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("kpl", "kpl_limit_up"),
                   filter=lambda record: record["extra"].get("name") == "kpl_limit_up",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("kpl", "kpl_debug"),
                   filter=lambda record: record["extra"].get("name") == "kpl_debug",
                   rotation="00:00", compression="zip", enqueue=True)

        # 看盘日志
        logger.add(self.get_path("kp", "kp_msg"),
                   filter=lambda record: record["extra"].get("name") == "kp_msg",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("redis", "redis_debug"),
                   filter=lambda record: record["extra"].get("name") == "redis_debug",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("profile", "profile"),
                   filter=lambda record: record["extra"].get("name") == "profile",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("request", "request_debug"),
                   filter=lambda record: record["extra"].get("name") == "request_debug",
                   rotation="00:00", compression="zip", enqueue=True)

        logger.add(self.get_path("request", "tuoguan_request_debug"),
                   filter=lambda record: record["extra"].get("name") == "tuoguan_request_debug",
                   rotation="00:00", compression="zip", enqueue=True)

    def get_path(self, dir_name, log_name):
        path_str = "{}/logs/gp/{}/{}".format(constant.get_path_prefix(), dir_name, log_name) + ".{time:YYYY-MM-DD}.log"
        # print(path_str)
        return path_str

    def get_logger(self, log_name):
        return logger.bind(name=log_name)


__mylogger = MyLogger()

logger_first_code_record = __mylogger.get_logger("first_code_record")

logger_debug = __mylogger.get_logger("debug")

logger_kpl_limit_up_reason_change = __mylogger.get_logger("kpl_limit_up_reason_change")

logger_kpl_limit_up = __mylogger.get_logger("kpl_limit_up")

logger_kpl_debug = __mylogger.get_logger("kpl_debug")

logger_kp_msg = __mylogger.get_logger("kp_msg")

logger_redis_debug = __mylogger.get_logger("redis_debug")

logger_profile = __mylogger.get_logger("profile")

logger_request_debug = __mylogger.get_logger("request_debug")

logger_tuoguan_request_debug = __mylogger.get_logger("tuoguan_request_debug")




class AsyncLogManager:
    __log_queue = queue.Queue()

    def __add_log(self, logger, method, *args):
        self.__log_queue.put_nowait((logger, time.time(), method, args))

    def debug(self, logger, *args):
        self.__add_log(logger, "debug", *args)

    def info(self, logger, *args):
        self.__add_log(logger, "info", *args)

    def warning(self, logger, *args):
        self.__add_log(logger, "warning", *args)

    def error(self, logger, *args):
        self.__add_log(logger, "error", *args)

    def exception(self, logger, *args):
        self.__add_log(logger, "exception", *args)

    # 运行同步日志
    def run_sync(self):
        while True:
            try:
                val = self.__log_queue.get()
                time_s = val[1]
                cmd = val[2]
                method = getattr(val[0], cmd)
                d = list(val[3])
                d[0] = f"[{tool.to_time_str(int(time_s))}.{str(time_s).split('.')[1][:3]}] " + d[0]
                d = tuple(d)
                method(*d)
            except:
                pass


async_log_util = AsyncLogManager()


def request_info(type_name, content, thread_id=None):
    if not thread_id:
        thread_id = tool.get_thread_id()
    async_log_util.info(logger_request_debug, f"【{thread_id}】【{type_name}】 {content}")