import asyncio
import hashlib
import json
import redis.asyncio as redis
from ..core import get_settings

settings = get_settings()


class CacheService:
    def __init__(self):
        self.redis: redis.Redis | None = None

    async def connect(self):
        try:
            self.redis = redis.from_url(settings.redis_url)
            await self.redis.ping()
        except Exception:
            self.redis = None

    async def disconnect(self):
        if self.redis:
            await self.redis.close()

    def _make_key(
        self,
        source_text: str,
        source_lang: str,
        target_lang: str,
        style: str,
        glossary_version: str | None = None,
        model_version: str | None = None,
    ) -> str:
        normalized = source_text.strip().lower()
        content = f"{normalized}:{source_lang}:{target_lang}:{style}"
        if glossary_version:
            content += f":{glossary_version}"
        if model_version:
            content += f":{model_version}"
        hash_val = hashlib.sha256(content.encode()).hexdigest()[:16]
        return f"tr:{hash_val}"

    async def get(self, key: str) -> dict | None:
        if not self.redis:
            return None
        try:
            data = await self.redis.get(key)
        except asyncio.CancelledError:
            return None
        except Exception:
            return None
        if data:
            return json.loads(data)
        return None

    async def set(self, key: str, value: dict, ttl: int | None = None):
        if not self.redis:
            return
        ttl = ttl or settings.cache_ttl_seconds
        try:
            await self.redis.set(key, json.dumps(value), ex=ttl)
        except asyncio.CancelledError:
            return
        except Exception:
            return


cache_service = CacheService()