import uuid
from typing import Annotated

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

from app.api.deps import get_current_user
from app.database import get_db
from app.models.user import User
from app.schemas.memory import (
    CreateMemoryRequest,
    MemoryEntryListResponse,
    MemoryEntryResponse,
    UpdateMemoryRequest,
)
from app.services import memory_service

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


@router.post("/", response_model=MemoryEntryResponse, status_code=status.HTTP_201_CREATED)
async def create_memory(
    data: CreateMemoryRequest,
    user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    entry = await memory_service.create_memory(db, user.id, **data.model_dump())
    return MemoryEntryResponse.model_validate(entry)


@router.get("/", response_model=MemoryEntryListResponse)
async def list_memories(
    user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
    category: str | None = Query(default=None),
    importance: str | None = Query(default=None),
    is_active: bool | None = Query(default=None),
):
    entries = await memory_service.get_user_memories(db, user.id, category, importance, is_active)
    return MemoryEntryListResponse(entries=[MemoryEntryResponse.model_validate(e) for e in entries])


@router.get("/{entry_id}", response_model=MemoryEntryResponse)
async def get_memory(
    entry_id: uuid.UUID,
    user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    entry = await memory_service.get_memory(db, entry_id, user.id)
    return MemoryEntryResponse.model_validate(entry)


@router.patch("/{entry_id}", response_model=MemoryEntryResponse)
async def update_memory(
    entry_id: uuid.UUID,
    data: UpdateMemoryRequest,
    user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    entry = await memory_service.update_memory(db, entry_id, user.id, **data.model_dump(exclude_unset=True))
    return MemoryEntryResponse.model_validate(entry)


@router.delete("/{entry_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_memory(
    entry_id: uuid.UUID,
    user: Annotated[User, Depends(get_current_user)],
    db: Annotated[AsyncSession, Depends(get_db)],
):
    await memory_service.delete_memory(db, entry_id, user.id)