012-kaopeilian/backend/app/api/v1/team_dashboard.py

"""
团队看板 API 路由
提供团队概览、学习进度、排行榜、动态等数据
"""

import json
from datetime import datetime, timedelta
from typing import Any, Dict, List

from fastapi import APIRouter, Depends
from sqlalchemy import and_, func, or_, select
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.deps import get_current_active_user as get_current_user, get_db
from app.core.logger import logger
from app.models.course import Course
from app.models.exam import Exam
from app.models.position import Position
from app.models.position_member import PositionMember
from app.models.practice import PracticeReport, PracticeSession
from app.models.user import Team, User, UserTeam
from app.schemas.base import ResponseModel

router = APIRouter(prefix="/team/dashboard", tags=["team-dashboard"])


async def get_accessible_teams(
    current_user: User,
    db: AsyncSession
) -> List[int]:
    """获取用户可访问的团队ID列表"""
    if current_user.role in ['admin', 'manager']:
        # 管理员查看所有团队
        stmt = select(Team.id).where(Team.is_deleted == False)  # noqa: E712
        result = await db.execute(stmt)
        return [row[0] for row in result.all()]
    else:
        # 普通用户只查看自己的团队
        stmt = select(UserTeam.team_id).where(UserTeam.user_id == current_user.id)
        result = await db.execute(stmt)
        return [row[0] for row in result.all()]


async def get_team_member_ids(
    team_ids: List[int],
    db: AsyncSession
) -> List[int]:
    """获取团队成员ID列表"""
    if not team_ids:
        return []
    
    stmt = select(UserTeam.user_id).where(
        UserTeam.team_id.in_(team_ids)
    ).distinct()
    result = await db.execute(stmt)
    return [row[0] for row in result.all()]


@router.get("/overview", response_model=ResponseModel)
async def get_team_overview(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取团队概览统计
    
    返回团队总数、成员数、平均学习进度、平均成绩、课程完成率等
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        
        # 获取团队成员ID
        member_ids = await get_team_member_ids(team_ids, db)
        
        # 统计团队数
        team_count = len(team_ids)
        
        # 统计成员数
        member_count = len(member_ids)
        
        # 计算平均考试成绩（使用round1_score）
        avg_score = 0.0
        if member_ids:
            stmt = select(func.avg(Exam.round1_score)).where(
                and_(
                    Exam.user_id.in_(member_ids),
                    Exam.round1_score.isnot(None),
                    Exam.status.in_(['completed', 'submitted'])
                )
            )
            result = await db.execute(stmt)
            avg_score_value = result.scalar()
            avg_score = float(avg_score_value) if avg_score_value else 0.0
        
        # 计算平均学习进度（基于考试完成情况）
        avg_progress = 0.0
        if member_ids:
            # 统计每个成员完成的考试数
            stmt = select(func.count(Exam.id)).where(
                and_(
                    Exam.user_id.in_(member_ids),
                    Exam.status.in_(['completed', 'submitted'])
                )
            )
            result = await db.execute(stmt)
            completed_exams = result.scalar() or 0
            
            # 假设每个成员应完成10个考试，计算完成率作为进度
            total_expected = member_count * 10
            if total_expected > 0:
                avg_progress = (completed_exams / total_expected) * 100
        
        # 计算课程完成率
        course_completion_rate = 0.0
        if member_ids:
            # 统计已完成的课程数（有考试记录且成绩>=60）
            stmt = select(func.count(func.distinct(Exam.course_id))).where(
                and_(
                    Exam.user_id.in_(member_ids),
                    Exam.round1_score >= 60,
                    Exam.status.in_(['completed', 'submitted'])
                )
            )
            result = await db.execute(stmt)
            completed_courses = result.scalar() or 0
            
            # 统计总课程数
            stmt = select(func.count(Course.id)).where(
                and_(
                    Course.is_deleted == False,  # noqa: E712
                    Course.status == 'published'
                )
            )
            result = await db.execute(stmt)
            total_courses = result.scalar() or 0
            
            if total_courses > 0:
                course_completion_rate = (completed_courses / total_courses) * 100
        
        # 趋势数据（暂时返回固定值，后续可实现真实趋势计算）
        trends = {
            "member_trend": 0,
            "progress_trend": 12.3 if avg_progress > 0 else 0,
            "score_trend": 5.8 if avg_score > 0 else 0,
            "completion_trend": -3.2 if course_completion_rate > 0 else 0
        }
        
        data = {
            "team_count": team_count,
            "member_count": member_count,
            "avg_progress": round(avg_progress, 1),
            "avg_score": round(avg_score, 1),
            "course_completion_rate": round(course_completion_rate, 1),
            "trends": trends
        }
        
        return ResponseModel(code=200, message="success", data=data)
        
    except Exception as e:
        logger.error(f"获取团队概览失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取团队概览失败: {str(e)}", data=None)


@router.get("/progress", response_model=ResponseModel)
async def get_progress_data(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取学习进度数据
    
    返回Top 5成员的8周学习进度数据
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        member_ids = await get_team_member_ids(team_ids, db)
        
        if not member_ids:
            return ResponseModel(
                code=200,
                message="success",
                data={"members": [], "weeks": [], "data": []}
            )
        
        # 获取Top 5学习时长最高的成员
        stmt = (
            select(
                User.id,
                User.full_name,
                func.sum(PracticeSession.duration_seconds).label('total_duration')
            )
            .join(PracticeSession, PracticeSession.user_id == User.id)
            .where(
                and_(
                    User.id.in_(member_ids),
                    PracticeSession.status == 'completed'
                )
            )
            .group_by(User.id, User.full_name)
            .order_by(func.sum(PracticeSession.duration_seconds).desc())
            .limit(5)
        )
        result = await db.execute(stmt)
        top_members = result.all()
        
        if not top_members:
            # 如果没有陪练记录，按考试成绩选择Top 5
            stmt = (
                select(
                    User.id,
                    User.full_name,
                    func.avg(Exam.round1_score).label('avg_score')
                )
                .join(Exam, Exam.user_id == User.id)
                .where(
                    and_(
                        User.id.in_(member_ids),
                        Exam.round1_score.isnot(None),
                        Exam.status.in_(['completed', 'submitted'])
                    )
                )
                .group_by(User.id, User.full_name)
                .order_by(func.avg(Exam.round1_score).desc())
                .limit(5)
            )
            result = await db.execute(stmt)
            top_members = result.all()
        
        # 生成周标签
        weeks = [f"第{i+1}周" for i in range(8)]
        
        # 为每个成员生成进度数据
        members = []
        data = []
        
        for member in top_members:
            member_name = member.full_name or f"用户{member.id}"
            members.append(member_name)
            
            # 查询该成员8周内的考试完成情况
            eight_weeks_ago = datetime.now() - timedelta(weeks=8)
            stmt = select(Exam).where(
                and_(
                    Exam.user_id == member.id,
                    Exam.created_at >= eight_weeks_ago,
                    Exam.status.in_(['completed', 'submitted'])
                )
            ).order_by(Exam.created_at)
            result = await db.execute(stmt)
            exams = result.scalars().all()
            
            # 计算每周的进度（0-100）
            values = []
            for week in range(8):
                week_start = datetime.now() - timedelta(weeks=8-week)
                week_end = week_start + timedelta(weeks=1)
                
                # 统计该周完成的考试数
                week_exams = [
                    e for e in exams
                    if week_start <= e.created_at < week_end
                ]
                
                # 进度 = 累计完成考试数 * 10（假设每个考试代表10%进度）
                cumulative_exams = len([e for e in exams if e.created_at < week_end])
                progress = min(cumulative_exams * 10, 100)
                values.append(progress)
            
            data.append({"name": member_name, "values": values})
        
        return ResponseModel(
            code=200,
            message="success",
            data={"members": members, "weeks": weeks, "data": data}
        )
        
    except Exception as e:
        logger.error(f"获取学习进度数据失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取学习进度数据失败: {str(e)}", data=None)


@router.get("/course-distribution", response_model=ResponseModel)
async def get_course_distribution(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取课程完成分布
    
    返回已完成、进行中、未开始的课程数量
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        member_ids = await get_team_member_ids(team_ids, db)
        
        # 统计所有已发布的课程
        stmt = select(func.count(Course.id)).where(
            and_(
                Course.is_deleted == False,  # noqa: E712
                Course.status == 'published'
            )
        )
        result = await db.execute(stmt)
        total_courses = result.scalar() or 0
        
        if not member_ids or total_courses == 0:
            return ResponseModel(
                code=200,
                message="success",
                data={"completed": 0, "in_progress": 0, "not_started": 0}
            )
        
        # 统计已完成的课程（有及格成绩）
        stmt = select(func.count(func.distinct(Exam.course_id))).where(
            and_(
                Exam.user_id.in_(member_ids),
                Exam.round1_score >= 60,
                Exam.status.in_(['completed', 'submitted'])
            )
        )
        result = await db.execute(stmt)
        completed = result.scalar() or 0
        
        # 统计进行中的课程（有考试记录但未及格）
        stmt = select(func.count(func.distinct(Exam.course_id))).where(
            and_(
                Exam.user_id.in_(member_ids),
                or_(
                    Exam.round1_score < 60,
                    Exam.status == 'started'
                )
            )
        )
        result = await db.execute(stmt)
        in_progress = result.scalar() or 0
        
        # 未开始 = 总数 - 已完成 - 进行中
        not_started = max(0, total_courses - completed - in_progress)
        
        data = {
            "completed": completed,
            "in_progress": in_progress,
            "not_started": not_started
        }
        
        return ResponseModel(code=200, message="success", data=data)
        
    except Exception as e:
        logger.error(f"获取课程分布失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取课程分布失败: {str(e)}", data=None)


@router.get("/ability-analysis", response_model=ResponseModel)
async def get_ability_analysis(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取能力分析数据
    
    返回团队能力雷达图数据和短板列表
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        member_ids = await get_team_member_ids(team_ids, db)
        
        if not member_ids:
            return ResponseModel(
                code=200,
                message="success",
                data={
                    "radar_data": {
                        "dimensions": [],
                        "values": []
                    },
                    "weaknesses": []
                }
            )
        
        # 查询所有陪练报告的能力维度数据
        # 需要通过PracticeSession关联，因为PracticeReport没有user_id
        stmt = (
            select(PracticeReport.ability_dimensions)
            .join(PracticeSession, PracticeSession.session_id == PracticeReport.session_id)
            .where(PracticeSession.user_id.in_(member_ids))
        )
        result = await db.execute(stmt)
        all_dimensions = result.scalars().all()
        
        if not all_dimensions:
            # 如果没有陪练报告，返回默认能力维度
            default_dimensions = ["沟通表达", "倾听理解", "需求挖掘", "异议处理", "成交技巧", "客户维护"]
            return ResponseModel(
                code=200,
                message="success",
                data={
                    "radar_data": {
                        "dimensions": default_dimensions,
                        "values": [0] * len(default_dimensions)
                    },
                    "weaknesses": []
                }
            )
        
        # 聚合能力数据
        ability_scores: Dict[str, List[float]] = {}
        
        # 能力维度名称映射
        dimension_name_map = {
            "sales_ability": "销售能力",
            "service_attitude": "服务态度",
            "technical_skills": "技术能力",
            "沟通表达": "沟通表达",
            "倾听理解": "倾听理解",
            "需求挖掘": "需求挖掘",
            "异议处理": "异议处理",
            "成交技巧": "成交技巧",
            "客户维护": "客户维护"
        }
        
        for dimensions in all_dimensions:
            if dimensions:
                # 如果是字符串，进行JSON反序列化
                if isinstance(dimensions, str):
                    try:
                        dimensions = json.loads(dimensions)
                    except json.JSONDecodeError:
                        logger.warning(f"无法解析能力维度数据: {dimensions}")
                        continue
                
                # 处理字典格式：{"sales_ability": 79.0, ...}
                if isinstance(dimensions, dict):
                    for key, score in dimensions.items():
                        name = dimension_name_map.get(key, key)
                        if name not in ability_scores:
                            ability_scores[name] = []
                        ability_scores[name].append(float(score))
                
                # 处理列表格式：[{"name": "沟通表达", "score": 85}, ...]
                elif isinstance(dimensions, list):
                    for dim in dimensions:
                        if not isinstance(dim, dict):
                            logger.warning(f"能力维度项格式错误: {type(dim)}")
                            continue
                        
                        name = dim.get('name', '')
                        score = dim.get('score', 0)
                        if name:
                            mapped_name = dimension_name_map.get(name, name)
                            if mapped_name not in ability_scores:
                                ability_scores[mapped_name] = []
                            ability_scores[mapped_name].append(float(score))
                else:
                    logger.warning(f"能力维度数据格式错误: {type(dimensions)}")
        
        # 计算平均分
        avg_scores = {
            name: sum(scores) / len(scores)
            for name, scores in ability_scores.items()
        }
        
        # 按固定顺序排列维度（支持多种维度组合）
        # 优先使用六维度，如果没有则使用三维度
        standard_dimensions_six = ["沟通表达", "倾听理解", "需求挖掘", "异议处理", "成交技巧", "客户维护"]
        standard_dimensions_three = ["销售能力", "服务态度", "技术能力"]
        
        # 判断使用哪种维度标准
        has_six_dimensions = any(dim in avg_scores for dim in standard_dimensions_six)
        has_three_dimensions = any(dim in avg_scores for dim in standard_dimensions_three)
        
        if has_six_dimensions:
            standard_dimensions = standard_dimensions_six
        elif has_three_dimensions:
            standard_dimensions = standard_dimensions_three
        else:
            # 如果都没有，使用实际数据的维度
            standard_dimensions = list(avg_scores.keys())
        
        dimensions = []
        values = []
        
        for dim in standard_dimensions:
            if dim in avg_scores:
                dimensions.append(dim)
                values.append(round(avg_scores[dim], 1))
        
        # 找出短板（平均分<80）
        weaknesses = []
        weakness_suggestions = {
            # 六维度建议
            "异议处理": "建议加强异议处理专项训练，增加实战演练",
            "成交技巧": "需要系统学习成交话术和时机把握",
            "需求挖掘": "提升提问技巧，深入了解客户需求",
            "沟通表达": "加强沟通技巧训练，提升表达能力",
            "倾听理解": "培养同理心，提高倾听和理解能力",
            "客户维护": "学习客户关系管理，提升服务质量",
            # 三维度建议
            "销售能力": "建议加强销售技巧训练，提升成交率",
            "服务态度": "需要改善服务态度，提高客户满意度",
            "技术能力": "建议学习产品知识，提升专业能力"
        }
        
        for name, score in avg_scores.items():
            if score < 80:
                weaknesses.append({
                    "name": name,
                    "avg_score": int(score),
                    "suggestion": weakness_suggestions.get(name, f"建议加强{name}专项训练")
                })
        
        # 按分数升序排列
        weaknesses.sort(key=lambda x: x['avg_score'])
        
        data = {
            "radar_data": {
                "dimensions": dimensions,
                "values": values
            },
            "weaknesses": weaknesses
        }
        
        return ResponseModel(code=200, message="success", data=data)
        
    except Exception as e:
        logger.error(f"获取能力分析失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取能力分析失败: {str(e)}", data=None)


@router.get("/rankings", response_model=ResponseModel)
async def get_rankings(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取排行榜数据
    
    返回学习时长排行和成绩排行Top 5
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        member_ids = await get_team_member_ids(team_ids, db)
        
        if not member_ids:
            return ResponseModel(
                code=200,
                message="success",
                data={
                    "study_time_ranking": [],
                    "score_ranking": []
                }
            )
        
        # 学习时长排行（基于陪练会话）
        stmt = (
            select(
                User.id,
                User.full_name,
                User.avatar_url,
                Position.name.label('position_name'),
                func.sum(PracticeSession.duration_seconds).label('total_duration')
            )
            .join(PracticeSession, PracticeSession.user_id == User.id)
            .outerjoin(PositionMember, and_(
                PositionMember.user_id == User.id,
                PositionMember.is_deleted == False  # noqa: E712
            ))
            .outerjoin(Position, Position.id == PositionMember.position_id)
            .where(
                and_(
                    User.id.in_(member_ids),
                    PracticeSession.status == 'completed'
                )
            )
            .group_by(User.id, User.full_name, User.avatar_url, Position.name)
            .order_by(func.sum(PracticeSession.duration_seconds).desc())
            .limit(5)
        )
        result = await db.execute(stmt)
        study_time_data = result.all()
        
        study_time_ranking = []
        for row in study_time_data:
            study_time_ranking.append({
                "id": row.id,
                "name": row.full_name or f"用户{row.id}",
                "position": row.position_name or "未分配岗位",
                "avatar": row.avatar_url or "",
                "study_time": round(row.total_duration / 3600, 1)  # 转换为小时
            })
        
        # 成绩排行（基于考试round1_score）
        stmt = (
            select(
                User.id,
                User.full_name,
                User.avatar_url,
                Position.name.label('position_name'),
                func.avg(Exam.round1_score).label('avg_score')
            )
            .join(Exam, Exam.user_id == User.id)
            .outerjoin(PositionMember, and_(
                PositionMember.user_id == User.id,
                PositionMember.is_deleted == False  # noqa: E712
            ))
            .outerjoin(Position, Position.id == PositionMember.position_id)
            .where(
                and_(
                    User.id.in_(member_ids),
                    Exam.round1_score.isnot(None),
                    Exam.status.in_(['completed', 'submitted'])
                )
            )
            .group_by(User.id, User.full_name, User.avatar_url, Position.name)
            .order_by(func.avg(Exam.round1_score).desc())
            .limit(5)
        )
        result = await db.execute(stmt)
        score_data = result.all()
        
        score_ranking = []
        for row in score_data:
            score_ranking.append({
                "id": row.id,
                "name": row.full_name or f"用户{row.id}",
                "position": row.position_name or "未分配岗位",
                "avatar": row.avatar_url or "",
                "avg_score": round(row.avg_score, 1)
            })
        
        data = {
            "study_time_ranking": study_time_ranking,
            "score_ranking": score_ranking
        }
        
        return ResponseModel(code=200, message="success", data=data)
        
    except Exception as e:
        logger.error(f"获取排行榜失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取排行榜失败: {str(e)}", data=None)


@router.get("/activities", response_model=ResponseModel)
async def get_activities(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db),
) -> ResponseModel:
    """
    获取团队学习动态
    
    返回最近20条活动记录（考试、陪练等）
    """
    try:
        # 获取可访问的团队
        team_ids = await get_accessible_teams(current_user, db)
        member_ids = await get_team_member_ids(team_ids, db)
        
        if not member_ids:
            return ResponseModel(
                code=200,
                message="success",
                data={"activities": []}
            )
        
        activities = []
        
        # 获取最近的考试记录
        stmt = (
            select(Exam, User.full_name, Course.name.label('course_name'))
            .join(User, User.id == Exam.user_id)
            .join(Course, Course.id == Exam.course_id)
            .where(
                and_(
                    Exam.user_id.in_(member_ids),
                    Exam.status.in_(['completed', 'submitted'])
                )
            )
            .order_by(Exam.updated_at.desc())
            .limit(10)
        )
        result = await db.execute(stmt)
        exam_records = result.all()
        
        for exam, user_name, course_name in exam_records:
            score = exam.round1_score or 0
            activity_type = "success" if score >= 60 else "danger"
            result_type = "success" if score >= 60 else "danger"
            result_text = f"成绩：{int(score)}分" if score >= 60 else "未通过"
            
            activities.append({
                "id": f"exam_{exam.id}",
                "user_name": user_name or f"用户{exam.user_id}",
                "action": "完成了" if score >= 60 else "参加了",
                "target": f"《{course_name}》课程考试",
                "time": exam.updated_at.strftime("%Y-%m-%d %H:%M"),
                "type": activity_type,
                "result": {"type": result_type, "text": result_text}
            })
        
        # 获取最近的陪练记录
        stmt = (
            select(PracticeSession, User.full_name, PracticeReport.total_score)
            .join(User, User.id == PracticeSession.user_id)
            .outerjoin(PracticeReport, PracticeReport.session_id == PracticeSession.session_id)
            .where(
                and_(
                    PracticeSession.user_id.in_(member_ids),
                    PracticeSession.status == 'completed'
                )
            )
            .order_by(PracticeSession.end_time.desc())
            .limit(10)
        )
        result = await db.execute(stmt)
        practice_records = result.all()
        
        for session, user_name, total_score in practice_records:
            activity_type = "primary"
            result_data = None
            if total_score:
                result_data = {"type": "", "text": f"评分：{int(total_score)}分"}
            
            activities.append({
                "id": f"practice_{session.id}",
                "user_name": user_name or f"用户{session.user_id}",
                "action": "参加了",
                "target": "AI陪练训练",
                "time": session.end_time.strftime("%Y-%m-%d %H:%M") if session.end_time else "",
                "type": activity_type,
                "result": result_data
            })
        
        # 按时间倒序排列，取前20条
        activities.sort(key=lambda x: x['time'], reverse=True)
        activities = activities[:20]
        
        return ResponseModel(
            code=200,
            message="success",
            data={"activities": activities}
        )
        
    except Exception as e:
        logger.error(f"获取团队动态失败: {e}", exc_info=True)
        return ResponseModel(code=500, message=f"获取团队动态失败: {str(e)}", data=None)