import time
from typing import Dict, List, Optional
from services.conversation_history import conversation_history_manager
from services.role_manager import role_manager

class HistoryService:
    async def get_history_paginated(
        self, 
        device_id: str, 
        role_key: Optional[str] = None,
        page: int = 1,
        page_size: int = 20,
        since: Optional[float] = None,
        until: Optional[float] = None
    ) -> Dict:
        """分页获取会话历史"""
        device_history = await conversation_history_manager.get_history(device_id, role_key)
        if not device_history or not device_history.history:
            return {
                "total": 0,
                "page": page,
                "page_size": page_size,
                "data": [],
                "role_key": role_key or "",
                "role_name": "未知角色"
            }
        
        role_info = await role_manager.get_role(device_history.role_key) if device_history.role_key else None
        role_name = role_info.get("name", "未知角色") if role_info else "未知角色"
        
        filtered_history = device_history.history
        if since:
            filtered_history = [msg for msg in filtered_history if 
                                msg.get("timestamp", 0) >= since]
        if until:
            filtered_history = [msg for msg in filtered_history if 
                                msg.get("timestamp", 0) <= until]
            
        total_messages = len(filtered_history)
        
        start_idx = (page - 1) * page_size
        end_idx = start_idx + page_size
        paged_messages = filtered_history[start_idx:end_idx]
        
        current_time = time.time()
        for i, msg in enumerate(paged_messages):
            if "timestamp" not in msg:
                paged_messages[i]["timestamp"] = current_time - (total_messages - i) * 60
        
        return {
            "total": total_messages,
            "page": page,
            "page_size": page_size,
            "data": paged_messages,
            "role_key": device_history.role_key or "",
            "role_name": role_name
        }
    
    async def get_history_summary(self, device_id: str, days: int = 7) -> List[Dict]:
        """获取会话历史摘要"""
        role_histories = await conversation_history_manager.get_device_role_histories(device_id)
        if not role_histories:
            return []
        
        summaries = []
        cutoff_time = time.time() - (days * 24 * 60 * 60)
        
        for role_key, history in role_histories.items():
            if history.last_interaction_time < cutoff_time:
                continue
                
            role_info = await role_manager.get_role(role_key)
            role_name = role_info.get("name", "未知角色") if role_info else "未知角色"
            
            last_message = ""
            if history.history:
                last_message = history.history[-1].get("assistant", "")[:100]
            
            summaries.append({
                "role_key": role_key,
                "role_name": role_name,
                "last_interaction": history.last_interaction_time,
                "message_count": len(history.history),
                "last_message": last_message
            })
        
        summaries.sort(key=lambda x: x["last_interaction"], reverse=True)
        return summaries

history_service = HistoryService()