MuMuAINovel/backend/app/api/careers.py

"""职业管理API"""
from fastapi import APIRouter, Depends, HTTPException, Request
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, func, and_
import json
from typing import AsyncGenerator

from app.database import get_db
from app.utils.sse_response import SSEResponse, create_sse_response, WizardProgressTracker
from app.models.career import Career, CharacterCareer
from app.models.character import Character
from app.models.project import Project
from app.schemas.career import (
    CareerCreate,
    CareerUpdate,
    CareerResponse,
    CareerListResponse,
    CareerGenerateRequest,
    CharacterCareerResponse,
    CharacterCareerDetail,
    SetMainCareerRequest,
    AddSubCareerRequest,
    UpdateCareerStageRequest,
    CareerStage
)
from app.services.ai_service import AIService
from app.logger import get_logger
from app.api.settings import get_user_ai_service
from app.api.common import verify_project_access

router = APIRouter(prefix="/careers", tags=["职业管理"])
logger = get_logger(__name__)


@router.get("", response_model=CareerListResponse, summary="获取职业列表")
async def get_careers(
    project_id: str,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """获取指定项目的所有职业"""
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(project_id, user_id, db)
    
    # 获取总数
    count_result = await db.execute(
        select(func.count(Career.id)).where(Career.project_id == project_id)
    )
    total = count_result.scalar_one()
    
    # 获取职业列表
    result = await db.execute(
        select(Career)
        .where(Career.project_id == project_id)
        .order_by(Career.type, Career.created_at.desc())
    )
    careers = result.scalars().all()
    
    # 分类返回
    main_careers = []
    sub_careers = []
    
    for career in careers:
        # 解析JSON字段
        stages = json.loads(career.stages) if career.stages else []
        attribute_bonuses = json.loads(career.attribute_bonuses) if career.attribute_bonuses else None
        
        career_dict = {
            "id": career.id,
            "project_id": career.project_id,
            "name": career.name,
            "type": career.type,
            "description": career.description,
            "category": career.category,
            "stages": stages,
            "max_stage": career.max_stage,
            "requirements": career.requirements,
            "special_abilities": career.special_abilities,
            "worldview_rules": career.worldview_rules,
            "attribute_bonuses": attribute_bonuses,
            "source": career.source,
            "created_at": career.created_at,
            "updated_at": career.updated_at
        }
        
        if career.type == "main":
            main_careers.append(career_dict)
        else:
            sub_careers.append(career_dict)
    
    return CareerListResponse(
        total=total,
        main_careers=main_careers,
        sub_careers=sub_careers
    )


@router.post("", response_model=CareerResponse, summary="创建职业")
async def create_career(
    career_data: CareerCreate,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """手动创建职业"""
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(career_data.project_id, user_id, db)
    
    try:
        # 转换stages为JSON字符串
        stages_json = json.dumps([stage.model_dump() for stage in career_data.stages], ensure_ascii=False)
        attribute_bonuses_json = json.dumps(career_data.attribute_bonuses, ensure_ascii=False) if career_data.attribute_bonuses else None
        
        # 创建职业
        career = Career(
            project_id=career_data.project_id,
            name=career_data.name,
            type=career_data.type,
            description=career_data.description,
            category=career_data.category,
            stages=stages_json,
            max_stage=career_data.max_stage,
            requirements=career_data.requirements,
            special_abilities=career_data.special_abilities,
            worldview_rules=career_data.worldview_rules,
            attribute_bonuses=attribute_bonuses_json,
            source=career_data.source
        )
        db.add(career)
        await db.commit()
        await db.refresh(career)
        
        logger.info(f"✅ 创建职业成功：{career.name} (ID: {career.id}, 类型: {career.type})")
        
        return CareerResponse(
            id=career.id,
            project_id=career.project_id,
            name=career.name,
            type=career.type,
            description=career.description,
            category=career.category,
            stages=career_data.stages,
            max_stage=career.max_stage,
            requirements=career.requirements,
            special_abilities=career.special_abilities,
            worldview_rules=career.worldview_rules,
            attribute_bonuses=career_data.attribute_bonuses,
            source=career.source,
            created_at=career.created_at,
            updated_at=career.updated_at
        )
        
    except Exception as e:
        logger.error(f"创建职业失败: {str(e)}")
        raise HTTPException(status_code=500, detail=f"创建职业失败: {str(e)}")


@router.get("/generate-system", summary="AI生成新职业（增量式，流式）")
async def generate_career_system(
    project_id: str,
    main_career_count: int = 3,
    sub_career_count: int = 6,
    user_requirements: str = "",
    enable_mcp: bool = False,
    http_request: Request = None,
    db: AsyncSession = Depends(get_db),
    user_ai_service: AIService = Depends(get_user_ai_service)
):
    """
    使用AI生成新职业（增量式，基于已有职业补充，支持SSE流式进度显示）
    
    通过Server-Sent Events返回实时进度信息
    """
    async def generate() -> AsyncGenerator[str, None]:
        tracker = WizardProgressTracker("职业体系")
        try:
            # 验证用户权限和项目是否存在
            user_id = getattr(http_request.state, 'user_id', None)
            project = await verify_project_access(project_id, user_id, db)
            
            yield await tracker.start()
            
            # 获取已有职业列表
            yield await tracker.loading("分析已有职业...", 0.3)
            
            existing_careers_result = await db.execute(
                select(Career).where(Career.project_id == project_id)
            )
            existing_careers = existing_careers_result.scalars().all()
            
            # 构建已有职业摘要
            existing_main_careers = []
            existing_sub_careers = []
            for career in existing_careers:
                career_summary = f"- {career.name}（{career.category or '未分类'}，{career.max_stage}阶）"
                if career.description:
                    career_summary += f": {career.description[:50]}"
                
                if career.type == "main":
                    existing_main_careers.append(career_summary)
                else:
                    existing_sub_careers.append(career_summary)
            
            existing_careers_text = ""
            if existing_main_careers:
                existing_careers_text += f"\n已有主职业（{len(existing_main_careers)}个）：\n" + "\n".join(existing_main_careers)
            if existing_sub_careers:
                existing_careers_text += f"\n\n已有副职业（{len(existing_sub_careers)}个）：\n" + "\n".join(existing_sub_careers)
            
            if not existing_careers_text:
                existing_careers_text = "\n当前还没有任何职业，这是第一次创建职业体系。"
            
            # 构建项目上下文
            yield await tracker.loading("分析项目世界观...", 0.6)
            
            project_context = f"""
项目信息：
- 书名：{project.title}
- 类型：{project.genre or '未设定'}
- 主题：{project.theme or '未设定'}
- 时间背景：{project.world_time_period or '未设定'}
- 地理位置：{project.world_location or '未设定'}
- 氛围基调：{project.world_atmosphere or '未设定'}
- 世界规则：{project.world_rules or '未设定'}
"""
            
            sanitized_user_requirements = user_requirements.strip()
            extra_requirement_text = ""
            if sanitized_user_requirements:
                extra_requirement_text = f"""
用户额外要求：
{sanitized_user_requirements}

执行要求：
- 请优先满足用户提出的职业方向、能力风格、限制条件和避雷项
- 如果用户要求与已有职业高度相似，请保留需求核心，但生成定位差异明确的新职业
- 如果用户要求与项目世界观冲突，请在不违背世界观的前提下进行合理改写和本土化适配
"""

            generation_requirements = f"""
已有职业情况：{existing_careers_text}

生成要求（增量式）：
- 本次新增主职业：{main_career_count}个
- 本次新增副职业：{sub_career_count}个
- ⚠️ 重要：请生成与已有职业**不重复**的新职业，形成互补体系
- 新职业应填补已有职业体系的空缺，丰富职业多样性
- 主职业必须严格符合世界观规则，体现核心能力体系
- 副职业可以更加自由灵活，包含生产、辅助、特殊类型

{extra_requirement_text}"""
            
            yield await tracker.preparing("构建AI提示词...")
            
            # 构建提示词
            prompt = f"""{project_context}

{generation_requirements}

请为这个小说项目生成新的补充职业（增量式）。要求：
1. **仔细分析已有职业**，避免生成重复或相似的职业
2. **填补职业体系的空缺**，让职业体系更加完善和多样化
3. 如果已有职业较少，可以生成核心基础职业
4. 如果已有职业较多，可以生成特色化、专精化的职业

返回JSON格式，结构如下：

{{
  "main_careers": [
    {{
      "name": "职业名称",
      "description": "职业描述",
      "category": "职业分类（如：战斗系、法术系等）",
      "stages": [
        {{"level": 1, "name": "阶段名称", "description": "阶段描述"}},
        {{"level": 2, "name": "阶段名称", "description": "阶段描述"}},
        ...
      ],
      "max_stage": 10,
      "requirements": "职业要求",
      "special_abilities": "特殊能力",
      "worldview_rules": "世界观规则关联",
      "attribute_bonuses": {{"strength": "+10%", "intelligence": "+5%"}}
    }}
  ],
  "sub_careers": [
    {{
      "name": "副职业名称",
      "description": "职业描述",
      "category": "生产系/辅助系/特殊系",
      "stages": [...],
      "max_stage": 5,
      "requirements": "职业要求",
      "special_abilities": "特殊能力"
    }}
  ]
}}

注意事项：
1. **避免重复**：生成的职业名称和定位不能与已有职业重复
2. **互补性**：新职业应与已有职业形成互补，丰富职业体系
3. 主职业的阶段设定要详细，体现明确的成长路径
4. 阶段名称要符合世界观特色
5. 副职业可以相对简化，但要有独特性
6. 所有职业都要符合项目的整体世界观设定
7. 如果提供了用户额外要求，请优先满足；若与世界观冲突，必须以世界观为准进行合理改写
8. 只返回纯JSON，不要添加任何解释文字
"""
            
            yield await tracker.generating(0, max(3000, len(prompt) * 8), "调用AI生成新职业...")
            logger.info(f"🎯 开始为项目 {project_id} 生成新职业（增量式，已有{len(existing_careers)}个职业）")
            
            try:
                # 使用流式生成替代非流式
                ai_response = ""
                chunk_count = 0
                estimated_total = max(3000, len(prompt) * 8)
                
                async for chunk in user_ai_service.generate_text_stream(prompt=prompt):
                    chunk_count += 1
                    ai_response += chunk
                    
                    # 发送内容块
                    yield await SSEResponse.send_chunk(chunk)
                    
                    # 平滑更新进度（避免过于频繁）
                    if chunk_count % 10 == 0:
                        yield await tracker.generating(len(ai_response), estimated_total)
                    
                    # 心跳
                    if chunk_count % 20 == 0:
                        yield await tracker.heartbeat()
                
            except Exception as ai_error:
                logger.error(f"❌ AI服务调用异常：{str(ai_error)}")
                yield await tracker.error(f"AI服务调用失败：{str(ai_error)}")
                return
            
            if not ai_response or not ai_response.strip():
                yield await tracker.error("AI服务返回空响应")
                return
            
            yield await tracker.parsing("解析AI响应...", 0.5)
            
            # 清洗并解析JSON
            try:
                cleaned_response = user_ai_service._clean_json_response(ai_response)
                career_data = json.loads(cleaned_response)
                logger.info(f"✅ 职业体系JSON解析成功")
            except json.JSONDecodeError as e:
                logger.error(f"❌ 职业体系JSON解析失败: {e}")
                logger.error(f"   原始响应预览: {ai_response[:200]}")
                yield await tracker.error(f"AI返回的内容无法解析为JSON：{str(e)}")
                return
            
            yield await tracker.saving("保存主职业到数据库...", 0.3)
            
            # 保存主职业
            main_careers_created = []
            for idx, career_info in enumerate(career_data.get("main_careers", [])):
                try:
                    stages_json = json.dumps(career_info.get("stages", []), ensure_ascii=False)
                    attribute_bonuses = career_info.get("attribute_bonuses")
                    attribute_bonuses_json = json.dumps(attribute_bonuses, ensure_ascii=False) if attribute_bonuses else None
                    
                    career = Career(
                        project_id=project_id,
                        name=career_info.get("name", f"未命名主职业{idx+1}"),
                        type="main",
                        description=career_info.get("description"),
                        category=career_info.get("category"),
                        stages=stages_json,
                        max_stage=career_info.get("max_stage", 10),
                        requirements=career_info.get("requirements"),
                        special_abilities=career_info.get("special_abilities"),
                        worldview_rules=career_info.get("worldview_rules"),
                        attribute_bonuses=attribute_bonuses_json,
                        source="ai"
                    )
                    db.add(career)
                    await db.flush()
                    main_careers_created.append(career.name)
                    logger.info(f"  ✅ 创建主职业：{career.name}")
                except Exception as e:
                    logger.error(f"  ❌ 创建主职业失败：{str(e)}")
                    continue
            
            yield await tracker.saving("保存副职业到数据库...", 0.6)
            
            # 保存副职业
            sub_careers_created = []
            for idx, career_info in enumerate(career_data.get("sub_careers", [])):
                try:
                    stages_json = json.dumps(career_info.get("stages", []), ensure_ascii=False)
                    attribute_bonuses = career_info.get("attribute_bonuses")
                    attribute_bonuses_json = json.dumps(attribute_bonuses, ensure_ascii=False) if attribute_bonuses else None
                    
                    career = Career(
                        project_id=project_id,
                        name=career_info.get("name", f"未命名副职业{idx+1}"),
                        type="sub",
                        description=career_info.get("description"),
                        category=career_info.get("category"),
                        stages=stages_json,
                        max_stage=career_info.get("max_stage", 5),
                        requirements=career_info.get("requirements"),
                        special_abilities=career_info.get("special_abilities"),
                        worldview_rules=career_info.get("worldview_rules"),
                        attribute_bonuses=attribute_bonuses_json,
                        source="ai"
                    )
                    db.add(career)
                    await db.flush()
                    sub_careers_created.append(career.name)
                    logger.info(f"  ✅ 创建副职业：{career.name}")
                except Exception as e:
                    logger.error(f"  ❌ 创建副职业失败：{str(e)}")
                    continue
            
            await db.commit()
            
            total_main = len(existing_main_careers) + len(main_careers_created)
            total_sub = len(existing_sub_careers) + len(sub_careers_created)
            
            logger.info(f"🎉 新职业生成完成：新增主职业{len(main_careers_created)}个，新增副职业{len(sub_careers_created)}个")
            logger.info(f"   职业体系总数：主职业{total_main}个，副职业{total_sub}个")
            
            yield await tracker.complete(f"新职业生成完成！（主职业{total_main}个，副职业{total_sub}个）")
            
            # 发送结果数据
            yield await tracker.result({
                "main_careers_count": len(main_careers_created),
                "sub_careers_count": len(sub_careers_created),
                "main_careers": main_careers_created,
                "sub_careers": sub_careers_created
            })
            
            yield await tracker.done()
            
        except HTTPException as he:
            logger.error(f"HTTP异常: {he.detail}")
            yield await tracker.error(he.detail, he.status_code)
        except Exception as e:
            logger.error(f"生成职业体系失败: {str(e)}")
            yield await tracker.error(f"生成新职业失败: {str(e)}")
    
    return create_sse_response(generate())


@router.put("/{career_id}", response_model=CareerResponse, summary="更新职业")
async def update_career(
    career_id: str,
    career_update: CareerUpdate,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """更新职业信息"""
    result = await db.execute(
        select(Career).where(Career.id == career_id)
    )
    career = result.scalar_one_or_none()
    
    if not career:
        raise HTTPException(status_code=404, detail="职业不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(career.project_id, user_id, db)
    
    # 更新字段
    update_data = career_update.model_dump(exclude_unset=True)
    
    for field, value in update_data.items():
        if field == "stages" and value is not None:
            # 转换为JSON字符串
            # model_dump() 已经将嵌套模型转换为字典，所以 value 中的元素已经是 dict
            stages_list = [
                stage if isinstance(stage, dict) else stage.model_dump()
                for stage in value
            ]
            setattr(career, field, json.dumps(stages_list, ensure_ascii=False))
        elif field == "attribute_bonuses" and value is not None:
            # 转换为JSON字符串
            setattr(career, field, json.dumps(value, ensure_ascii=False))
        else:
            setattr(career, field, value)
    
    await db.commit()
    await db.refresh(career)
    
    logger.info(f"✅ 更新职业成功：{career.name} (ID: {career_id})")
    
    # 解析JSON返回
    stages = json.loads(career.stages) if career.stages else []
    attribute_bonuses = json.loads(career.attribute_bonuses) if career.attribute_bonuses else None
    
    return CareerResponse(
        id=career.id,
        project_id=career.project_id,
        name=career.name,
        type=career.type,
        description=career.description,
        category=career.category,
        stages=stages,
        max_stage=career.max_stage,
        requirements=career.requirements,
        special_abilities=career.special_abilities,
        worldview_rules=career.worldview_rules,
        attribute_bonuses=attribute_bonuses,
        source=career.source,
        created_at=career.created_at,
        updated_at=career.updated_at
    )


@router.delete("/{career_id}", summary="删除职业")
async def delete_career(
    career_id: str,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """删除职业"""
    result = await db.execute(
        select(Career).where(Career.id == career_id)
    )
    career = result.scalar_one_or_none()
    
    if not career:
        raise HTTPException(status_code=404, detail="职业不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(career.project_id, user_id, db)
    
    # 检查是否有角色使用该职业
    char_career_result = await db.execute(
        select(func.count(CharacterCareer.id)).where(CharacterCareer.career_id == career_id)
    )
    usage_count = char_career_result.scalar_one()
    
    if usage_count > 0:
        raise HTTPException(
            status_code=400,
            detail=f"该职业被{usage_count}个角色使用，无法删除。请先移除角色的职业关联。"
        )
    
    await db.delete(career)
    await db.commit()
    
    logger.info(f"✅ 删除职业成功：{career.name} (ID: {career_id})")
    
    return {"message": "职业删除成功"}


@router.get("/{career_id}", response_model=CareerResponse, summary="获取职业详情")
async def get_career(
    career_id: str,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """根据ID获取职业详情"""
    result = await db.execute(
        select(Career).where(Career.id == career_id)
    )
    career = result.scalar_one_or_none()
    
    if not career:
        raise HTTPException(status_code=404, detail="职业不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(career.project_id, user_id, db)
    
    # 解析JSON字段
    stages = json.loads(career.stages) if career.stages else []
    attribute_bonuses = json.loads(career.attribute_bonuses) if career.attribute_bonuses else None
    
    return CareerResponse(
        id=career.id,
        project_id=career.project_id,
        name=career.name,
        type=career.type,
        description=career.description,
        category=career.category,
        stages=stages,
        max_stage=career.max_stage,
        requirements=career.requirements,
        special_abilities=career.special_abilities,
        worldview_rules=career.worldview_rules,
        attribute_bonuses=attribute_bonuses,
        source=career.source,
        created_at=career.created_at,
        updated_at=career.updated_at
    )


# ===== 角色职业关联API =====

@router.get("/character/{character_id}/careers", response_model=CharacterCareerResponse, summary="获取角色的职业信息")
async def get_character_careers(
    character_id: str,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """获取角色的所有职业信息（主职业和副职业）"""
    # 验证角色存在
    char_result = await db.execute(
        select(Character).where(Character.id == character_id)
    )
    character = char_result.scalar_one_or_none()
    
    if not character:
        raise HTTPException(status_code=404, detail="角色不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(character.project_id, user_id, db)
    
    # 获取角色的所有职业关联
    result = await db.execute(
        select(CharacterCareer, Career)
        .join(Career, CharacterCareer.career_id == Career.id)
        .where(CharacterCareer.character_id == character_id)
        .order_by(CharacterCareer.career_type.desc())  # main排在前
    )
    career_relations = result.all()
    
    main_career = None
    sub_careers = []
    
    for char_career, career in career_relations:
        # 解析职业的阶段信息
        stages = json.loads(career.stages) if career.stages else []
        
        # 找到当前阶段信息
        stage_name = "未知阶段"
        stage_description = None
        for stage in stages:
            if stage.get("level") == char_career.current_stage:
                stage_name = stage.get("name", f"第{char_career.current_stage}阶段")
                stage_description = stage.get("description")
                break
        
        career_detail = CharacterCareerDetail(
            id=char_career.id,
            character_id=char_career.character_id,
            career_id=char_career.career_id,
            career_name=career.name,
            career_type=char_career.career_type,
            current_stage=char_career.current_stage,
            stage_name=stage_name,
            stage_description=stage_description,
            stage_progress=char_career.stage_progress,
            max_stage=career.max_stage,
            started_at=char_career.started_at,
            reached_current_stage_at=char_career.reached_current_stage_at,
            notes=char_career.notes,
            created_at=char_career.created_at,
            updated_at=char_career.updated_at
        )
        
        if char_career.career_type == "main":
            main_career = career_detail
        else:
            sub_careers.append(career_detail)
    
    return CharacterCareerResponse(
        main_career=main_career,
        sub_careers=sub_careers
    )


@router.post("/character/{character_id}/careers/main", summary="设置角色主职业")
async def set_main_career(
    character_id: str,
    career_request: SetMainCareerRequest,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """设置或更换角色的主职业"""
    # 验证角色存在
    char_result = await db.execute(
        select(Character).where(Character.id == character_id)
    )
    character = char_result.scalar_one_or_none()
    
    if not character:
        raise HTTPException(status_code=404, detail="角色不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(character.project_id, user_id, db)
    
    # 验证职业存在且为主职业类型
    career_result = await db.execute(
        select(Career).where(
            Career.id == career_request.career_id,
            Career.project_id == character.project_id
        )
    )
    career = career_result.scalar_one_or_none()
    
    if not career:
        raise HTTPException(status_code=404, detail="职业不存在")
    
    if career.type != "main":
        raise HTTPException(status_code=400, detail="该职业不是主职业类型，无法设置为主职业")
    
    # 验证阶段有效性
    if career_request.current_stage > career.max_stage:
        raise HTTPException(
            status_code=400,
            detail=f"阶段超出范围，该职业最大阶段为{career.max_stage}"
        )
    
    # 检查是否已有主职业
    existing_main = await db.execute(
        select(CharacterCareer).where(
            CharacterCareer.character_id == character_id,
            CharacterCareer.career_type == "main"
        )
    )
    current_main = existing_main.scalar_one_or_none()
    
    if current_main:
        # 删除旧的主职业
        await db.delete(current_main)
        logger.info(f"  移除旧主职业关联: {current_main.career_id}")
    
    # 创建新的主职业关联
    char_career = CharacterCareer(
        character_id=character_id,
        career_id=career_request.career_id,
        career_type="main",
        current_stage=career_request.current_stage,
        stage_progress=0,
        started_at=career_request.started_at,
        reached_current_stage_at=career_request.started_at
    )
    db.add(char_career)
    await db.commit()
    
    logger.info(f"✅ 设置主职业成功：角色{character.name} -> {career.name}（第{career_request.current_stage}阶段）")
    
    return {"message": "主职业设置成功", "career_name": career.name}


@router.post("/character/{character_id}/careers/sub", summary="添加角色副职业")
async def add_sub_career(
    character_id: str,
    career_request: AddSubCareerRequest,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """为角色添加副职业"""
    # 验证角色存在
    char_result = await db.execute(
        select(Character).where(Character.id == character_id)
    )
    character = char_result.scalar_one_or_none()
    
    if not character:
        raise HTTPException(status_code=404, detail="角色不存在")
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(character.project_id, user_id, db)
    
    # 验证职业存在且为副职业类型
    career_result = await db.execute(
        select(Career).where(
            Career.id == career_request.career_id,
            Career.project_id == character.project_id
        )
    )
    career = career_result.scalar_one_or_none()
    
    if not career:
        raise HTTPException(status_code=404, detail="职业不存在")
    
    if career.type != "sub":
        raise HTTPException(status_code=400, detail="该职业不是副职业类型，无法添加为副职业")
    
    # 验证阶段有效性
    if career_request.current_stage > career.max_stage:
        raise HTTPException(
            status_code=400,
            detail=f"阶段超出范围，该职业最大阶段为{career.max_stage}"
        )
    
    # 检查是否已存在
    existing_check = await db.execute(
        select(CharacterCareer).where(
            CharacterCareer.character_id == character_id,
            CharacterCareer.career_id == career_request.career_id
        )
    )
    if existing_check.scalar_one_or_none():
        raise HTTPException(status_code=400, detail="该角色已拥有此副职业")
    
    # 检查副职业数量限制（可选，这里设置为最多5个）
    sub_count_result = await db.execute(
        select(func.count(CharacterCareer.id)).where(
            CharacterCareer.character_id == character_id,
            CharacterCareer.career_type == "sub"
        )
    )
    sub_count = sub_count_result.scalar_one()
    
    if sub_count >= 5:
        raise HTTPException(status_code=400, detail="副职业数量已达上限（最多5个）")
    
    # 创建副职业关联
    char_career = CharacterCareer(
        character_id=character_id,
        career_id=career_request.career_id,
        career_type="sub",
        current_stage=career_request.current_stage,
        stage_progress=0,
        started_at=career_request.started_at,
        reached_current_stage_at=career_request.started_at
    )
    db.add(char_career)
    await db.commit()
    
    logger.info(f"✅ 添加副职业成功：角色{character.name} -> {career.name}（第{career_request.current_stage}阶段）")
    
    return {"message": "副职业添加成功", "career_name": career.name}


@router.put("/character/{character_id}/careers/{career_id}/stage", summary="更新职业阶段")
async def update_career_stage(
    character_id: str,
    career_id: str,
    stage_request: UpdateCareerStageRequest,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """更新角色在某个职业的阶段"""
    # 验证角色职业关联存在
    result = await db.execute(
        select(CharacterCareer, Career, Character)
        .join(Career, CharacterCareer.career_id == Career.id)
        .join(Character, CharacterCareer.character_id == Character.id)
        .where(
            CharacterCareer.character_id == character_id,
            CharacterCareer.career_id == career_id
        )
    )
    relation_data = result.one_or_none()
    
    if not relation_data:
        raise HTTPException(status_code=404, detail="角色职业关联不存在")
    
    char_career, career, character = relation_data
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(character.project_id, user_id, db)
    
    # 验证新阶段有效性
    if stage_request.current_stage > career.max_stage:
        raise HTTPException(
            status_code=400,
            detail=f"阶段超出范围，该职业最大阶段为{career.max_stage}"
        )
    
    # 验证阶段递增规则（不能倒退，除非降级）
    if stage_request.current_stage < char_career.current_stage:
        logger.warning(f"⚠️ 角色{character.name}的职业{career.name}阶段降低：{char_career.current_stage} -> {stage_request.current_stage}")
    
    # 更新阶段信息
    char_career.current_stage = stage_request.current_stage
    char_career.stage_progress = stage_request.stage_progress
    if stage_request.reached_current_stage_at:
        char_career.reached_current_stage_at = stage_request.reached_current_stage_at
    if stage_request.notes is not None:
        char_career.notes = stage_request.notes
    
    await db.commit()
    
    logger.info(f"✅ 更新职业阶段成功：{character.name}的{career.name} -> 第{stage_request.current_stage}阶段")
    
    return {
        "message": "职业阶段更新成功",
        "career_name": career.name,
        "new_stage": stage_request.current_stage
    }


@router.delete("/character/{character_id}/careers/{career_id}", summary="删除角色副职业")
async def remove_sub_career(
    character_id: str,
    career_id: str,
    request: Request,
    db: AsyncSession = Depends(get_db)
):
    """删除角色的副职业"""
    # 验证角色职业关联存在
    result = await db.execute(
        select(CharacterCareer, Character)
        .join(Character, CharacterCareer.character_id == Character.id)
        .where(
            CharacterCareer.character_id == character_id,
            CharacterCareer.career_id == career_id
        )
    )
    relation_data = result.one_or_none()
    
    if not relation_data:
        raise HTTPException(status_code=404, detail="角色职业关联不存在")
    
    char_career, character = relation_data
    
    # 验证用户权限
    user_id = getattr(request.state, 'user_id', None)
    await verify_project_access(character.project_id, user_id, db)
    
    # 不允许删除主职业
    if char_career.career_type == "main":
        raise HTTPException(status_code=400, detail="无法删除主职业，只能更换")
    
    await db.delete(char_career)
    await db.commit()
    
    logger.info(f"✅ 删除副职业成功：角色{character.name}移除职业{career_id}")
    
    return {"message": "副职业删除成功"}