import redis
import json
import logging
from typing import Any, Optional
from datetime import timedelta
import os
from dotenv import load_dotenv
from utils.logging_utils import log_to_file

load_dotenv()

class CacheManager:
    def __init__(self):
        """Initialise la connexion Redis"""
        self.redis_client = redis.Redis(
            host=os.getenv("REDIS_HOST"),
            port=int(os.getenv("REDIS_PORT")),
            username=os.getenv("REDIS_USERNAME"),  # Ajout du nom d'utilisateur pour l'instance render
            password=os.getenv("REDIS_PASSWORD"),  # Ajout du mot de passe pour l'instance render
            decode_responses=True  # Pour automatiquement décoder les réponses en str
        )
        self.default_expiry = timedelta(hours=1)  # Expiration par défaut : 1 heure

    async def get(self, key: str) -> Optional[Any]:
        """Récupère une valeur du cache"""
        try:
            value = self.redis_client.get(key)
            if value:
                log_to_file(f"Cache hit pour la clé: {key}", level=logging.INFO)
                return json.loads(value)
            log_to_file(f"Cache miss pour la clé: {key}", level=logging.INFO)
            return None
        except Exception as e:
            log_to_file(f"Erreur lors de la lecture du cache: {str(e)}", level=logging.ERROR)
            return None

    async def set(self, key: str, value: Any, expiry: Optional[timedelta] = None) -> bool:
        """Enregistre une valeur dans le cache"""
        try:
            expiry_seconds = int((expiry or self.default_expiry).total_seconds())
            success = self.redis_client.setex(
                key,
                expiry_seconds,
                json.dumps(value)
            )
            if success:
                log_to_file(f"Valeur mise en cache pour la clé: {key}", level=logging.INFO)
            return success
        except Exception as e:
            log_to_file(f"Erreur lors de l'écriture dans le cache: {str(e)}", level=logging.ERROR)
            return False

    async def delete(self, key: str) -> bool:
        """Supprime une valeur du cache"""
        try:
            return bool(self.redis_client.delete(key))
        except Exception as e:
            log_to_file(f"Erreur lors de la suppression du cache: {str(e)}", level=logging.ERROR)
            return False

    async def clear_all(self) -> bool:
        """Vide tout le cache"""
        try:
            self.redis_client.flushall()
            log_to_file("Cache entièrement vidé", level=logging.INFO)
            return True
        except Exception as e:
            log_to_file(f"Erreur lors du vidage du cache: {str(e)}", level=logging.ERROR)
            return False