import asyncio
from datetime import datetime
from ...application.use_cases.cleanup_old_data import CleanupOldDataUseCase
from ...infrastructure.repositories.mongodb_search_repository import MongoDBSearchRepository
from ...core.database import get_database
from ...core.config import settings
import logging

logger = logging.getLogger(__name__)

class CleanupScheduler:
    def __init__(self):
        self.cleanup_use_case = None
        self.task = None
        self.is_running = False
    
    async def start(self):
        """Start the cleanup scheduler"""
        if not settings.ENABLE_PERIODIC_CLEANUP:
            logger.info("Periodic cleanup is disabled")
            return
        
        try:
            database = await get_database()
            search_repository = MongoDBSearchRepository(database)
            self.cleanup_use_case = CleanupOldDataUseCase(search_repository)
            
            self.is_running = True
            self.task = asyncio.create_task(self._run_cleanup_loop())
            
            logger.info("Cleanup scheduler started")
            
        except Exception as e:
            logger.error(f"Error starting cleanup scheduler: {e}")
            raise
    
    async def stop(self):
        """Stop the cleanup scheduler"""
        try:
            self.is_running = False
            
            if self.task:
                self.task.cancel()
                try:
                    await self.task
                except asyncio.CancelledError:
                    pass
            
            logger.info("Cleanup scheduler stopped")
            
        except Exception as e:
            logger.error(f"Error stopping cleanup scheduler: {e}")
    
    async def _run_cleanup_loop(self):
        """Run the cleanup loop"""
        while self.is_running:
            try:
                await self._perform_cleanup()
                await asyncio.sleep(settings.CLEANUP_INTERVAL)
                
            except asyncio.CancelledError:
                break
            except Exception as e:
                logger.error(f"Error in cleanup loop: {e}")
                await asyncio.sleep(60)  # Wait 1 minute before retrying
    
    async def _perform_cleanup(self):
        """Perform the actual cleanup"""
        try:
            logger.info("Starting periodic cleanup")
            
            # Clean up old requests
            result = await self.cleanup_use_case.cleanup_old_requests()
            
            # Clean up cache
            await self.cleanup_use_case.cleanup_cache()
            
            logger.info(f"Periodic cleanup completed: {result}")
            
        except Exception as e:
            logger.error(f"Error during periodic cleanup: {e}")

cleanup_scheduler = CleanupScheduler()