from typing import Any

from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from sqlalchemy.orm import Session

from app.db.base import get_db
from app.memory.service import MemoryService

router = APIRouter()


class ProfileUpdate(BaseModel):
    updates: dict[str, Any] = Field(default_factory=dict)


class FactCreate(BaseModel):
    content: str = Field(min_length=1)
    category: str = "fact"
    importance: int = Field(default=3, ge=1, le=5)
    session_id: int | None = None


class SessionSummaryUpdate(BaseModel):
    summary: str = Field(min_length=1)
    message_count: int = 0


@router.get("/memory")
def get_memory_snapshot(
    session_id: int | None = None,
    db: Session = Depends(get_db),
) -> dict[str, Any]:
    return MemoryService(db).snapshot(session_id)


@router.get("/profile")
def get_profile(db: Session = Depends(get_db)) -> dict[str, Any]:
    return MemoryService(db).get_profile()


@router.put("/profile")
def update_profile(
    payload: ProfileUpdate,
    db: Session = Depends(get_db),
) -> dict[str, Any]:
    try:
        return MemoryService(db).update_profile(payload.updates)
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@router.get("/memory/facts")
def list_facts(
    query: str | None = None,
    category: str | None = None,
    limit: int = 30,
    db: Session = Depends(get_db),
) -> list[dict[str, Any]]:
    return MemoryService(db).recall_memories(query=query, category=category, limit=limit)


@router.post("/memory/facts")
def create_fact(
    payload: FactCreate,
    db: Session = Depends(get_db),
) -> dict[str, Any]:
    try:
        return MemoryService(db).remember_fact(
            payload.content,
            category=payload.category,
            session_id=payload.session_id,
            importance=payload.importance,
            source="api",
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc


@router.delete("/memory/facts/{memory_id}")
def forget_fact(memory_id: int, db: Session = Depends(get_db)) -> dict[str, Any]:
    try:
        return MemoryService(db).forget_memory(memory_id)
    except ValueError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@router.put("/memory/sessions/{session_id}/summary")
def update_session_summary(
    session_id: int,
    payload: SessionSummaryUpdate,
    db: Session = Depends(get_db),
) -> dict[str, Any]:
    try:
        return MemoryService(db).update_session_summary(
            session_id,
            payload.summary,
            message_count=payload.message_count,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc)) from exc