import logging
import django_redis

logger = logging.getLogger(__file__)


class TaskQueue:
    Redis = django_redis.get_redis_connection()

    LEVEL_MAP = {
        1: "common",
        2: "priority",
        3: "cam",
        7: "cron",
        8: "gitv",
        9: "gdyd",
        10: "nmgt",
        11: "qshi",
        20: "batdel",
        21: "batupt"
    }
    Task_Key = "task_{}"
    Count_Key = "count_{}"

    # 获取hash的key
    @classmethod
    def get_key(cls, level):
        key = cls.Task_Key.format(cls.LEVEL_MAP[int(level)])
        return key

    @classmethod
    def get_count_key(cls, level):
        key = cls.Count_Key.format(cls.LEVEL_MAP[int(level)])
        return key

    # 获取task任务队列
    @classmethod
    def get_queue(cls, level):
        key = cls.get_key(level)
        queue = cls.Redis.hgetall(key)
        return {int(task_id): int(status) for task_id, status in queue.items()}

    @classmethod
    def get_cron_queue(cls, level=7):
        key = cls.get_key(level)
        queue = cls.Redis.hgetall(key)
        return {int(task_id): str(cron_datetime, encoding="utf-8") for task_id, cron_datetime in queue.items()}

    # 添加队列中的task任务
    @classmethod
    def add(cls, level, task_id, value):
        key = cls.get_key(level)
        res = cls.Redis.hsetnx(key, task_id, value)
        res_str = "成功" if res == 1 else "失败"
        logger.warning(f"增加redis_task队列 {res_str}: {key} 优先级: {level} task_id: {task_id} 值: {value}")
        return res

    # 根据level和field批量更新队列中的task任务
    @classmethod
    def update(cls, level, task_id, value):
        key = cls.get_key(level)
        res = cls.Redis.hset(key, task_id, value)
        logger.warning(f"更新redis_task队列: {key} 优先级: {level} task_id: {task_id} 值: {value}")
        return res

    @classmethod
    def update_cron_task(cls, level, task_id, value):
        if level == 7:
            level = 3
        key = cls.get_key(level)
        res = cls.Redis.hset(key, task_id, value)
        logger.warning(f"更新redis_task队列: {key} 优先级: {level} task_id: {task_id} 值: {value}")
        return res

    # 根据key和field删除队列中的task任务
    @classmethod
    def delete(cls, level, task_id):
        key = cls.get_key(level)
        cls.Redis.hdel(key, task_id)
        logger.warning(f"删除redis_task队列{key} task_id: {task_id}")
        return

    # 判断队列中field是否存在

    @classmethod
    def has_field(cls, level, task_id):
        key = cls.get_key(level)
        return cls.Redis.hexists(key, task_id)

    @classmethod
    def set_count_nx(cls, level):
        key = cls.get_count_key(level)
        return cls.Redis.setnx(key, 0)

    @classmethod
    def get_count(cls, level):
        key = cls.get_count_key(level)
        return cls.Redis.get(key)

    @classmethod
    def add_1(cls, level):
        key = cls.get_count_key(level)
        return cls.Redis.incr(key)

    @classmethod
    def sub_1(cls, level):
        key = cls.get_count_key(level)
        return cls.Redis.decr(key)


class TaskCacheHash:
    Redis = django_redis.get_redis_connection()
    Key = "cache_hash_{}_{}"
    Key_2 = "cache_hash_{}_{}_{}"

    @classmethod
    def get_key(cls, partner_id, media_id, salt=None):
        if salt:
            return cls.Key_2.format(partner_id, media_id, salt)
        return cls.Key.format(partner_id, media_id)

    @classmethod
    def add(cls, partner_id, media_id, video_id, status, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hsetnx(key, video_id, status)
        return res

    @classmethod
    def update(cls, partner_id, media_id, video_id, status, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hset(key, video_id, status)
        return res

    @classmethod
    def has_key(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.exists(key)
        return res

    @classmethod
    def get_size(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hlen(key)
        return res

    @classmethod
    def get_fields(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hkeys(key)
        return res

    @classmethod
    def get_values(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hvals(key)
        return res

    @classmethod
    def get_all(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hgetall(key)
        return res

    @classmethod
    def delete(cls, partner_id, media_id, video_list, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.hdel(key, *video_list)
        return res

    @classmethod
    def del_key(cls, partner_id, media_id, salt=None):
        key = cls.get_key(partner_id, media_id, salt)
        res = cls.Redis.delete(key)
        return res


class TaskCacheList:
    Redis = django_redis.get_redis_connection()
    Key = "cache_list_{}_{}"
    Key_2 = "cache2_list_{}_{}"

    @classmethod
    def get_key(cls, partner_id, media_id):
        return cls.Key.format(partner_id, media_id)

    @classmethod
    def add(cls, partner_id, media_id, video_id):
        key = cls.get_key(partner_id, media_id)
        res = cls.Redis.rpush(key, video_id)
        return res

    @classmethod
    def get_list(cls, partner_id, media_id, video_id):
        key = cls.get_key(partner_id, media_id)
        res = cls.Redis.lrange(key, video_id)
        return res

    @classmethod
    def has_key(cls, partner_id, media_id):
        key = cls.get_key(partner_id, media_id)
        res = cls.Redis.exists(key)
        return res

    @classmethod
    def delete(cls, partner_id, media_id, video_id):
        key = cls.get_key(partner_id, media_id)
        res = cls.Redis.lrem(key, 0, video_id)
        return res


class TaskCDNLOCK:
    Redis = django_redis.get_redis_connection()
    Key = "task_cdn_{}"
    expire = 60 * 60 * 24

    @classmethod
    def add_lock(cls, task_id, val):
        key = cls.Key.format(task_id)
        res = cls.Redis.set(key, val, nx=True, ex=cls.expire)
        return res

    @classmethod
    def delete_lock(cls, task_id):
        key = cls.Key.format(task_id)
        res = cls.Redis.delete(key)
        return res

    @classmethod
    def get_value(cls, task_id):
        key = cls.Key.format(task_id)
        res = cls.Redis.get(key)
        return res