import json
import logging
import redis
import psycopg2
from psycopg2.extras import RealDictCursor


# Настраиваем логирование для отслеживания проблем с кэшем
logger = logging.getLogger(__name__)


class CacheService:
    def __init__(self):
        # В реальном приложении параметры передаются через конфигурацию/env
        self.redis_client = redis.Redis(
            host='redis.example.com',
            port=6379,
            decode_responses=True,
            socket_timeout=0.5,          # Быстрый отрыв, если Redis занят
            socket_connect_timeout=1.0
        )
        self.db_conn = psycopg2.connect(
            host='postgres.example.com',
            database='appdb',
            user='appuser',
            password='password'
        )
    
    def get_user_data(self, user_id):
        cache_key = f"user:{user_id}"
        
        # 1. Проверяем Redis с обработкой ошибок (Graceful Degradation)
        try:
            cached_data = self.redis_client.get(cache_key)
            if cached_data:
                return json.loads(cached_data)
        except redis.RedisError as e:
            logger.error(f"Redis error on get: {e}. Falling back to DB.")
        
        # 2. Cache miss или отказ Redis - идём в базу данных
        # RealDictCursor автоматически собирает строки в удобные dict
        with self.db_conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute(
                "SELECT id, name, email, last_login FROM users WHERE id = %s",
                (user_id,)
            )
            row = cur.fetchone()
            if not row:
                return None
            
            data = dict(row)
            if data.get('last_login'):
                data['last_login'] = data['last_login'].isoformat()
        
        # 3. Пытаемся сохранить данные в Redis с TTL 1 час
        try:
            self.redis_client.setex(cache_key, 3600, json.dumps(data))
        except redis.RedisError as e:
            logger.error(f"Failed to write to Redis: {e}")
            
        return data

    def get_top_products(self, category, limit=10):
        cache_key = f"top:products:{category}"
        
        try:
            cached = self.redis_client.get(cache_key)
            if cached:
                return json.loads(cached)
        except redis.RedisError as e:
            logger.error(f"Redis error on get top products: {e}")
        
        # Тяжелый SQL-запрос с сортировкой и агрегацией
        with self.db_conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute("""
                SELECT id, name, sales_count, rating
                FROM products
                WHERE category = %s AND active = true
                ORDER BY sales_count DESC, rating DESC
                LIMIT %s
            """, (category, limit))
            products = [dict(row) for row in cur.fetchall()]
        
        # Кэшируем результат на 10 минут
        try:
            self.redis_client.setex(cache_key, 600, json.dumps(products))
        except redis.RedisError as e:
            logger.error(f"Failed to cache top products: {e}")
            
        return products

    def update_product(self, product_id, data):
        # 1. Обновляем основную базу данных
        with self.db_conn.cursor() as cur:
            cur.execute(
                "UPDATE products SET name = %s, price = %s WHERE id = %s",
                (data['name'], data['price'], product_id)
            )
            self.db_conn.commit()
        
        # 2. Сбрасываем устаревший кэш (Инвалидация)
        try:
            self.redis_client.delete(f"product:{product_id}")
            self.redis_client.delete(f"top:products:{data['category']}")
        except redis.RedisError as e:
            # Логируем, чтобы не блокировать выполнение основной бизнес-логики
            logger.error(f"Cache invalidation failed: {e}. Cache might be stale.")