from datetime import datetime
from typing import Any

from fastapi import APIRouter, Depends
from common_logging import get_logger
from sqlalchemy import desc, func
from sqlalchemy.orm import Session

from app.api.permissions import get_current_user
from app.db.session import get_db
from app.models.agent import Agent, ChatMessage
from app.models.audit_log import AuditLog
from app.models.provider import Model, ModelProvider
from app.models.user import User
from common_logging import get_logger

logger = get_logger(__name__)

router = APIRouter(tags=["dashboard"])
logger = get_logger(__name__)


@router.get("/stats")
async def get_dashboard_stats(
    db: Session = Depends(get_db), current_user: User = Depends(get_current_user)
) -> dict[str, Any]:
    logger.info(f"Fetching dashboard stats: user={current_user.id}, tenant={current_user.tenant_id}")
    total_users = db.query(User).filter(User.tenant_id == current_user.tenant_id).count()
    popular_models_query = (
        db.query(
            Model.id,
            Model.name,
            Model.type,
            ModelProvider.id.label("provider_id"),
            ModelProvider.name.label("provider_name"),
            ModelProvider.icon.label("provider_icon"),
            ModelProvider.color.label("provider_color"),
            func.count(Agent.id).label("usage_count"),
        )
        .join(ModelProvider, Model.provider_id == ModelProvider.id)
        .outerjoin(Agent, Agent.model_id == Model.id)
        .filter(Agent.tenant_id == current_user.tenant_id)
        .group_by(
            Model.id,
            Model.name,
            Model.type,
            ModelProvider.id,
            ModelProvider.name,
            ModelProvider.icon,
            ModelProvider.color,
        )
        .order_by(desc("usage_count"))
        .limit(5)
        .all()
    )
    popular_models = [
        {
            "id": model.id,
            "name": model.name,
            "type": model.type,
            "usage_count": model.usage_count,
            "provider": {
                "id": model.provider_id,
                "name": model.provider_name,
                "icon": model.provider_icon,
                "color": model.provider_color,
            },
        }
        for model in popular_models_query
    ]
    popular_agents_query = (
        db.query(Agent, func.count(ChatMessage.id).label("user_count"))
        .outerjoin(ChatMessage, Agent.id == ChatMessage.agent_id)
        .filter(Agent.status == "online", Agent.tenant_id == current_user.tenant_id)
        .group_by(Agent.id)
        .order_by(desc("user_count"))
        .limit(5)
        .all()
    )
    popular_agents = [
        {"id": agent.id, "name": agent.name, "model_id": agent.model_id, "user_count": user_count}
        for agent, user_count in popular_agents_query
    ]
    recent_activities = []
    try:
        recent_logs = (
            db.query(AuditLog, User.name)
            .outerjoin(User, AuditLog.user_id == User.id)
            .filter(AuditLog.tenant_id == current_user.tenant_id)
            .order_by(desc(AuditLog.created_at))
            .limit(10)
            .all()
        )
        action_colors = {
            "create": "green",
            "update": "blue",
            "delete": "red",
            "login": "purple",
            "logout": "gray",
            "execute": "yellow",
        }
        action_text_map = {
            "create": "创建",
            "update": "更新",
            "delete": "删除",
            "login": "登录",
            "logout": "登出",
            "execute": "执行",
            "read": "查看",
        }
        resource_text_map = {
            "agent": "智能体",
            "knowledge_base": "知识库",
            "user": "用户",
            "tenant": "租户",
            "provider": "模型提供商",
            "model": "模型",
            "document": "文档",
            "category": "分类",
        }
        for log, username in recent_logs:
            time_diff = datetime.utcnow() - log.created_at
            if time_diff.total_seconds() < 60:
                time_ago = f"{int(time_diff.total_seconds())}秒前"
            elif time_diff.total_seconds() < 3600:
                time_ago = f"{int(time_diff.total_seconds() / 60)}分钟前"
            elif time_diff.total_seconds() < 86400:
                time_ago = f"{int(time_diff.total_seconds() / 3600)}小时前"
            else:
                time_ago = f"{int(time_diff.total_seconds() / 86400)}天前"
            action_text = action_text_map.get(log.action, log.action)
            resource_text = resource_text_map.get(log.resource_type, log.resource_type)
            user_text = username or "系统"
            activity_text = f"{user_text} {action_text}了{resource_text}"
            recent_activities.append(
                {
                    "text": activity_text,
                    "time_ago": time_ago,
                    "color": action_colors.get(log.action, "blue"),
                    "created_at": log.created_at.isoformat() if log.created_at else None,
                }
            )
    except Exception as e:
        db.rollback()
        logger.warning(f"Failed to fetch recent activities: {e}")
        recent_activities = []
    return {
        "total_users": total_users,
        "online_users": 0,
        "verified_users": db.query(User).filter(User.is_verified).count(),
        "admin_users": db.query(User)
        .filter(User.role.in_(["platform_admin", "customer_admin"]))
        .count(),
        "popular_models": popular_models,
        "popular_agents": popular_agents,
        "recent_activities": recent_activities,
    }