"""记忆 API。"""

from fastapi import APIRouter, Depends, Header, Query, Request

from app.api.v1.deps import get_current_user
from app.schemas.auth import CurrentUser
from app.schemas.common import Page
from app.schemas.memory import MemoryCreateRequest, MemoryResponse, MemoryUpdateRequest
from app.services.idempotency import run_idempotent
from app.services.memory import create_memory, delete_memory, list_memory_page, update_memory

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


@router.get("", response_model=Page[MemoryResponse])
async def list_memory(
    page: int = Query(default=1, ge=1),
    page_size: int = Query(default=20, ge=1, le=100),
    memory_type: str | None = Query(
        default=None,
        alias="type",
        description="按类型过滤（如 user/assistant/system，契约字典 memory.type）。",
    ),
    source: str | None = Query(
        default=None,
        description="按来源过滤（如 user_explicit/big_cycle/import，契约字典 memory.source）。",
    ),
    current_user: CurrentUser = Depends(get_current_user),
) -> Page[MemoryResponse]:
    return await list_memory_page(
        page=page,
        page_size=page_size,
        memory_type=memory_type,
        source=source,
        owner_scope=current_user.owner_scope,
    )


@router.post("", response_model=MemoryResponse)
async def create_memory_api(
    payload: MemoryCreateRequest,
    request: Request,
    idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"),
    current_user: CurrentUser = Depends(get_current_user),
) -> MemoryResponse:
    return await run_idempotent(
        key=idempotency_key,
        method="POST",
        path=str(request.url.path),
        payload=payload,
        response_type=MemoryResponse,
        resource_type="memory",
        handler=lambda session: create_memory(
            session, payload, owner_scope=current_user.owner_scope
        ),
    )


@router.patch("/{memory_id}", response_model=MemoryResponse)
async def update_memory_api(
    memory_id: str,
    payload: MemoryUpdateRequest,
    current_user: CurrentUser = Depends(get_current_user),
) -> MemoryResponse:
    return await update_memory(memory_id, payload, owner_scope=current_user.owner_scope)


@router.delete("/{memory_id}", response_model=MemoryResponse)
async def delete_memory_api(
    memory_id: str,
    current_user: CurrentUser = Depends(get_current_user),
) -> MemoryResponse:
    return await delete_memory(memory_id, owner_scope=current_user.owner_scope)