from datetime import datetime, timezone

from fastapi import APIRouter, Depends, HTTPException
from sqlmodel import Session, select, func

from ..database import get_session
from ..models import Novel, Chapter
from ..schemas import (
    ChapterCreate,
    ChapterUpdate,
    ChapterRead,
    ChapterList,
    ChapterReorder,
)

router = APIRouter(prefix="/api/novels/{novel_id}/chapters", tags=["chapters"])


def _get_novel_or_404(novel_id: int, session: Session) -> Novel:
    novel = session.get(Novel, novel_id)
    if not novel:
        raise HTTPException(status_code=404, detail="小说不存在")
    return novel


def _get_chapter_or_404(
    chapter_id: int, novel_id: int, session: Session
) -> Chapter:
    chapter = session.get(Chapter, chapter_id)
    if not chapter or chapter.novel_id != novel_id:
        raise HTTPException(status_code=404, detail="章节不存在")
    return chapter


@router.get("", response_model=ChapterList)
def list_chapters(
    novel_id: int,
    session: Session = Depends(get_session),
):
    _get_novel_or_404(novel_id, session)
    total = session.exec(
        select(func.count(Chapter.id)).where(Chapter.novel_id == novel_id)
    ).one()
    items = session.exec(
        select(Chapter)
        .where(Chapter.novel_id == novel_id)
        .order_by(Chapter.sort_order)
    ).all()
    return ChapterList(
        items=[ChapterRead.model_validate(c, from_attributes=True) for c in items],
        total=total,
    )


@router.post("", response_model=ChapterRead, status_code=201)
def create_chapter(
    novel_id: int,
    data: ChapterCreate,
    session: Session = Depends(get_session),
):
    _get_novel_or_404(novel_id, session)
    max_order = session.exec(
        select(func.max(Chapter.sort_order)).where(Chapter.novel_id == novel_id)
    ).one()
    next_order = (max_order or 0) + 1

    chapter = Chapter(novel_id=novel_id, sort_order=next_order, **data.model_dump())
    session.add(chapter)
    session.commit()
    session.refresh(chapter)
    return chapter


@router.put("/reorder", response_model=ChapterList)
def reorder_chapters(
    novel_id: int,
    data: ChapterReorder,
    session: Session = Depends(get_session),
):
    _get_novel_or_404(novel_id, session)
    now = datetime.now(timezone.utc)
    for idx, cid in enumerate(data.ordered_ids):
        chapter = _get_chapter_or_404(cid, novel_id, session)
        chapter.sort_order = idx + 1
        chapter.updated_at = now
        session.add(chapter)
    session.commit()

    items = session.exec(
        select(Chapter)
        .where(Chapter.novel_id == novel_id)
        .order_by(Chapter.sort_order)
    ).all()
    total = len(items)
    return ChapterList(
        items=[ChapterRead.model_validate(c, from_attributes=True) for c in items],
        total=total,
    )


@router.get("/{chapter_id}", response_model=ChapterRead)
def get_chapter(
    novel_id: int,
    chapter_id: int,
    session: Session = Depends(get_session),
):
    return _get_chapter_or_404(chapter_id, novel_id, session)


@router.patch("/{chapter_id}", response_model=ChapterRead)
def update_chapter(
    novel_id: int,
    chapter_id: int,
    data: ChapterUpdate,
    session: Session = Depends(get_session),
):
    chapter = _get_chapter_or_404(chapter_id, novel_id, session)
    update_data = data.model_dump(exclude_unset=True)
    for key, value in update_data.items():
        setattr(chapter, key, value)
    chapter.updated_at = datetime.now(timezone.utc)
    session.add(chapter)
    session.commit()
    session.refresh(chapter)
    return chapter


@router.delete("/{chapter_id}", status_code=204)
def delete_chapter(
    novel_id: int,
    chapter_id: int,
    session: Session = Depends(get_session),
):
    chapter = _get_chapter_or_404(chapter_id, novel_id, session)
    session.delete(chapter)
    session.commit()