import asyncio
from config import settings
from services.audio_session import audio_session_manager
from utils.logger import session_logger
from services.conversation_history import conversation_history_manager

async def run_in_executor(func, *args):
    loop = asyncio.get_running_loop()
    return await loop.run_in_executor(None, func, *args)

async def background_cleanup_task():
    try:
        while True:
            await asyncio.sleep(settings.cleanup_interval)
            
            current_time = asyncio.get_running_loop().time()
            audio_sessions_to_clean = []
            
            sessions = await audio_session_manager.get_all_sessions()
            for session_key, session in sessions:
                device_id, session_id = session_key
                if current_time - session.last_activity_time > settings.session_timeout:
                    audio_sessions_to_clean.append(session_key)
                    session_logger.info(
                        device_id, 
                        "cleanup", 
                        f"清理过期的音频会话, 超时: {settings.session_timeout}秒"
                    )
            
            for session_key in audio_sessions_to_clean:
                await audio_session_manager.remove_session(session_key)
            
            role_histories_to_clean = []
            
            for (device_id, role_key), history in conversation_history_manager.role_histories.items():
                if current_time - history.last_interaction_time > settings.conversation_history_timeout:
                    role_histories_to_clean.append((device_id, role_key))
                    session_logger.info(
                        device_id, 
                        "cleanup", 
                        f"发现过期的对话历史缓存: {role_key}, 超时: {settings.conversation_history_timeout}秒"
                    )
            
            for device_id, role_key in role_histories_to_clean:
                cache_key = (device_id, role_key)
                if cache_key in conversation_history_manager.role_histories:
                    del conversation_history_manager.role_histories[cache_key]
                    session_logger.info(
                        device_id, 
                        "cleanup", 
                        f"已从内存中清理对话历史: {role_key}"
                    )
                    
    except asyncio.CancelledError:
        session_logger.info("system", "cleanup", "后台清理任务已取消")
    except Exception as e:
        session_logger.error("system", "cleanup", f"后台清理任务出错: {str(e)}")