"""后台管理路由"""
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from sqlalchemy import func as sa_func, distinct
from datetime import datetime, timedelta
from pydantic import BaseModel
from typing import Optional

from database import get_db
from models.user import User
from models.post import Post
from models.comment import Comment
from models.like import Like, Collect
from models.system_config import SystemConfig
from models.category import Category
from routers.auth import get_admin_user, get_current_user

router = APIRouter()

# ---------- 对象存储配置管理（腾讯云COS） ----------

COS_CONFIG_KEYS = [
    {"key": "cos_secret_id", "description": "SecretId"},
    {"key": "cos_secret_key", "description": "SecretKey"},
    {"key": "cos_bucket", "description": "Bucket（如 bianchengshequ-1250000000）"},
    {"key": "cos_region", "description": "Region（如 ap-beijing）"},
    {"key": "cos_custom_domain", "description": "自定义域名（可选，CDN加速域名）"},
]


def get_cos_config_from_db(db: Session) -> dict:
    """从数据库读取COS配置"""
    config = {}
    for item in COS_CONFIG_KEYS:
        row = db.query(SystemConfig).filter(SystemConfig.key == item["key"]).first()
        config[item["key"]] = row.value if row else ""
    return config


class CosConfigUpdate(BaseModel):
    cos_secret_id: str = ""
    cos_secret_key: Optional[str] = None
    cos_bucket: str = ""
    cos_region: str = ""
    cos_custom_domain: str = ""


@router.get("/storage/config")
async def get_storage_config(
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """获取对象存储配置"""
    config = get_cos_config_from_db(db)
    # 脱敏 SecretKey
    secret = config.get("cos_secret_key", "")
    if secret and len(secret) > 6:
        config["cos_secret_key_masked"] = secret[:3] + "*" * (len(secret) - 6) + secret[-3:]
    else:
        config["cos_secret_key_masked"] = "*" * len(secret) if secret else ""
    config.pop("cos_secret_key", None)
    return {"config": config, "fields": COS_CONFIG_KEYS}


@router.put("/storage/config")
async def update_storage_config(
    data: CosConfigUpdate,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """更新对象存储配置"""
    updates = data.dict(exclude_none=True)
    for key, value in updates.items():
        row = db.query(SystemConfig).filter(SystemConfig.key == key).first()
        if row:
            row.value = value
        else:
            desc = next((i["description"] for i in COS_CONFIG_KEYS if i["key"] == key), "")
            db.add(SystemConfig(key=key, value=value, description=desc))
    db.commit()
    return {"message": "配置已保存"}


@router.post("/storage/test")
async def test_storage_connection(
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """测试COS连接"""
    config = get_cos_config_from_db(db)
    secret_id = config.get("cos_secret_id", "")
    secret_key = config.get("cos_secret_key", "")
    bucket = config.get("cos_bucket", "")
    region = config.get("cos_region", "")

    if not all([secret_id, secret_key, bucket, region]):
        raise HTTPException(status_code=400, detail="COS配置不完整，请先填写所有必填项")

    try:
        from qcloud_cos import CosConfig, CosS3Client
        cos_config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key)
        client = CosS3Client(cos_config)
        # 尝试获取bucket信息来验证连接
        client.head_bucket(Bucket=bucket)
        return {"success": True, "message": "连接成功"}
    except ImportError:
        raise HTTPException(status_code=500, detail="服务器未安装 cos-python-sdk-v5 库，请执行 pip install cos-python-sdk-v5")
    except Exception as e:
        raise HTTPException(status_code=400, detail=f"连接失败: {str(e)}")


@router.get("/stats")
async def get_stats(
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """获取管理后台统计数据"""
    today = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)

    # 基础统计
    total_users = db.query(sa_func.count(User.id)).scalar() or 0
    total_posts = db.query(sa_func.count(Post.id)).scalar() or 0
    total_comments = db.query(sa_func.count(Comment.id)).scalar() or 0
    total_likes = db.query(sa_func.count(Like.id)).scalar() or 0

    # 今日新增
    today_users = db.query(sa_func.count(User.id)).filter(User.created_at >= today).scalar() or 0
    today_posts = db.query(sa_func.count(Post.id)).filter(Post.created_at >= today).scalar() or 0

    # 今日活跃（今日有发帖/评论/点赞行为的用户）
    active_post = db.query(distinct(Post.user_id)).filter(Post.created_at >= today)
    active_comment = db.query(distinct(Comment.user_id)).filter(Comment.created_at >= today)
    active_like = db.query(distinct(Like.user_id)).filter(Like.created_at >= today)
    active_ids = set()
    for row in active_post.all():
        active_ids.add(row[0])
    for row in active_comment.all():
        active_ids.add(row[0])
    for row in active_like.all():
        active_ids.add(row[0])
    today_active = len(active_ids)

    # 7日趋势
    user_trend = []
    post_trend = []
    for i in range(6, -1, -1):
        day_start = today - timedelta(days=i)
        day_end = day_start + timedelta(days=1)
        date_str = day_start.strftime("%m-%d")

        u_count = db.query(sa_func.count(User.id)).filter(
            User.created_at >= day_start, User.created_at < day_end
        ).scalar() or 0
        p_count = db.query(sa_func.count(Post.id)).filter(
            Post.created_at >= day_start, Post.created_at < day_end
        ).scalar() or 0

        user_trend.append({"date": date_str, "count": u_count})
        post_trend.append({"date": date_str, "count": p_count})

    # 最近注册用户
    recent_users = db.query(User).order_by(User.created_at.desc()).limit(5).all()
    recent_users_data = [
        {"id": u.id, "username": u.username, "email": u.email, "created_at": str(u.created_at)}
        for u in recent_users
    ]

    # 最近发布帖子
    recent_posts = db.query(Post).order_by(Post.created_at.desc()).limit(5).all()
    recent_posts_data = []
    for p in recent_posts:
        author = db.query(User).filter(User.id == p.user_id).first()
        recent_posts_data.append({
            "id": p.id, "title": p.title,
            "author": author.username if author else "未知",
            "created_at": str(p.created_at),
        })

    return {
        "total_users": total_users,
        "total_posts": total_posts,
        "total_comments": total_comments,
        "total_likes": total_likes,
        "today_users": today_users,
        "today_posts": today_posts,
        "today_active": today_active,
        "user_trend": user_trend,
        "post_trend": post_trend,
        "recent_users": recent_users_data,
        "recent_posts": recent_posts_data,
    }


@router.get("/users")
async def list_users(
    search: str = "",
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """用户管理列表"""
    query = db.query(User)
    if search:
        query = query.filter(User.username.contains(search))

    total = query.count()
    users = query.order_by(User.created_at.desc()).offset((page - 1) * page_size).limit(page_size).all()

    items = []
    for u in users:
        post_count = db.query(sa_func.count(Post.id)).filter(Post.user_id == u.id).scalar() or 0
        comment_count = db.query(sa_func.count(Comment.id)).filter(Comment.user_id == u.id).scalar() or 0
        items.append({
            "id": u.id,
            "username": u.username,
            "email": u.email,
            "avatar": u.avatar or "",
            "is_admin": u.is_admin,
            "is_banned": getattr(u, 'is_banned', False),
            "is_approved": getattr(u, 'is_approved', True),
            "post_count": post_count,
            "comment_count": comment_count,
            "created_at": str(u.created_at),
        })

    return {"items": items, "total": total, "page": page, "page_size": page_size}


@router.put("/users/{user_id}/toggle-admin")
async def toggle_admin(
    user_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """切换用户管理员身份"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if user.id == admin.id:
        raise HTTPException(status_code=400, detail="不能修改自己的管理员状态")
    user.is_admin = not user.is_admin
    db.commit()
    return {"message": f"已{'设为' if user.is_admin else '取消'}管理员", "is_admin": user.is_admin}


@router.put("/users/{user_id}/toggle-ban")
async def toggle_ban(
    user_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """封禁/解封用户"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if user.id == admin.id:
        raise HTTPException(status_code=400, detail="不能封禁自己")
    if user.is_admin:
        raise HTTPException(status_code=400, detail="不能封禁管理员")
    user.is_banned = not user.is_banned
    db.commit()
    return {"message": f"已{'封禁' if user.is_banned else '解封'}该用户", "is_banned": user.is_banned}


@router.put("/users/{user_id}/approve")
async def approve_user(
    user_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """审核通过用户"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if getattr(user, 'is_approved', False):
        raise HTTPException(status_code=400, detail="该用户已通过审核")
    user.is_approved = True
    db.commit()
    return {"message": f"已审核通过用户：{user.username}", "is_approved": True}


@router.put("/users/{user_id}/reject")
async def reject_user(
    user_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """拒绝/撤回用户审核"""
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if user.is_admin:
        raise HTTPException(status_code=400, detail="不能拒绝管理员")
    user.is_approved = False
    db.commit()
    return {"message": f"已拒绝用户：{user.username}", "is_approved": False}


@router.get("/posts")
async def list_posts(
    search: str = "",
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """帖子管理列表"""
    query = db.query(Post)
    if search:
        query = query.filter(Post.title.contains(search))

    total = query.count()
    posts = query.order_by(Post.created_at.desc()).offset((page - 1) * page_size).limit(page_size).all()

    items = []
    for p in posts:
        author = db.query(User).filter(User.id == p.user_id).first()
        like_count = db.query(sa_func.count(Like.id)).filter(Like.post_id == p.id).scalar() or 0
        comment_count = db.query(sa_func.count(Comment.id)).filter(Comment.post_id == p.id).scalar() or 0
        items.append({
            "id": p.id,
            "title": p.title,
            "author": author.username if author else "未知",
            "author_id": p.user_id,
            "category": p.category or "",
            "is_public": p.is_public,
            "like_count": like_count,
            "comment_count": comment_count,
            "view_count": p.view_count,
            "created_at": str(p.created_at),
        })

    return {"items": items, "total": total, "page": page, "page_size": page_size}


@router.delete("/posts/{post_id}")
async def delete_post(
    post_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """管理员删除帖子"""
    post = db.query(Post).filter(Post.id == post_id).first()
    if not post:
        raise HTTPException(status_code=404, detail="帖子不存在")
    # 删除关联数据
    db.query(Comment).filter(Comment.post_id == post_id).delete()
    db.query(Like).filter(Like.post_id == post_id).delete()
    db.query(Collect).filter(Collect.post_id == post_id).delete()
    db.delete(post)
    db.commit()
    return {"message": "删除成功"}


# ---------- 分类管理 ----------

@router.get("/categories")
async def list_categories(
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """获取所有分类（含禁用的）"""
    cats = db.query(Category).order_by(Category.sort_order, Category.id).all()
    return [{"id": c.id, "name": c.name, "sort_order": c.sort_order, "is_active": c.is_active} for c in cats]


class CategoryCreate(BaseModel):
    name: str

class CategoryUpdate(BaseModel):
    name: Optional[str] = None
    sort_order: Optional[int] = None
    is_active: Optional[bool] = None


@router.post("/categories")
async def create_category(
    data: CategoryCreate,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """新增分类"""
    existing = db.query(Category).filter(Category.name == data.name).first()
    if existing:
        raise HTTPException(status_code=400, detail="分类名称已存在")
    max_order = db.query(sa_func.max(Category.sort_order)).scalar() or 0
    cat = Category(name=data.name, sort_order=max_order + 1)
    db.add(cat)
    db.commit()
    db.refresh(cat)
    return {"id": cat.id, "name": cat.name, "sort_order": cat.sort_order, "is_active": cat.is_active}


@router.put("/categories/{cat_id}")
async def update_category(
    cat_id: int,
    data: CategoryUpdate,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """修改分类"""
    cat = db.query(Category).filter(Category.id == cat_id).first()
    if not cat:
        raise HTTPException(status_code=404, detail="分类不存在")
    if data.name is not None:
        dup = db.query(Category).filter(Category.name == data.name, Category.id != cat_id).first()
        if dup:
            raise HTTPException(status_code=400, detail="分类名称已存在")
        cat.name = data.name
    if data.sort_order is not None:
        cat.sort_order = data.sort_order
    if data.is_active is not None:
        cat.is_active = data.is_active
    db.commit()
    return {"id": cat.id, "name": cat.name, "sort_order": cat.sort_order, "is_active": cat.is_active}


@router.delete("/categories/{cat_id}")
async def delete_category(
    cat_id: int,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """删除分类"""
    cat = db.query(Category).filter(Category.id == cat_id).first()
    if not cat:
        raise HTTPException(status_code=404, detail="分类不存在")
    db.delete(cat)
    db.commit()
    return {"message": "删除成功"}


@router.put("/categories/reorder")
async def reorder_categories(
    items: list,
    db: Session = Depends(get_db),
    admin: User = Depends(get_admin_user),
):
    """批量更新分类排序"""
    for item in items:
        cat = db.query(Category).filter(Category.id == item["id"]).first()
        if cat:
            cat.sort_order = item["sort_order"]
    db.commit()
    return {"message": "排序已更新"}


# ---------- 公开分类API（无需管理员权限） ----------

@router.get("/public/categories")
async def get_public_categories(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    """获取启用的分类列表（前台使用）"""
    cats = db.query(Category).filter(Category.is_active == True).order_by(Category.sort_order, Category.id).all()
    return [c.name for c in cats]