import json
import logging
from typing import Any, Optional, List

from app.client.redis_client_manager import redis_client_manager

logger = logging.getLogger(__name__)


class RedisUtils:
    @staticmethod
    async def get(key: str) -> Optional[str]:
        try:
            return await redis_client_manager.client.get(key)
        except Exception as e:
            logger.error(f"Redis get error: {e}")
            return None

    @staticmethod
    async def set(key: str, value: str, expire_seconds: Optional[int] = None) -> bool:
        try:
            if expire_seconds:
                await redis_client_manager.client.set(key, value, ex=expire_seconds)
            else:
                await redis_client_manager.client.set(key, value)
            return True
        except Exception as e:
            logger.error(f"Redis set error: {e}")
            return False

    @staticmethod
    async def delete(key: str) -> bool:
        try:
            await redis_client_manager.client.delete(key)
            return True
        except Exception as e:
            logger.error(f"Redis delete error: {e}")
            return False

    @staticmethod
    async def exists(key: str) -> bool:
        try:
            return await redis_client_manager.client.exists(key) > 0
        except Exception as e:
            logger.error(f"Redis exists error: {e}")
            return False

    @staticmethod
    async def expire(key: str, seconds: int) -> bool:
        try:
            return await redis_client_manager.client.expire(key, seconds)
        except Exception as e:
            logger.error(f"Redis expire error: {e}")
            return False

    @staticmethod
    async def get_json(key: str) -> Optional[Any]:
        try:
            value = await redis_client_manager.client.get(key)
            if value:
                return json.loads(value)
            return None
        except json.JSONDecodeError:
            logger.error(f"Redis get_json error: Invalid JSON")
            return None
        except Exception as e:
            logger.error(f"Redis get_json error: {e}")
            return None

    @staticmethod
    async def set_json(key: str, value: Any, expire_seconds: Optional[int] = None) -> bool:
        try:
            json_str = json.dumps(value, ensure_ascii=False)
            return await RedisUtils.set(key, json_str, expire_seconds)
        except Exception as e:
            logger.error(f"Redis set_json error: {e}")
            return False

    @staticmethod
    async def hget(key: str, field: str) -> Optional[str]:
        try:
            return await redis_client_manager.client.hget(key, field)
        except Exception as e:
            logger.error(f"Redis hget error: {e}")
            return None

    @staticmethod
    async def hset(key: str, field: str, value: str) -> bool:
        try:
            await redis_client_manager.client.hset(key, field, value)
            return True
        except Exception as e:
            logger.error(f"Redis hset error: {e}")
            return False

    @staticmethod
    async def hgetall(key: str) -> Optional[dict]:
        try:
            return await redis_client_manager.client.hgetall(key)
        except Exception as e:
            logger.error(f"Redis hgetall error: {e}")
            return None

    @staticmethod
    async def hdel(key: str, field: str) -> bool:
        try:
            await redis_client_manager.client.hdel(key, field)
            return True
        except Exception as e:
            logger.error(f"Redis hdel error: {e}")
            return False

    @staticmethod
    async def lpush(key: str, *values: Any) -> int:
        try:
            return await redis_client_manager.client.lpush(key, *values)
        except Exception as e:
            logger.error(f"Redis lpush error: {e}")
            return 0

    @staticmethod
    async def rpush(key: str, *values: Any) -> int:
        try:
            return await redis_client_manager.client.rpush(key, *values)
        except Exception as e:
            logger.error(f"Redis rpush error: {e}")
            return 0

    @staticmethod
    async def lpop(key: str) -> Optional[str]:
        try:
            return await redis_client_manager.client.lpop(key)
        except Exception as e:
            logger.error(f"Redis lpop error: {e}")
            return None

    @staticmethod
    async def rpop(key: str) -> Optional[str]:
        try:
            return await redis_client_manager.client.rpop(key)
        except Exception as e:
            logger.error(f"Redis rpop error: {e}")
            return None

    @staticmethod
    async def llen(key: str) -> int:
        try:
            return await redis_client_manager.client.llen(key)
        except Exception as e:
            logger.error(f"Redis llen error: {e}")
            return 0

    @staticmethod
    async def lrange(key: str, start: int, end: int) -> List[str]:
        try:
            return await redis_client_manager.client.lrange(key, start, end)
        except Exception as e:
            logger.error(f"Redis lrange error: {e}")
            return []

    @staticmethod
    async def incr(key: str) -> int:
        try:
            return await redis_client_manager.client.incr(key)
        except Exception as e:
            logger.error(f"Redis incr error: {e}")
            return 0

    @staticmethod
    async def decr(key: str) -> int:
        try:
            return await redis_client_manager.client.decr(key)
        except Exception as e:
            logger.error(f"Redis decr error: {e}")
            return 0

    @staticmethod
    async def sadd(key: str, *members: Any) -> int:
        try:
            return await redis_client_manager.client.sadd(key, *members)
        except Exception as e:
            logger.error(f"Redis sadd error: {e}")
            return 0

    @staticmethod
    async def smembers(key: str) -> List[str]:
        try:
            return await redis_client_manager.client.smembers(key)
        except Exception as e:
            logger.error(f"Redis smembers error: {e}")
            return []

    @staticmethod
    async def srem(key: str, *members: Any) -> int:
        try:
            return await redis_client_manager.client.srem(key, *members)
        except Exception as e:
            logger.error(f"Redis srem error: {e}")
            return 0

    @staticmethod
    async def zadd(key: str, mapping: dict) -> int:
        try:
            return await redis_client_manager.client.zadd(key, mapping)
        except Exception as e:
            logger.error(f"Redis zadd error: {e}")
            return 0

    @staticmethod
    async def zrange(key: str, start: int, end: int, withscores: bool = False) -> List[str]:
        try:
            return await redis_client_manager.client.zrange(key, start, end, withscores=withscores)
        except Exception as e:
            logger.error(f"Redis zrange error: {e}")
            return []

    @staticmethod
    async def keys(pattern: str) -> List[str]:
        try:
            return await redis_client_manager.client.keys(pattern)
        except Exception as e:
            logger.error(f"Redis keys error: {e}")
            return []

    @staticmethod
    async def flush_db() -> bool:
        try:
            await redis_client_manager.client.flushdb()
            return True
        except Exception as e:
            logger.error(f"Redis flush_db error: {e}")
            return False


class RedisSyncUtils:
    @staticmethod
    def get(key: str) -> Optional[str]:
        try:
            return redis_client_manager.sync_client.get(key)
        except Exception as e:
            logger.error(f"Redis sync get error: {e}")
            return None

    @staticmethod
    def set(key: str, value: str, expire_seconds: Optional[int] = None) -> bool:
        try:
            if expire_seconds:
                redis_client_manager.sync_client.set(key, value, ex=expire_seconds)
            else:
                redis_client_manager.sync_client.set(key, value)
            return True
        except Exception as e:
            logger.error(f"Redis sync set error: {e}")
            return False

    @staticmethod
    def delete(key: str) -> bool:
        try:
            redis_client_manager.sync_client.delete(key)
            return True
        except Exception as e:
            logger.error(f"Redis sync delete error: {e}")
            return False

    @staticmethod
    def get_json(key: str) -> Optional[Any]:
        try:
            value = redis_client_manager.sync_client.get(key)
            if value:
                return json.loads(value)
            return None
        except Exception as e:
            logger.error(f"Redis sync get_json error: {e}")
            return None

    @staticmethod
    def set_json(key: str, value: Any, expire_seconds: Optional[int] = None) -> bool:
        try:
            json_str = json.dumps(value, ensure_ascii=False)
            return RedisSyncUtils.set(key, json_str, expire_seconds)
        except Exception as e:
            logger.error(f"Redis sync set_json error: {e}")
            return False