import logging
import os
from redis import BlockingConnectionPool, DataError, StrictRedis


logger = logging.getLogger("redis_db")


class NoRedisClient(StrictRedis):
    """
    Null object for Redis Client class.
    """

    @classmethod
    def from_url(cls, *args, **kwargs):
        return cls()

    def __init__(self, logger):
        logger.warning("There are some issues with Redis connection. Cache will be disabled.")
        self.connection_pool = None
        self.response_callbacks = {}

    def pipeline(self, transaction=True, shard_hint=None):
        return NoRedisPipeline(self.connection_pool, self.response_callbacks)

    def delete(self, *args, **kwargs):
        return

    def flushall(self, *args, **kwargs):
        return

    def get(self, *args, **kwargs):
        return

    def mget(self, keys, *args):
        if isinstance(keys, list):
            keys_len = len(keys)
        elif isinstance(keys, str) or isinstance(keys, bytes):
            keys_len = len(args) + 1
        else:
            raise DataError(f"{self.__class__.__name__} unsupported cache key {keys}.")
        return [None] * keys_len

    def setex(self, *args, **kwargs):
        return

    def expire(self, *args, **kwargs):
        return

    def scan_iter(self, match=None, count=None, _type=None):
        return []


class NoRedisPipeline(NoRedisClient):
    """
    Null object for Redis Pipeline class.
    """

    def __init__(self, connection_pool=None, response_callbacks=None):
        self.connection_pool = connection_pool
        self.connection = None
        self.response_callbacks = response_callbacks
        self.transaction = True
        self.shard_hint = None
        self.watching = False

    def __enter__(self):
        return self

    def __exit__(self, *args, **kwargs):
        pass

    def __del__(self):
        pass

    def __len__(self):
        return 0

    def execute(self):
        return []

    def reset(self):
        return


connection_pool = None


def init_redis():
    host = os.environ.get("REDIS_HOST")
    port = os.environ.get("REDIS_PORT", "6379")
    pool_size = int(os.environ.get("REDIS_CONNECTION_POOL_SIZE", 30))

    if not host:
        client = NoRedisClient(logger)
        logger.error("Redis HOST was not provided")
        return client

    global connection_pool
    if not connection_pool:
        connection_pool = BlockingConnectionPool(host=host, port=port, max_connections=pool_size)

    try:
        client = StrictRedis(connection_pool=connection_pool)
        client.ping()
    except Exception as err:
        client = NoRedisClient(logger)
        logger.error(f"Redis connection error: {err}")

    return client


redis_client = init_redis()