from __future__ import annotations

from fastapi import APIRouter, Depends, HTTPException, Query, status
from pydantic import BaseModel

from app.core.config import Settings, get_settings
from app.core.security import AuthUser, get_current_user
from app.services import conversations as svc

router = APIRouter(tags=["conversations"])


class CreateReq(BaseModel):
    course: str | None = None
    title: str | None = None


class PatchReq(BaseModel):
    title: str | None = None
    pinned: bool | None = None
    archived: bool | None = None
    course: str | None = None


class FeedbackReq(BaseModel):
    feedback: str | None  # up | down | null


@router.get("/conversations")
async def list_conversations(q: str | None = None, archived: bool = False,
                             limit: int = Query(50, le=200), offset: int = 0,
                             auth: AuthUser = Depends(get_current_user)) -> list[dict]:
    return await svc.list_conversations(auth.id, q, archived, limit, offset)


@router.post("/conversations", status_code=201)
async def create(req: CreateReq, auth: AuthUser = Depends(get_current_user),
                 settings: Settings = Depends(get_settings)) -> dict:
    course = (req.course or settings.courses[0]).upper()
    if course not in settings.courses:
        raise HTTPException(status.HTTP_400_BAD_REQUEST, detail="Cours inconnu.")
    return await svc.create_conversation(auth.id, course, req.title)


@router.get("/conversations/{conv_id}")
async def get(conv_id: str, auth: AuthUser = Depends(get_current_user)) -> dict:
    data = await svc.get_conversation_full(conv_id, auth.id)
    if not data:
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Conversation introuvable.")
    return data


@router.patch("/conversations/{conv_id}")
async def patch(conv_id: str, req: PatchReq, auth: AuthUser = Depends(get_current_user)) -> dict:
    data = await svc.update_conversation(conv_id, auth.id, title=req.title, pinned=req.pinned,
                                         archived=req.archived,
                                         course_code=req.course.upper() if req.course else None)
    if not data:
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Conversation introuvable.")
    return data


@router.delete("/conversations/{conv_id}")
async def delete(conv_id: str, auth: AuthUser = Depends(get_current_user)) -> dict:
    if not await svc.delete_conversation(conv_id, auth.id):
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Conversation introuvable.")
    return {"ok": True}


@router.post("/conversations/{conv_id}/messages/{message_id}/feedback")
async def feedback(conv_id: str, message_id: str, req: FeedbackReq,
                   auth: AuthUser = Depends(get_current_user)) -> dict:
    if req.feedback not in {None, "up", "down"}:
        raise HTTPException(status.HTTP_400_BAD_REQUEST, detail="feedback invalide")
    if not await svc.set_feedback(message_id, auth.id, req.feedback):
        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Message introuvable.")
    return {"ok": True}