AIChatRoom/backend/routers/discussions.py

"""
讨论结果路由
"""
from typing import List, Optional, Dict, Any
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel

from models.discussion_result import DiscussionResult


router = APIRouter()


# ============ 响应模型 ============

class DiscussionResponse(BaseModel):
    """讨论结果响应"""
    discussion_id: str
    room_id: str
    objective: str
    consensus_reached: bool
    confidence: float
    summary: str
    action_items: List[str]
    unresolved_issues: List[str]
    key_decisions: List[str]
    total_rounds: int
    total_messages: int
    participating_agents: List[str]
    agent_contributions: Dict[str, int]
    status: str
    end_reason: str
    created_at: str
    completed_at: Optional[str]


class DiscussionListResponse(BaseModel):
    """讨论列表响应"""
    discussions: List[DiscussionResponse]
    total: int


# ============ 路由处理 ============

@router.get("", response_model=DiscussionListResponse)
async def list_discussions(
    room_id: Optional[str] = None,
    limit: int = 20,
    skip: int = 0
):
    """
    获取讨论结果列表
    """
    query = {}
    if room_id:
        query["room_id"] = room_id
    
    discussions = await DiscussionResult.find(query).sort(
        "-created_at"
    ).skip(skip).limit(limit).to_list()
    
    total = await DiscussionResult.find(query).count()
    
    return DiscussionListResponse(
        discussions=[_to_response(d) for d in discussions],
        total=total
    )


@router.get("/{discussion_id}", response_model=DiscussionResponse)
async def get_discussion(discussion_id: str):
    """
    获取指定讨论结果
    """
    discussion = await DiscussionResult.find_one(
        DiscussionResult.discussion_id == discussion_id
    )
    
    if not discussion:
        raise HTTPException(status_code=404, detail="讨论记录不存在")
    
    return _to_response(discussion)


@router.get("/room/{room_id}", response_model=List[DiscussionResponse])
async def get_room_discussions(room_id: str, limit: int = 10):
    """
    获取聊天室的讨论历史
    """
    discussions = await DiscussionResult.find(
        {"room_id": room_id}
    ).sort("-created_at").limit(limit).to_list()
    
    return [_to_response(d) for d in discussions]


@router.get("/room/{room_id}/latest", response_model=DiscussionResponse)
async def get_latest_discussion(room_id: str):
    """
    获取聊天室最新的讨论结果
    """
    discussion = await DiscussionResult.find(
        {"room_id": room_id}
    ).sort("-created_at").first_or_none()
    
    if not discussion:
        raise HTTPException(status_code=404, detail="没有找到讨论记录")
    
    return _to_response(discussion)


# ============ 辅助函数 ============

def _to_response(discussion: DiscussionResult) -> DiscussionResponse:
    """
    转换为响应模型
    """
    return DiscussionResponse(
        discussion_id=discussion.discussion_id,
        room_id=discussion.room_id,
        objective=discussion.objective,
        consensus_reached=discussion.consensus_reached,
        confidence=discussion.confidence,
        summary=discussion.summary,
        action_items=discussion.action_items,
        unresolved_issues=discussion.unresolved_issues,
        key_decisions=discussion.key_decisions,
        total_rounds=discussion.total_rounds,
        total_messages=discussion.total_messages,
        participating_agents=discussion.participating_agents,
        agent_contributions=discussion.agent_contributions,
        status=discussion.status,
        end_reason=discussion.end_reason,
        created_at=discussion.created_at.isoformat(),
        completed_at=discussion.completed_at.isoformat() if discussion.completed_at else None
    )