"""Redis-based message deduplication service"""
import redis.asyncio as redis
from typing import Optional
from app.core.logging import get_logger

logger = get_logger(__name__)


class RedisMessageDeduplicator:
    """Redis-backed message deduplicator for production"""
    
    def __init__(self, redis_client: redis.Redis, ttl: int = 300):
        self.redis = redis_client
        self.ttl = ttl
        self.prefix = "dedup:"
    
    async def is_duplicate(self, message_id: str) -> bool:
        """Check if message was already processed"""
        key = f"{self.prefix}{message_id}"
        
        try:
            exists = await self.redis.exists(key)
            
            if exists:
                logger.debug(f"Duplicate message detected: {message_id}")
                return True
            
            # Mark as processed with TTL
            await self.redis.setex(key, self.ttl, "1")
            return False
            
        except Exception as e:
            logger.error(f"Redis error in deduplicator: {e}")
            # Fail open - allow message through on Redis error
            return False
    
    async def mark_processed(self, message_id: str) -> None:
        """Explicitly mark message as processed"""
        key = f"{self.prefix}{message_id}"
        try:
            await self.redis.setex(key, self.ttl, "1")
        except Exception as e:
            logger.error(f"Redis error marking processed: {e}")
    
    async def clear(self) -> None:
        """Clear all processed messages"""
        try:
            cursor = 0
            pattern = f"{self.prefix}*"
            while True:
                cursor, keys = await self.redis.scan(cursor, match=pattern, count=100)
                if keys:
                    await self.redis.delete(*keys)
                if cursor == 0:
                    break
            logger.info("Redis deduplicator cleared")
        except Exception as e:
            logger.error(f"Redis error clearing: {e}")