coc_apiagent.py

# coc_apiagent_fixed.py - 修复版本，支持角色卡聊天系统
import uvicorn
from fastapi import FastAPI, HTTPException, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field
from typing import Dict, List, Optional, Any, Tuple
import uuid  # 用于生成 Session ID
import threading  # 线程安全
import json  # 用于SSE数据编码

# --- 导入 Agent 逻辑核心和状态模型 ---
from coc_agent import (
    CoCAgentLogic,
    SessionState,
    GameState,
    KeeperState,
    Investigator,
    Characteristics,
    InvestigatorSkills,
    PREGEN_CHARACTERS
)

# --- 导入角色卡聊天系统 ---
from character_card import CharacterCard
from chat_agent import ChatAgent, ChatState
from card_registry import registry as card_registry
from base_agent import BaseAgent, BaseChatState

# --- 导入职业数据和背景故事模型 ---
from occupation_data import (
    get_all_occupations,
    get_occupation_by_id,
    search_occupations,
    Occupation
)
from character_sheet import Background

# --- 导入统计日志模块 ---
from session_logger import logger, safe_log

# --- 导入会话持久化模块 ---
from session_persistence import SessionPersistence

# --- 导入统计分析模块 ---
from stats_analyzer import analyzer
from app_config import load_settings
from admin_security import is_admin_request_allowed
from session_contracts import investigator_to_dto, session_state_to_dto
from playable_keeper import (
    build_action_payload as build_playable_action_payload,
    handle_action as handle_playable_action,
    start_session_state as start_playable_session_state,
    text_chunks as playable_text_chunks,
)

# --- 1. 配置 ---
# 默认 API 配置现在在 base_agent.py 中统一管理
settings = load_settings()

# 存储用户自定义的API配置（全局）
user_api_config: Optional[Dict] = None

# --- 2. 初始化 ---
print("正在初始化 FastAPI 应用...")
app = FastAPI(
    title="CoC Agent API (无用户注册版)",
    description="提供 CoC Agent 游戏逻辑和状态管理的后端服务",
    version="1.2.0"  # 版本升级到1.2.0，支持自定义API
)

# 添加 CORS 中间件
app.add_middleware(
    CORSMiddleware,
    allow_origins=settings.cors_origins,
    allow_origin_regex=r"https://.*\.trycloudflare\.com" if settings.allow_public_tunnel_hosts else None,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

print("正在初始化 Agent 逻辑核心...")
try:
    # 如果有用户配置，使用用户配置；否则使用默认配置
    agent_logic = CoCAgentLogic(custom_config=user_api_config)
    print("[SUCCESS] Agent logic core loaded successfully!")
except Exception as e:
    print(f"[ERROR] Agent logic core loading failed: {e}")
    agent_logic = None

def reinitialize_agent():
    """重新初始化Agent（用于更新API配置后）"""
    global agent_logic
    try:
        agent_logic = CoCAgentLogic(custom_config=user_api_config)
        print(f"[SUCCESS] Agent重新初始化成功 (使用{'自定义' if user_api_config else '默认'}配置)")
        return True
    except Exception as e:
        print(f"[ERROR] Agent重新初始化失败: {e}")
        return False

# --- 3. 简化的会话管理（无需用户） ---
# 直接管理session_id -> SessionState
sessions: Dict[str, SessionState] = {}
# 线程安全锁
sessions_lock = threading.RLock()

# --- 会话持久化管理器 ---
persistence = SessionPersistence()

# --- 启动时自动加载上次的会话（如果存在）---
print("检查是否有之前的会话备份...")
try:
    loaded_sessions = persistence.import_sessions()
    if loaded_sessions:
        with sessions_lock:
            sessions.update(loaded_sessions)
        print(f"[OK] 已恢复 {len(loaded_sessions)} 个会话！玩家可以继续之前的游戏。")
except Exception as e:
    print(f"[!] 加载会话备份失败: {e}")
    print("   将从空白状态开始")

# --- 4. API 数据模型 ---
class StartSessionRequest(BaseModel):
    # 不需要user_id，直接开始游戏
    pass

class StartSessionResponse(BaseModel):
    session_id: str
    initial_response: Dict

class ActionRequest(BaseModel):
    session_id: str
    player_input: Optional[str] = None
    roll_result: Optional[int] = None
    # 移除user_id字段

class SaveGameRequest(BaseModel):
    session_id: str
    filename: str = "quicksave"

class ActionResponse(BaseModel):
    kp_response: Any  # 改为Any类型，支持字符串、字典等各种格式
    investigator: Optional[Dict] = None
    session_state: Optional[Dict] = None

class SimpleResponse(BaseModel):
    status: str
    message: Optional[str] = None

class ApiConfigRequest(BaseModel):
    api_key: str
    base_url: str
    model: str
    provider: Optional[str] = "Custom API"

class ApiConfigResponse(BaseModel):
    status: str
    message: str
    current_config: Optional[Dict] = None

# ========== 新增：车卡系统API模型 ==========

class CreateCustomCharacterRequest(BaseModel):
    """创建自定义角色请求"""
    session_id: str
    name: str
    age: int = Field(default=30, ge=15, le=90)
    sex: str = Field(default="未知")
    birthplace: Optional[str] = None
    residence: Optional[str] = None
    occupation_id: str
    characteristics: Dict[str, int]  # STR, CON, SIZ等

class AllocateSkillsRequest(BaseModel):
    """分配技能点请求"""
    session_id: str
    occupation_skills: Dict[str, int]  # {技能名: 分配点数}
    personal_skills: Dict[str, int]    # {技能名: 分配点数}

class UpdateBackgroundRequest(BaseModel):
    """更新背景故事请求"""
    session_id: str
    background: Dict[str, Any]  # Background模型的字典形式

class OccupationListResponse(BaseModel):
    """职业列表响应"""
    occupations: List[Dict]
    total: int

class CharacterCreationResponse(BaseModel):
    """角色创建响应"""
    status: str
    message: str
    investigator: Optional[Dict] = None

# --- 5. 会话辅助函数 ---
def create_session() -> str:
    """创建新的游戏会话"""
    session_id = str(uuid.uuid4())

    with sessions_lock:
        # 初始化游戏状态和会话状态
        initial_game_state = GameState()
        initial_kp_state = KeeperState()

        session_state = SessionState(
            session_id=session_id,
            game_state=initial_game_state,
            keeper_state=initial_kp_state
        )

        sessions[session_id] = session_state
        print(f"[API] 创建新会话: {session_id}")

    return session_id

def get_session(session_id: str) -> Optional[SessionState]:
    """获取会话"""
    with sessions_lock:
        return sessions.get(session_id)


def require_admin_access(request: Request):
    client_host = request.client.host if request.client else None
    if not is_admin_request_allowed(request.headers, client_host, settings):
        raise HTTPException(status_code=403, detail="Admin access denied")

# --- 6. API 路由 ---
@app.get("/health", response_model=SimpleResponse)
async def health_check():
    """健康检查"""
    return SimpleResponse(status="ok", message="服务正常运行")

@app.post("/api/start_session", response_model=StartSessionResponse)
@app.post("/start_session", response_model=StartSessionResponse)
async def start_session(request: StartSessionRequest):
    """开始新的游戏会话 - 无需用户登录"""
    session_id = str(uuid.uuid4())
    session_state, initial_response = start_playable_session_state(session_id)

    with sessions_lock:
        sessions[session_id] = session_state

    try:
        logger.log_session_start(session_id=session_id)
        logger.log_game_phase(session_id=session_id, phase="choose_investigator")
    except Exception as e:
        print(f"[!] [统计] 记录会话开始失败: {e}")

    return StartSessionResponse(session_id=session_id, initial_response=initial_response)

@app.post("/api/send_action", response_model=ActionResponse)
@app.post("/send_action", response_model=ActionResponse)
async def send_action(request: ActionRequest):
    """发送玩家行动 - 无需用户ID"""
    session_state = get_session(request.session_id)
    if not session_state:
        raise HTTPException(status_code=404, detail="会话不存在，请重新开始游戏")

    new_state, kp_response = handle_playable_action(
        session_state,
        player_input=request.player_input,
        roll_result=request.roll_result,
    )
    with sessions_lock:
        sessions[request.session_id] = new_state

    try:
        logger.log_session_state(session_id=request.session_id, session_state=new_state)
    except Exception as e:
        print(f"[!] [统计] 记录状态快照失败: {e}")

    return build_playable_action_payload(new_state, kp_response)

    # 【统计】记录玩家行动
    try:
        if request.player_input:
            logger.log_player_action(
                session_id=request.session_id,
                action_text=request.player_input,
                game_state={
                    'current_location': getattr(session_state.game_state, 'current_location', None),
                    'current_enemies': getattr(session_state.game_state, 'current_enemies', []),
                    'current_npcs': getattr(session_state.game_state, 'current_npcs', []),
                    'combat_turn': getattr(session_state.game_state, 'combat_turn', 0)
                }
            )
    except Exception as e:
        print(f"[!] [统计] 记录玩家行动失败: {e}")

    try:
        print(f"[DEBUG] 收到send_action请求: session_id={request.session_id}")
        print(f"[DEBUG] player_input: {request.player_input}, roll_result: {request.roll_result}")

        # 检查是否有roll_result需要处理
        if request.roll_result is not None:
            # 处理技能检定结果
            if session_state.pending_roll:
                print(f"[DEBUG] 处理技能检定: {session_state.pending_roll.skill_name}, 投骰: {request.roll_result}")
                outcome_str, outcome_level = agent_logic.resolve_skill_check(
                    investigator=session_state.investigator,
                    roll_result=request.roll_result,
                    skill_name=session_state.pending_roll.skill_name,
                    difficulty=session_state.pending_roll.difficulty,
                    session_id=request.session_id  # 传递session_id以启用日志记录
                )

                # 清除pending_roll
                session_state.pending_roll = None

                # 调用next_turn处理检定结果
                new_state, kp_response = agent_logic.next_turn(
                    current_state=session_state,
                    roll_outcome=outcome_str
                )

            # 处理SAN检定结果
            elif session_state.pending_san_check:
                print(f"[DEBUG] 处理SAN检定: 投骰: {request.roll_result}")
                outcome_str, san_loss, madness = agent_logic.resolve_sanity_check(
                    investigator=session_state.investigator,
                    roll_result=request.roll_result,
                    success_loss_str=session_state.pending_san_check.success_loss,
                    failure_loss_str=session_state.pending_san_check.failure_loss,
                    session_id=request.session_id  # 传递session_id以启用日志记录
                )

                # 更新SAN值
                session_state.investigator.current_sanity = max(0, session_state.investigator.current_sanity - san_loss)

                # 清除pending_san_check
                session_state.pending_san_check = None

                # 调用next_turn处理SAN检定结果
                new_state, kp_response = agent_logic.next_turn(
                    current_state=session_state,
                    san_check_outcome=outcome_str
                )
            else:
                print(f"[WARNING] 收到roll_result但没有pending_roll或pending_san_check")
                # 当作普通输入处理
                new_state, kp_response = agent_logic.process_action(
                    session_id=request.session_id,
                    player_input=request.player_input,
                    session_state=session_state
                )
        else:
            # 没有roll_result，正常处理玩家行动
            new_state, kp_response = agent_logic.process_action(
                session_id=request.session_id,
                player_input=request.player_input,
                session_state=session_state
            )

        # 更新会话状态
        with sessions_lock:
            sessions[request.session_id] = new_state

        # 【统计】记录状态快照
        try:
            logger.log_session_state(
                session_id=request.session_id,
                session_state=new_state
            )

            # 如果角色刚创建，记录角色选择
            if new_state.investigator and request.player_input:
                # 检测是否是角色选择的行动（如 "1,李明" 格式）
                if ',' in request.player_input:
                    character_data = {
                        'name': getattr(new_state.investigator, 'name', None),
                        'occupation': getattr(new_state.investigator, 'occupation', None),
                        'current_sanity': getattr(new_state.investigator, 'current_sanity', None) or getattr(new_state.investigator, 'current_san', None),
                        'hp': getattr(new_state.investigator, 'hp', None) or getattr(new_state.investigator, 'current_hp', None)
                    }
                    if character_data['name'] and character_data['occupation']:
                        logger.log_character_selected(request.session_id, character_data)
                        logger.log_game_phase(session_id=request.session_id, phase='in-room')

            # 检测场景切换
            old_location = getattr(session_state.game_state, 'current_location', None)
            new_location = getattr(new_state.game_state, 'current_location', None)
            if old_location and new_location and old_location != new_location:
                logger.log_location_change(request.session_id, old_location, new_location)
        except Exception as e:
            print(f"[!] [统计] 记录状态快照失败: {e}")

        # 构建完整的响应，包含 kp_response 和 investigator 数据
        response_data = {
            "kp_response": kp_response
        }

        # 添加更新后的调查员数据（如果有）
        if new_state.investigator:
            response_data["investigator"] = investigator_to_dto(new_state.investigator)
            response_data["session_state"] = session_state_to_dto(new_state)

        return response_data
    except Exception as e:
        print(f"[API] 处理行动失败: {e}")
        raise HTTPException(status_code=500, detail=f"处理行动失败: {str(e)}")

@app.post("/api/send_action_stream")
@app.post("/send_action_stream")
async def send_action_stream(request: ActionRequest):
    """发送玩家行动（流式版本）- 使用SSE流式返回AI响应"""
    session_state = get_session(request.session_id)
    if not session_state:
        raise HTTPException(status_code=404, detail="会话不存在，请重新开始游戏")

    new_state, kp_response = handle_playable_action(
        session_state,
        player_input=request.player_input,
        roll_result=request.roll_result,
    )
    with sessions_lock:
        sessions[request.session_id] = new_state

    async def generate_playable_sse():
        text = kp_response.get("text", "") if isinstance(kp_response, dict) else str(kp_response)
        for chunk in playable_text_chunks(text):
            yield f"data: {json.dumps({'type': 'chunk', 'data': chunk}, ensure_ascii=False)}\n\n"
        complete_data = {
            "type": "complete",
            **build_playable_action_payload(new_state, kp_response),
        }
        yield f"data: {json.dumps(complete_data, ensure_ascii=False)}\n\n"

    return StreamingResponse(
        generate_playable_sse(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no",
        },
    )

    # 【统计】记录玩家行动
    try:
        if request.player_input:
            logger.log_player_action(
                session_id=request.session_id,
                action_text=request.player_input,
                game_state={
                    'current_location': getattr(session_state.game_state, 'current_location', None),
                    'current_enemies': getattr(session_state.game_state, 'current_enemies', []),
                    'current_npcs': getattr(session_state.game_state, 'current_npcs', []),
                    'combat_turn': getattr(session_state.game_state, 'combat_turn', 0)
                }
            )
    except Exception as e:
        print(f"[!] [统计] 记录玩家行动失败: {e}")

    async def generate_sse():
        """SSE生成器"""
        try:
            print(f"[DEBUG_STREAM] 收到流式请求: session_id={request.session_id}")

            # 处理检定结果
            if request.roll_result is not None:
                if session_state.pending_roll:
                    outcome_str, outcome_level = agent_logic.resolve_skill_check(
                        investigator=session_state.investigator,
                        roll_result=request.roll_result,
                        skill_name=session_state.pending_roll.skill_name,
                        difficulty=session_state.pending_roll.difficulty,
                        session_id=request.session_id
                    )
                    session_state.pending_roll = None
                    generator = agent_logic.next_turn_stream(current_state=session_state, roll_outcome=outcome_str)
                elif session_state.pending_san_check:
                    outcome_str, san_loss, madness = agent_logic.resolve_sanity_check(
                        investigator=session_state.investigator,
                        roll_result=request.roll_result,
                        success_loss_str=session_state.pending_san_check.success_loss,
                        failure_loss_str=session_state.pending_san_check.failure_loss,
                        session_id=request.session_id
                    )
                    session_state.investigator.current_sanity = max(0, session_state.investigator.current_sanity - san_loss)
                    session_state.pending_san_check = None
                    generator = agent_logic.next_turn_stream(current_state=session_state, san_check_outcome=outcome_str)
                else:
                    generator = agent_logic.next_turn_stream(current_state=session_state, player_input=request.player_input)
            else:
                generator = agent_logic.next_turn_stream(current_state=session_state, player_input=request.player_input)

            # 逐步发送流式响应
            new_state = None
            final_response = None

            while True:
                try:
                    event = next(generator)
                except StopIteration as e:
                    if e.value is not None:
                        new_state, final_response_from_gen = e.value
                        if final_response is None:
                            final_response = final_response_from_gen
                    break

                event_type = event.get("type")
                event_data = event.get("data")

                if event_type == "chunk":
                    sse_data = json.dumps({"type": "chunk", "data": event_data}, ensure_ascii=False)
                    yield f"data: {sse_data}\n\n"
                elif event_type == "tool_call":
                    sse_data = json.dumps({"type": "tool_call", "data": event_data}, ensure_ascii=False)
                    yield f"data: {sse_data}\n\n"
                elif event_type == "complete":
                    final_response = event_data
                elif event_type == "error":
                    sse_data = json.dumps({"type": "error", "data": event_data}, ensure_ascii=False)
                    yield f"data: {sse_data}\n\n"
                    return

            # 更新会话状态
            if new_state:
                with sessions_lock:
                    sessions[request.session_id] = new_state

                try:
                    logger.log_session_state(session_id=request.session_id, session_state=new_state)
                    if new_state.investigator and request.player_input and ',' in request.player_input:
                        character_data = {
                            'name': getattr(new_state.investigator, 'name', None),
                            'occupation': getattr(new_state.investigator, 'occupation', None),
                            'current_sanity': getattr(new_state.investigator, 'current_sanity', None),
                            'hp': getattr(new_state.investigator, 'current_hp', None)
                        }
                        if character_data['name'] and character_data['occupation']:
                            logger.log_character_selected(request.session_id, character_data)
                            logger.log_game_phase(session_id=request.session_id, phase='in-room')
                except Exception as e:
                    print(f"[!] [统计] 记录失败: {e}")

            # 发送完成事件
            complete_data = {"type": "complete", "kp_response": final_response}
            if new_state and new_state.investigator:
                complete_data["investigator"] = investigator_to_dto(new_state.investigator)
                complete_data["session_state"] = session_state_to_dto(new_state)

            sse_data = json.dumps(complete_data, ensure_ascii=False)
            yield f"data: {sse_data}\n\n"

        except Exception as e:
            print(f"[API_STREAM] 流式处理失败: {e}")
            error_data = json.dumps({"type": "error", "data": str(e)}, ensure_ascii=False)
            yield f"data: {error_data}\n\n"

    return StreamingResponse(
        generate_sse(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no"
        }
    )

@app.get("/api/get_state/{session_id}")
@app.get("/get_state/{session_id}")
async def get_session_state(session_id: str):
    """获取游戏状态"""
    session_state = get_session(session_id)
    if not session_state:
        raise HTTPException(status_code=404, detail="会话不存在")

    return {
        "session_id": session_id,
        "game_state": session_state.game_state.__dict__,
        "keeper_state": session_state.keeper_state.__dict__,
        "investigator": investigator_to_dto(session_state.investigator),
        "session_state": session_state_to_dto(session_state)
    }

@app.post("/api/save_game")
@app.post("/save_game")
async def save_game(request: SaveGameRequest):
    """保存当前游戏会话快照。"""
    session_state = get_session(request.session_id)
    if not session_state:
        raise HTTPException(status_code=404, detail="会话不存在，请重新开始游戏")

    safe_name = "".join(ch for ch in request.filename if ch.isalnum() or ch in ("-", "_")) or "quicksave"
    if not safe_name.endswith(".pkl"):
        safe_name = f"{safe_name}.pkl"

    with sessions_lock:
        snapshot = dict(sessions)

    filepath = persistence.export_sessions(snapshot, safe_name)
    return {
        "status": "success",
        "message": "游戏已保存",
        "session_id": request.session_id,
        "filename": safe_name,
        "filepath": filepath,
    }

@app.post("/admin/export_sessions")
async def admin_export_sessions(request: Request):
    """管理员接口：导出所有会话到文件，用于服务器重启前备份"""
    require_admin_access(request)
    try:
        with sessions_lock:
            # 复制当前所有会话
            sessions_copy = dict(sessions)

        # 导出到文件
        filepath = persistence.export_sessions(sessions_copy)

        # 统计信息
        active_count = sum(1 for s in sessions_copy.values() if hasattr(s, 'investigator') and s.investigator)

        return {
            "status": "success",
            "message": "会话导出成功",
            "filepath": filepath,
            "total_sessions": len(sessions_copy),
            "sessions_with_characters": active_count
        }
    except Exception as e:
        print(f"[API] 导出会话失败: {e}")
        raise HTTPException(status_code=500, detail=f"导出失败: {str(e)}")

@app.get("/admin/sessions_summary")
async def admin_sessions_summary(request: Request):
    """管理员接口：获取当前会话摘要（增强版 + 排行榜）"""
    require_admin_access(request)
    try:
        with sessions_lock:
            total = len(sessions)
            with_characters = sum(1 for s in sessions.values() if hasattr(s, 'investigator') and s.investigator)

            # 统计角色职业偏好
            character_preferences = {}
            recent_players = []
            active_count = 0

            for session_id, session in sessions.items():
                if hasattr(session, 'investigator') and session.investigator:
                    investigator_dto = investigator_to_dto(session.investigator)
                    # 统计职业
                    occupation = investigator_dto.get('occupation', '未知')
                    character_preferences[occupation] = character_preferences.get(occupation, 0) + 1

                    # 收集玩家信息
                    player_info = {
                        'name': investigator_dto.get('name', '未命名'),
                        'occupation': occupation,
                        'san': investigator_dto.get('san', {}).get('current', 0),
                        'hp': investigator_dto.get('hp', {}).get('current', 0)
                    }
                    recent_players.append(player_info)
                    active_count += 1

            # 按最新的排序，只返回前10个
            recent_players = recent_players[-10:][::-1]

        # 从日志文件分析排行榜数据
        try:
            leaderboards = analyzer.analyze_leaderboards()
            overall_stats = analyzer.get_overall_stats()
        except Exception as e:
            print(f"[!] 分析排行榜数据失败: {e}")
            leaderboards = {
                'chatterbox': [],
                'daredevil': [],
                'lucky_player': [],
                'unlucky_player': []
            }
            overall_stats = {}

        return {
            "status": "ok",
            "total_sessions": total,
            "sessions_with_characters": with_characters,
            "active_sessions": active_count,
            "character_preferences": character_preferences,
            "recent_players": recent_players,
            "leaderboards": leaderboards,
            "overall_stats": overall_stats
        }
    except Exception as e:
        print(f"[API] 获取会话摘要失败: {e}")
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/set_api_config", response_model=ApiConfigResponse)
async def set_api_config(config: ApiConfigRequest):
    """设置用户自定义API配置"""
    global user_api_config

    try:
        # 验证配置
        if not config.api_key or not config.base_url or not config.model:
            raise HTTPException(status_code=400, detail="API配置不完整，请提供api_key、base_url和model")

        # 保存配置
        user_api_config = {
            'api_key': config.api_key,
            'base_url': config.base_url,
            'model': config.model,
            'provider': config.provider
        }

        # 重新初始化Agent
        if not reinitialize_agent():
            raise HTTPException(status_code=500, detail="API配置保存成功但初始化失败，请检查配置是否正确")

        print(f"[API] 用户API配置已更新: {config.provider} ({config.model})")

        return ApiConfigResponse(
            status="success",
            message=f"API配置已成功设置为 {config.provider}",
            current_config={
                'provider': config.provider,
                'model': config.model,
                'base_url': config.base_url,
            }
        )
    except HTTPException:
        raise
    except Exception as e:
        print(f"[API] 设置API配置失败: {e}")
        raise HTTPException(status_code=500, detail=f"设置API配置失败: {str(e)}")

@app.post("/test_api_config")
async def test_api_config(config: ApiConfigRequest):
    """测试API配置连接"""
    try:
        # 验证配置
        if not config.api_key or not config.base_url or not config.model:
            raise HTTPException(status_code=400, detail="API配置不完整")

        # 尝试创建临时客户端并测试连接
        import openai
        test_client = openai.OpenAI(
            api_key=config.api_key,
            base_url=config.base_url
        )

        # 发送测试请求
        test_response = test_client.chat.completions.create(
            model=config.model,
            messages=[{"role": "user", "content": "测试"}],
            max_tokens=10,
            timeout=10
        )

        print(f"[API] API配置测试成功: {config.provider} ({config.model})")

        return {
            "status": "success",
            "message": f"成功连接到 {config.provider}",
            "model": config.model
        }
    except Exception as e:
        print(f"[API] API配置测试失败: {e}")
        raise HTTPException(
            status_code=400,
            detail=f"连接测试失败: {str(e)}"
        )

@app.get("/api_config_status")
async def get_api_config_status():
    """获取当前API配置状态"""
    if user_api_config:
        return {
            "status": "custom",
            "message": "使用自定义API配置",
            "config": {
                'provider': user_api_config.get('provider'),
                'model': user_api_config.get('model'),
                'base_url': user_api_config.get('base_url'),
            }
        }
    else:
        # 返回默认配置信息
        default_llm = load_settings().selected_llm()
        default_config = {
            'provider': default_llm.provider,
            'model': default_llm.model,
        }

        return {
            "status": "default",
            "message": "使用默认API配置",
            "config": default_config
        }


# ========== 新增：车卡系统API端点 ==========

@app.get("/api/occupations", response_model=OccupationListResponse)
async def get_occupations(search: Optional[str] = None):
    """
    获取职业列表

    Args:
        search: 可选，搜索关键词（支持中英文名称和描述搜索）
    """
    try:
        if search:
            occupations = search_occupations(search)
        else:
            occupations = get_all_occupations()

        # 转换为字典格式
        occupations_dict = [occ.model_dump() for occ in occupations]

        return OccupationListResponse(
            occupations=occupations_dict,
            total=len(occupations_dict)
        )
    except Exception as e:
        print(f"[API] 获取职业列表失败: {e}")
        raise HTTPException(status_code=500, detail=f"获取职业列表失败: {str(e)}")


@app.get("/api/occupations/{occupation_id}")
async def get_occupation(occupation_id: str):
    """
    获取指定职业的详细信息

    Args:
        occupation_id: 职业ID
    """
    try:
        occupation = get_occupation_by_id(occupation_id)
        if not occupation:
            raise HTTPException(status_code=404, detail=f"职业 '{occupation_id}' 不存在")

        return occupation.model_dump()
    except HTTPException:
        raise
    except Exception as e:
        print(f"[API] 获取职业详情失败: {e}")
        raise HTTPException(status_code=500, detail=f"获取职业详情失败: {str(e)}")


@app.post("/api/character/create_custom", response_model=CharacterCreationResponse)
async def create_custom_character(request: CreateCustomCharacterRequest):
    """
    创建自定义角色

    这是车卡流程的第一步，创建基础角色信息
    """
    try:
        # 获取会话，如果不存在则创建
        session_state = get_session(request.session_id)
        if not session_state:
            # 为车卡系统创建临时会话
            print(f"[API] 车卡系统：创建临时会话 {request.session_id}")
            with sessions_lock:
                initial_game_state = GameState()
                initial_kp_state = KeeperState()
                session_state = SessionState(
                    session_id=request.session_id,
                    game_state=initial_game_state,
                    keeper_state=initial_kp_state
                )
                sessions[request.session_id] = session_state

        # 获取职业信息
        occupation = get_occupation_by_id(request.occupation_id)
        if not occupation:
            raise HTTPException(status_code=404, detail=f"职业 '{request.occupation_id}' 不存在")

        # 创建Characteristics对象
        char = Characteristics(**request.characteristics)

        # 创建Investigator对象
        investigator = Investigator(
            name=request.name,
            occupation=occupation.name,
            age=request.age,
            sex=request.sex,
            birthplace=request.birthplace,
            residence=request.residence,
            occupation_id=request.occupation_id,
            characteristics=char
        )

        # 保存到会话状态
        with sessions_lock:
            session_state.investigator = investigator
            session_state.game_state.current_phase = "character_creation"

        print(f"[API] 创建自定义角色成功: {request.name} ({occupation.name})")

        return CharacterCreationResponse(
            status="success",
            message=f"角色 '{request.name}' 创建成功",
            investigator=investigator_to_dto(investigator)
        )

    except HTTPException:
        raise
    except Exception as e:
        print(f"[API] 创建自定义角色失败: {e}")
        raise HTTPException(status_code=500, detail=f"创建角色失败: {str(e)}")


@app.put("/api/character/allocate_skills", response_model=CharacterCreationResponse)
async def allocate_skills(request: AllocateSkillsRequest):
    """
    分配技能点

    车卡流程的技能分配步骤
    """
    try:
        # 获取会话
        session_state = get_session(request.session_id)
        if not session_state:
            raise HTTPException(status_code=404, detail="会话不存在")

        # 检查是否已创建角色
        if not session_state.investigator:
            raise HTTPException(status_code=400, detail="请先创建角色")

        investigator = session_state.investigator

        # 应用技能点分配
        success = investigator.apply_skill_allocation(
            request.occupation_skills,
            request.personal_skills
        )

        if not success:
            raise HTTPException(status_code=400, detail="技能点分配失败，请检查点数是否超限")

        # 更新会话
        with sessions_lock:
            session_state.investigator = investigator

        print(f"[API] 技能分配成功: {investigator.name}")

        return CharacterCreationResponse(
            status="success",
            message="技能点分配成功",
            investigator=investigator_to_dto(investigator)
        )

    except HTTPException:
        raise
    except Exception as e:
        print(f"[API] 技能分配失败: {e}")
        raise HTTPException(status_code=500, detail=f"技能分配失败: {str(e)}")


@app.put("/api/character/update_background", response_model=CharacterCreationResponse)
async def update_background(request: UpdateBackgroundRequest):
    """
    更新角色背景故事

    车卡流程的背景故事编辑步骤
    """
    try:
        # 获取会话
        session_state = get_session(request.session_id)
        if not session_state:
            raise HTTPException(status_code=404, detail="会话不存在")

        # 检查是否已创建角色
        if not session_state.investigator:
            raise HTTPException(status_code=400, detail="请先创建角色")

        investigator = session_state.investigator

        # 创建Background对象
        background = Background(**request.background)

        # 设置背景故事
        investigator.set_background(background)

        # 更新会话
        with sessions_lock:
            session_state.investigator = investigator
            session_state.game_state.current_phase = "ready"  # 标记为准备完成

        print(f"[API] 背景故事更新成功: {investigator.name}")

        return CharacterCreationResponse(
            status="success",
            message="背景故事更新成功，角色创建完成！",
            investigator=investigator_to_dto(investigator)
        )

    except HTTPException:
        raise
    except Exception as e:
        print(f"[API] 更新背景故事失败: {e}")
        raise HTTPException(status_code=500, detail=f"更新背景故事失败: {str(e)}")


# ============================================================
# 通用角色聊天 API（新增，与 CoC 端点并存）
# ============================================================

# --- 聊天会话存储 ---
chat_sessions: Dict[str, Tuple[BaseAgent, BaseChatState]] = {}
chat_sessions_lock = threading.RLock()

# --- 聊天 API 数据模型 ---
class ChatStartRequest(BaseModel):
    card_id: str
    user_name: Optional[str] = "用户"

class ChatStartResponse(BaseModel):
    session_id: str
    character: Dict
    greeting: str
    expression: str = "default"

class ChatSendRequest(BaseModel):
    session_id: str
    message: str

class CharacterListResponse(BaseModel):
    characters: List[Dict]
    total: int
    tags: List[str]


# --- 角色卡列表 ---
@app.get("/api/characters")
async def list_characters(tag: Optional[str] = None, mode: Optional[str] = None):
    """获取角色卡列表（画廊用）"""
    cards = card_registry.list_cards(tag_filter=tag, mode_filter=mode)
    return CharacterListResponse(
        characters=[c.model_dump() for c in cards],
        total=len(cards),
        tags=card_registry.get_all_tags()
    )


@app.get("/api/characters/{card_id}")
async def get_character(card_id: str):
    """获取单个角色卡详情"""
    card = card_registry.get_card(card_id)
    if not card:
        raise HTTPException(status_code=404, detail=f"角色卡不存在: {card_id}")
    return card.model_dump()


# --- 开始聊天会话 ---
@app.post("/api/chat/start")
async def start_chat(request: ChatStartRequest):
    """开始一个角色聊天会话"""
    card = card_registry.get_card(request.card_id)
    if not card:
        raise HTTPException(status_code=404, detail=f"角色卡不存在: {request.card_id}")

    session_id = str(uuid.uuid4())

    # 根据模式创建对应的 Agent
    if card.mode == "trpg":
        # TRPG 模式：返回提示让前端跳转到 CoC 游戏
        return ChatStartResponse(
            session_id="",
            character=card.model_dump(),
            greeting="",
            expression="default"
        )

    # 聊天模式：创建 ChatAgent
    try:
        agent = ChatAgent(
            character_card=card,
            custom_config=user_api_config,
            skip_warmup=True  # 主 Agent 已预热过
        )
        state = agent.create_initial_state(session_id)

        with chat_sessions_lock:
            chat_sessions[session_id] = (agent, state)

        print(f"[ChatAPI] 新聊天会话: {session_id} | 角色: {card.name}")

        return ChatStartResponse(
            session_id=session_id,
            character=card.model_dump(),
            greeting=card.greeting,
            expression="default"
        )
    except Exception as e:
        print(f"[ChatAPI] 创建聊天会话失败: {e}")
        raise HTTPException(status_code=500, detail=f"创建会话失败: {str(e)}")


# --- 发送消息（流式） ---
@app.post("/api/chat/send_stream")
async def chat_send_stream(request: ChatSendRequest):
    """发送聊天消息（SSE 流式响应）"""
    session_id = request.session_id

    with chat_sessions_lock:
        session_data = chat_sessions.get(session_id)

    if not session_data:
        raise HTTPException(status_code=404, detail="会话不存在或已过期")

    agent, state = session_data

    async def generate_sse():
        try:
            final_state = None
            for event in agent.process_message_stream(state, request.message):
                event_type = event.get("type", "")

                if event_type == "chunk":
                    yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n"

                elif event_type == "complete":
                    final_state = event.get("state", state)
                    # 更新会话状态
                    with chat_sessions_lock:
                        chat_sessions[session_id] = (agent, final_state)

                    complete_data = {
                        "type": "complete",
                        "kp_response": event.get("kp_response", {}),
                        "expression": event.get("expression", "default")
                    }
                    yield f"data: {json.dumps(complete_data, ensure_ascii=False)}\n\n"

                elif event_type == "error":
                    yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n"

        except Exception as e:
            print(f"[ChatAPI] SSE 错误: {e}")
            error_data = {"type": "error", "data": f"流式传输错误: {str(e)}"}
            yield f"data: {json.dumps(error_data, ensure_ascii=False)}\n\n"

    return StreamingResponse(
        generate_sse(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no"
        }
    )


# --- 发送消息（非流式） ---
@app.post("/api/chat/send")
async def chat_send(request: ChatSendRequest):
    """发送聊天消息（非流式响应）"""
    session_id = request.session_id

    with chat_sessions_lock:
        session_data = chat_sessions.get(session_id)

    if not session_data:
        raise HTTPException(status_code=404, detail="会话不存在或已过期")

    agent, state = session_data

    try:
        new_state, response = agent.process_message(state, request.message)

        with chat_sessions_lock:
            chat_sessions[session_id] = (agent, new_state)

        return {
            "reply": response.get("text", ""),
            "expression": response.get("expression", "default"),
            "speaker": response.get("speaker", "")
        }
    except Exception as e:
        print(f"[ChatAPI] 发送消息失败: {e}")
        raise HTTPException(status_code=500, detail=f"发送消息失败: {str(e)}")


# --- 获取聊天状态 ---
@app.get("/api/chat/state/{session_id}")
async def get_chat_state(session_id: str):
    """获取聊天会话状态"""
    with chat_sessions_lock:
        session_data = chat_sessions.get(session_id)

    if not session_data:
        raise HTTPException(status_code=404, detail="会话不存在")

    agent, state = session_data

    return {
        "session_id": state.session_id,
        "character": state.character_card.model_dump() if state.character_card else None,
        "current_expression": state.current_expression,
        "mood": state.mood,
        "message_count": len(state.messages)
    }


# --- 重新加载角色卡 ---
@app.post("/api/characters/reload")
async def reload_characters():
    """重新加载角色卡（开发用）"""
    card_registry.reload()
    return {"status": "success", "count": card_registry.count}


if __name__ == "__main__":
    print("启动 CoC Agent API 服务器 (无用户注册版)...")
    print("无需用户注册，直接开始游戏！")
    print(f"已加载 {card_registry.count} 张角色卡")
    print("访问 http://127.0.0.1:8001/docs 查看 API 文档")
    uvicorn.run(app, host="0.0.0.0", port=8001)