from __future__ import annotations

from datetime import datetime, timezone
from typing import Any

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

from app.enums.team import TeamStatus
from app.enums.user import UserType
from app.models.team import Team
from app.models.user import User
from app.schemas.team import TeamCreate, TeamUpdate
from app.utils.id_gen import generate_id


def _clean_text(value: str | None) -> str | None:
    if value is None:
        return None
    value = value.strip()
    return value or None


def _team_snapshot(team: Team | None) -> dict[str, Any]:
    if not team:
        return {"team_id": None, "team_name": None}
    return {
        "team_id": team.id,
        "team_name": getattr(team, "name", None),
    }


def _team_out_payload(team: Team, member_count: int = 0, manager_name: str | None = None) -> dict[str, Any]:
    return {
        "id": team.id,
        "name": team.name,
        "code": getattr(team, "code", None),
        "description": getattr(team, "description", None),
        "status": getattr(team, "status", TeamStatus.ACTIVE.value),
        "sort_order": getattr(team, "sort_order", 0) or 0,
        "member_count": int(member_count or 0),
        "created_at": team.created_at,
        "updated_at": team.updated_at,
        "manager_id": getattr(team, "manager_id", None),
        "manager_name": manager_name,
    }


async def _get_team(db: AsyncSession, team_id: str, *, include_deleted: bool = False) -> Team | None:
    query = select(Team).where(Team.id == team_id).limit(1)
    if not include_deleted:
        query = query.where(Team.deleted_at.is_(None))
    result = await db.execute(query)
    return result.scalar_one_or_none()


async def _get_team_name(db: AsyncSession, team_id: str | None) -> str | None:
    if not team_id:
        return None
    result = await db.execute(select(Team.name).where(Team.id == team_id).limit(1))
    return result.scalar_one_or_none()


async def _assert_unique_team(db: AsyncSession, *, name: str, code: str | None, exclude_id: str | None = None) -> None:
    conditions = [Team.deleted_at.is_(None)]
    duplicate_filters = [Team.name == name]
    if code:
        duplicate_filters.append(Team.code == code)
    conditions.append(or_(*duplicate_filters))
    if exclude_id:
        conditions.append(Team.id != exclude_id)
    result = await db.execute(select(Team.id).where(and_(*conditions)).limit(1))
    if result.scalar_one_or_none():
        raise HTTPException(status_code=400, detail="团队名称或编码已存在")


async def list_teams(
    db: AsyncSession,
    *,
    page: int = 1,
    page_size: int = 20,
    keyword: str | None = None,
    status: str | None = None,
) -> dict[str, Any]:
    page = max(int(page or 1), 1)
    page_size = min(max(int(page_size or 20), 1), 500)

    filters: list[Any] = [Team.deleted_at.is_(None)]
    kw = _clean_text(keyword)
    if kw:
        like = f"%{kw}%"
        filters.append(or_(Team.name.ilike(like), Team.code.ilike(like), Team.description.ilike(like)))
    if status:
        filters.append(Team.status == status)

    where_clause = and_(*filters)
    total = (await db.execute(select(func.count(Team.id)).where(where_clause))).scalar() or 0
    result = await db.execute(
        select(Team)
        .where(where_clause)
        .order_by(Team.sort_order.asc(), Team.created_at.desc(), Team.id.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
    )
    teams = list(result.scalars().all())
    if not teams:
        return {"items": [], "total": total}

    team_ids = [team.id for team in teams]
    member_result = await db.execute(
        select(User.team_id, func.count(User.id))
        .where(User.user_type == UserType.FRONTEND.value, User.team_id.in_(team_ids))
        .group_by(User.team_id)
    )
    member_map = {row[0]: int(row[1] or 0) for row in member_result.all()}

    # 批量获取管理人用户名
    manager_ids = [getattr(t, "manager_id", None) for t in teams if getattr(t, "manager_id", None)]
    manager_name_map: dict[str, str] = {}
    if manager_ids:
        mgr_result = await db.execute(
            select(User.id, User.username).where(User.id.in_(manager_ids))
        )
        manager_name_map = {row[0]: row[1] for row in mgr_result.all()}

    return {
        "items": [
            _team_out_payload(
                team,
                member_map.get(team.id, 0),
                manager_name_map.get(getattr(team, "manager_id", None)),
            )
            for team in teams
        ],
        "total": total,
    }


async def list_team_options(db: AsyncSession, *, include_disabled: bool = True) -> list[dict[str, Any]]:
    filters: list[Any] = [Team.deleted_at.is_(None)]
    if not include_disabled:
        filters.append(Team.status == TeamStatus.ACTIVE.value)
    result = await db.execute(
        select(Team)
        .where(and_(*filters))
        .order_by(Team.sort_order.asc(), Team.created_at.desc(), Team.id.desc())
    )
    return [
        {
            "id": team.id,
            "name": team.name,
            "code": getattr(team, "code", None),
            "status": getattr(team, "status", TeamStatus.ACTIVE.value),
        }
        for team in result.scalars().all()
    ]


async def batch_get_team_name_map(db: AsyncSession, team_ids: list[str] | set[str] | tuple[str, ...]) -> dict[str, str]:
    """Batch load team names for list pages. Avoid joining teams in high-frequency user queries."""
    ids = [team_id for team_id in dict.fromkeys(team_ids or []) if team_id]
    if not ids:
        return {}
    result = await db.execute(
        select(Team.id, Team.name)
        .where(Team.id.in_(ids), Team.deleted_at.is_(None))
    )
    return {row[0]: row[1] for row in result.all()}


async def create_team(db: AsyncSession, req: TeamCreate) -> Team:
    name = req.name.strip()
    code = _clean_text(req.code)
    await _assert_unique_team(db, name=name, code=code)
    team = Team(
        id=generate_id(),
        name=name,
        code=code,
        description=_clean_text(req.description),
        status=req.status or TeamStatus.ACTIVE.value,
        sort_order=req.sort_order or 0,
    )
    db.add(team)
    await db.flush()
    await db.refresh(team)
    return team


async def update_team(db: AsyncSession, team_id: str, req: TeamUpdate) -> tuple[Team, dict[str, Any], dict[str, Any]]:
    team = await _get_team(db, team_id)
    if not team:
        raise HTTPException(status_code=404, detail="团队不存在")

    before = {
        "id": team.id,
        "name": team.name,
        "code": getattr(team, "code", None),
        "description": getattr(team, "description", None),
        "status": getattr(team, "status", TeamStatus.ACTIVE.value),
        "sort_order": getattr(team, "sort_order", 0) or 0,
    }
    name = req.name.strip()
    code = _clean_text(req.code)
    await _assert_unique_team(db, name=name, code=code, exclude_id=team_id)

    team.name = name
    team.code = code
    team.description = _clean_text(req.description)
    team.status = req.status or TeamStatus.ACTIVE.value
    team.sort_order = req.sort_order or 0
    await db.flush()
    await db.refresh(team)

    after = {
        "id": team.id,
        "name": team.name,
        "code": getattr(team, "code", None),
        "description": getattr(team, "description", None),
        "status": getattr(team, "status", TeamStatus.ACTIVE.value),
        "sort_order": getattr(team, "sort_order", 0) or 0,
    }
    return team, before, after


async def soft_delete_team(db: AsyncSession, team_id: str) -> tuple[Team, dict[str, Any]]:
    team = await _get_team(db, team_id)
    if not team:
        raise HTTPException(status_code=404, detail="团队不存在")

    member_count = (await db.execute(
        select(func.count(User.id)).where(
            User.user_type == UserType.FRONTEND.value,
            User.team_id == team_id,
        )
    )).scalar() or 0
    if member_count > 0:
        raise HTTPException(status_code=400, detail="该团队下仍有前台用户，请先迁移或取消团队归属")

    before = {
        "id": team.id,
        "name": team.name,
        "code": getattr(team, "code", None),
        "status": getattr(team, "status", TeamStatus.ACTIVE.value),
        "member_count": int(member_count or 0),
    }
    team.deleted_at = datetime.now(timezone.utc)
    await db.flush()
    return team, before


async def set_frontend_user_team(
    db: AsyncSession,
    *,
    user_id: str,
    team_id: str | None,
) -> tuple[User, dict[str, Any], dict[str, Any]]:
    result = await db.execute(select(User).where(User.id == user_id).limit(1))
    user = result.scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if user.user_type != UserType.FRONTEND.value:
        raise HTTPException(status_code=400, detail="仅前台用户支持设置团队")

    old_team_id = getattr(user, "team_id", None)
    old_team = await _get_team(db, old_team_id, include_deleted=True) if old_team_id else None
    before = _team_snapshot(old_team)

    new_team: Team | None = None
    if team_id:
        new_team = await _get_team(db, team_id)
        if not new_team:
            raise HTTPException(status_code=404, detail="团队不存在")
        if getattr(new_team, "status", TeamStatus.ACTIVE.value) != TeamStatus.ACTIVE.value:
            raise HTTPException(status_code=400, detail="禁用团队不能设置给用户")

    user.team_id = team_id or None
    await db.flush()
    after = _team_snapshot(new_team)
    return user, before, after