from typing import List, Optional, Dict, Any
from datetime import datetime, timedelta
from ..entities.search_request import SearchRequest, SearchTask, SearchStatus
from ..repositories.search_repository import SearchRepository
from ...infrastructure.cache.redis_cache import redis_cache
import logging

logger = logging.getLogger(__name__)

class SearchService:
    def __init__(self, search_repository: SearchRepository):
        self.search_repository = search_repository
    
    async def get_search_request_with_cache(self, request_id: str) -> Optional[SearchRequest]:
        """Get search request with caching"""
        cache_key = f"search_request:{request_id}"
        
        # Try to get from cache first
        cached_data = await redis_cache.get(cache_key)
        if cached_data:
            logger.debug(f"Retrieved search request from cache: {request_id}")
            return SearchRequest(**cached_data)
        
        # If not in cache, get from database
        search_request = await self.search_repository.get_search_request(request_id)
        if search_request:
            # Cache for 5 minutes
            await redis_cache.set(cache_key, search_request.dict(), ttl=300)
            logger.debug(f"Cached search request: {request_id}")
        
        return search_request
    
    async def update_search_request_with_cache(self, search_request: SearchRequest) -> SearchRequest:
        """Update search request and invalidate cache"""
        updated_request = await self.search_repository.update_search_request(search_request)
        
        # Invalidate cache
        cache_key = f"search_request:{search_request.id}"
        await redis_cache.delete(cache_key)
        
        return updated_request
    
    async def get_search_statistics(self, user_id: Optional[str] = None) -> Dict[str, Any]:
        """Get search statistics with caching"""
        cache_key = f"search_stats:{user_id or 'global'}"
        
        # Try to get from cache
        cached_stats = await redis_cache.get(cache_key)
        if cached_stats:
            return cached_stats
        
        # Calculate statistics
        stats = await self._calculate_search_statistics(user_id)
        
        # Cache for 10 minutes
        await redis_cache.set(cache_key, stats, ttl=600)
        
        return stats
    
    async def _calculate_search_statistics(self, user_id: Optional[str] = None) -> Dict[str, Any]:
        """Calculate search statistics from database"""
        # This would involve complex queries to get statistics
        # For now, returning mock data
        return {
            "total_requests": 0,
            "pending_requests": 0,
            "completed_requests": 0,
            "failed_requests": 0,
            "average_completion_time": 0,
            "popular_keywords": [],
            "platform_usage": {}
        }
    
    async def increment_search_counter(self, platform: str):
        """Increment search counter for platform"""
        counter_key = f"search_counter:{platform}:{datetime.utcnow().strftime('%Y-%m-%d')}"
        await redis_cache.increment(counter_key)
        
        # Set expiry for the counter (7 days)
        if not await redis_cache.exists(f"{counter_key}_ttl"):
            await redis_cache.set(f"{counter_key}_ttl", "1", ttl=604800)  # 7 days