from uuid import UUID

from fastapi import APIRouter, Depends, Query
from sqlalchemy import select
from sqlalchemy.orm import Session

from app.db.session import get_db
from app.models.indexing import Chunk, IndexPublication, IndexVersion
from app.schemas.catalog import Page
from app.schemas.indexing import (
    ActiveIndex,
    BuildIndex,
    ChunkRead,
    IndexRead,
    PublicationRead,
    PublishIndex,
)
from app.services.auth import CurrentSession, require_admin
from app.services.catalog import page_result
from app.services.indexing import active_index, build_index, publish_index, version_or_404

router = APIRouter(prefix="/indexes", tags=["indexes"], dependencies=[Depends(require_admin)])


@router.post("", response_model=IndexRead, status_code=201)
def build(
    payload: BuildIndex,
    current: CurrentSession = Depends(require_admin),
    db: Session = Depends(get_db),
):
    return build_index(db, payload, current.user.id)


@router.get("", response_model=Page[IndexRead])
def list_versions(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    return page_result(
        db,
        select(IndexVersion).order_by(IndexVersion.created_at.desc(), IndexVersion.id),
        page,
        page_size,
    )


@router.get("/active", response_model=ActiveIndex)
def active(db: Session = Depends(get_db)):
    return active_index(db)


@router.get("/publications", response_model=Page[PublicationRead])
def publications(
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    return page_result(
        db, select(IndexPublication).order_by(IndexPublication.generation.desc()), page, page_size
    )


@router.get("/{version_id}", response_model=IndexRead)
def read_version(version_id: UUID, db: Session = Depends(get_db)):
    return version_or_404(db, str(version_id))


@router.post("/{version_id}/publish", response_model=ActiveIndex)
def publish(
    version_id: UUID,
    payload: PublishIndex,
    current: CurrentSession = Depends(require_admin),
    db: Session = Depends(get_db),
):
    return publish_index(db, version_id, payload.expected_generation, current.user.id)


@router.get("/{version_id}/chunks", response_model=Page[ChunkRead])
def chunks(
    version_id: UUID,
    knowledge_id: int | None = Query(None, gt=0),
    page: int = Query(1, ge=1),
    page_size: int = Query(20, ge=1, le=100),
    db: Session = Depends(get_db),
):
    version_or_404(db, str(version_id))
    statement = select(Chunk).where(Chunk.index_version_id == str(version_id))
    if knowledge_id is not None:
        statement = statement.where(Chunk.knowledge_id == knowledge_id)
    return page_result(db, statement.order_by(Chunk.knowledge_id, Chunk.ordinal), page, page_size)