"""GET /api/groups, /api/groups/{room_id}/members — chat-group browse endpoints.

* ``GET /api/groups`` -> ``Page[GroupOut]`` filtered by ``channel`` /
  ``owner_account_id`` / ``user_id`` (the latter mapping to the
  ``owner_user_id`` column), ordered by ``last_chat_time desc`` (nulls last)
  so recently-active groups surface first.
* ``GET /api/groups/{room_id}/members`` -> ``list[GroupMemberOut]`` — the
  members of a single group (small set, no pagination needed).
"""

from __future__ import annotations

from typing import Annotated

import sqlalchemy as sa
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.ext.asyncio import AsyncSession

from app.api.deps import get_session
from app.api.schemas import GroupMemberOut, GroupOut, Page
from app.db.models import ChatGroup, GroupMember

router = APIRouter(prefix="/api", tags=["groups"])

SessionDep = Annotated[AsyncSession, Depends(get_session)]
PageParam = Annotated[int, Query(ge=1)]
PageSizeParam = Annotated[int, Query(ge=1, le=100)]


@router.get("/groups")
async def list_groups(
    session: SessionDep,
    page: PageParam = 1,
    page_size: PageSizeParam = 20,
    channel: Annotated[str | None, Query()] = None,
    owner_account_id: Annotated[str | None, Query()] = None,
    user_id: Annotated[str | None, Query()] = None,
) -> Page[GroupOut]:
    """List chat groups with optional ``channel`` / ``owner_account_id`` /
    ``user_id`` filters.

    ``user_id`` maps to the ``ChatGroup.owner_user_id`` column (the staff
    ``userId`` who owns the chatroom account), mirroring the ``user_id``
    filter on ``GET /api/customers``.
    """
    conditions = []
    if channel is not None:
        conditions.append(ChatGroup.channel == channel)
    if owner_account_id is not None:
        conditions.append(ChatGroup.owner_account_id == owner_account_id)
    if user_id is not None:
        conditions.append(ChatGroup.owner_user_id == user_id)

    total_stmt = sa.select(sa.func.count()).select_from(ChatGroup)
    if conditions:
        total_stmt = total_stmt.where(*conditions)
    total = (await session.execute(total_stmt)).scalar_one()

    list_stmt = sa.select(ChatGroup)
    if conditions:
        list_stmt = list_stmt.where(*conditions)
    list_stmt = (
        list_stmt.order_by(
            sa.nullslast(ChatGroup.last_chat_time.desc()),
            ChatGroup.room_id.asc(),
        )
        .limit(page_size)
        .offset((page - 1) * page_size)
    )
    rows = (await session.execute(list_stmt)).scalars().all()
    items = [GroupOut.model_validate(row) for row in rows]
    return Page(items=items, total=total, page=page, page_size=page_size)


@router.get("/groups/{room_id}/members")
async def list_group_members(
    room_id: str, session: SessionDep
) -> list[GroupMemberOut]:
    """Return the members of a single group (plain list).

    Ordered by ``member_id`` for stable rendering. Returns ``404`` when no such
    group exists so the frontend can distinguish "missing room" from "empty
    room".
    """
    exists = (
        await session.execute(
            sa.select(sa.func.count())
            .select_from(ChatGroup)
            .where(ChatGroup.room_id == room_id)
        )
    ).scalar_one()
    if not exists:
        raise HTTPException(status_code=404, detail="group not found")

    stmt = (
        sa.select(GroupMember)
        .where(GroupMember.room_id == room_id)
        .order_by(GroupMember.member_id.asc())
    )
    rows = (await session.execute(stmt)).scalars().all()
    return [GroupMemberOut.model_validate(row) for row in rows]