"""GET /api/messages — chat timeline list (WeChat + WhatsApp).

Read-only query over the mirrored ``message`` table. Filters:

* ``channel``              — ``wechat`` / ``whatsapp``.
* ``owner_account_id``     — owning staff account (wxId / uid).
* ``talker_id`` (1:1) OR ``room_id`` (group) — the conversation anchor. Both
  may be supplied (AND), but typically the frontend sends exactly one.
* ``start`` / ``end``      — ms-epoch window compared against ``timestamp``
  (inclusive on both ends).

Ordered by ``timestamp asc`` so the timeline renders oldest-first. The index
``ix_message_channel_owner_talker_time`` covers the hot path
``(channel, owner_account_id, talker_id, timestamp)``.
"""

from __future__ import annotations

from typing import Annotated

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

from app.api.deps import get_session
from app.api.schemas import MessageOut, Page
from app.db.models import Message

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

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


@router.get("/messages")
async def list_messages(
    session: SessionDep,
    page: PageParam = 1,
    page_size: PageSizeParam = 50,
    channel: Annotated[str | None, Query()] = None,
    owner_account_id: Annotated[str | None, Query()] = None,
    talker_id: Annotated[str | None, Query()] = None,
    room_id: Annotated[str | None, Query()] = None,
    start: Annotated[int | None, Query(ge=0)] = None,
    end: Annotated[int | None, Query(ge=0)] = None,
) -> Page[MessageOut]:
    """List messages for a timeline (ordered by ``timestamp asc``)."""
    conditions = []
    if channel is not None:
        conditions.append(Message.channel == channel)
    if owner_account_id is not None:
        conditions.append(Message.owner_account_id == owner_account_id)
    if talker_id is not None:
        conditions.append(Message.talker_id == talker_id)
    if room_id is not None:
        conditions.append(Message.room_id == room_id)
    if start is not None:
        conditions.append(Message.timestamp >= start)
    if end is not None:
        conditions.append(Message.timestamp <= end)

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

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