import redis

# Fornece mecanismos de Caching e Persistência Volátil/PubSub na aplicação usando Redis
class RedisClient:
    def __init__(self, host='localhost', port=6379, db=0):
        """
        Inicializa o cliente Redis com as configurações fornecidas.
        """
        self.client = redis.Redis(host=host, port=port, db=db, decode_responses=True)

    def set(self, key, value):
        """
        Define um valor para uma chave no Redis.
        """
        self.client.set(key, value)
    
    def setex(self, key, value, ex):
        """
        Define um valor para uma chave no Redis com um tempo de expiração em segundos.
        """
        self.client.set(key, value, ex)

    def get(self, key):
        """
        Obtém o valor de uma chave no Redis.
        """
        return self.client.get(key)
    
    def get_keys(self, pattern="*"):
        """
        Obtém todas as chaves que correspondem a um padrão.
        """
        return self.client.keys(pattern)
    
    def get_all(self):
        """
        Obtém todas as chaves e seus valores no Redis.
        """
        keys = self.client.keys('*')
        return {key: self.client.get(key) for key in keys}

    def delete(self, key):
        """
        Remove uma chave do Redis.
        """
        self.client.delete(key)

    def exists(self, key):
        """
        Verifica se uma chave existe no Redis.
        Retorna True se a chave existir, caso contrário, False.
        """
        return self.client.exists(key) > 0

    def close(self):
        """
        Fecha a conexão com o Redis.
        """
        self.client.close()
        
    def set_expiration(self, key, value, seconds):
        """
        Define um valor para uma chave e configura um tempo de expiração em segundos.
        """
        self.client.set(key, value, ex=seconds)

    def increment(self, key, amount=1):
        """
        Incrementa o valor de uma chave numérica no Redis.
        """
        return self.client.incr(key, amount)

    def decrement(self, key, amount=1):
        """
        Decrementa o valor de uma chave numérica no Redis.
        """
        return self.client.decr(key, amount)

    def hset(self, name, key, value):
        """
        Define um campo em um hash no Redis.
        """
        self.client.hset(name, key, value)

    def hget(self, name, key):
        """
        Obtém o valor de um campo em um hash no Redis.
        """
        return self.client.hget(name, key)

    def hgetall(self, name):
        """
        Obtém todos os campos e valores de um hash no Redis.
        """
        return self.client.hgetall(name)

    def expire(self, key, seconds):
        """
        Define um tempo de expiração para uma chave existente.
        """
        self.client.expire(key, seconds)

    def ttl(self, key):
        """
        Obtém o tempo restante de vida (TTL) de uma chave.
        """
        return self.client.ttl(key)