from __future__ import annotations import math import hashlib from pathlib import Path from datetime import datetime, timezone from fastapi import APIRouter, HTTPException, Query, status from fastapi.responses import FileResponse from pydantic import BaseModel, Field, model_validator from sqlalchemy import func, select from sakura_cloud.api.deps import CurrentUser, DbSession from sakura_cloud.core.config import settings from sakura_cloud.models.file import FileBlob, UserFile from sakura_cloud.models.mixins import utc_now from sakura_cloud.models.novel import Novel from sakura_cloud.schemas.common import ApiResponse, PageResponse, Pagination from sakura_cloud.schemas.novel import ( BookmarkUpdate, NovelOut, NovelSeriesGroup, NovelViewUpdate, ReadingProgressUpdate, ) router = APIRouter() class NovelBatchDeleteRequest(BaseModel): ids: list[str] = Field(default_factory=list, max_length=200) series_ids: list[str] = Field(default_factory=list, max_length=50) @model_validator(mode="after") def normalize_targets(self) -> "NovelBatchDeleteRequest": self.ids = [item.strip() for item in self.ids if item and item.strip()] self.series_ids = [item.strip() for item in self.series_ids if item and item.strip()] return self class OnlineNovelImportRequest(BaseModel): source_platform: str = Field(max_length=20) title: str = Field(min_length=1, max_length=500) author: str | None = Field(default=None, max_length=200) detail_url: str = Field(min_length=1, max_length=2048) cover_url: str | None = Field(default=None, max_length=2048) content: str = Field(min_length=1, max_length=2_000_000) tags: list[str] = Field(default_factory=list, max_length=50) def _latest_non_null(values: list[datetime | None]) -> datetime | None: normalized = [value for value in values if value is not None] return max(normalized) if normalized else None def _series_group_from_items(series_id: str, items: list[Novel], *, include_chapters: bool = True) -> NovelSeriesGroup: sorted_items = sorted(items, key=lambda item: (item.chapter_order, item.updated_at)) first = sorted_items[0] return NovelSeriesGroup( series_id=series_id, series_title=first.series_title or first.title, author=first.author, chapter_count=len(sorted_items), cover_path=first.cover_path, last_read_at=_latest_non_null([item.last_read_at for item in sorted_items]), last_viewed_at=_latest_non_null([item.last_viewed_at for item in sorted_items]), chapters=[NovelOut.model_validate(item) for item in sorted_items] if include_chapters else [], ) def _resolve_novel_storage_path(novel: Novel, db: DbSession) -> Path: path = Path(novel.file_path or "") if path.is_file(): return path if novel.file_id: user_file = db.get(UserFile, novel.file_id) if user_file is not None: blob = db.get(FileBlob, user_file.file_sha256) if blob is not None: blob_path = Path(blob.storage_path) if blob_path.is_file(): novel.file_path = blob.storage_path novel.file_size = blob.file_size if not novel.cover_path: novel.cover_path = blob.thumbnail_path db.commit() db.refresh(novel) return blob_path raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel file missing from storage") def _online_source_id(detail_url: str) -> str: return hashlib.sha256(detail_url.encode("utf-8")).hexdigest()[:32] def _write_online_novel_file(user_id: str, source_id: str, content: str) -> tuple[str, str, int]: data = content.encode("utf-8") sha256 = hashlib.sha256(data).hexdigest() path = Path(settings.storage_root) / "online_imports" / "novels" / user_id path.mkdir(parents=True, exist_ok=True) target = path / f"{source_id}-{sha256[:12]}.txt" if not target.exists(): target.write_bytes(data) return str(target), sha256, len(data) def _ensure_storage_quota(current_user: CurrentUser, incoming_size: int) -> None: size = max(0, incoming_size) if size and current_user.storage_used + size > current_user.storage_limit: raise HTTPException(status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE, detail="Storage quota exceeded") @router.get("", response_model=ApiResponse[PageResponse[NovelOut]]) def list_novels( current_user: CurrentUser, db: DbSession, page: int = Query(default=1, ge=1), limit: int = Query(default=30, ge=1, le=100), search: str | None = None, is_favorite: bool | None = None, ) -> ApiResponse[PageResponse[NovelOut]]: query = select(Novel).where(Novel.user_id == current_user.id) count_query = select(func.count()).select_from(Novel).where(Novel.user_id == current_user.id) if search: if db.bind is not None and db.bind.dialect.name == "postgresql": vector = func.to_tsvector("simple", func.concat_ws(" ", Novel.title, Novel.author, Novel.description)) condition = vector.op("@@")(func.plainto_tsquery("simple", search)) else: condition = Novel.title.ilike(f"%{search}%") | Novel.author.ilike(f"%{search}%") query = query.where(condition) count_query = count_query.where(condition) if is_favorite is not None: query = query.where(Novel.is_favorite == is_favorite) count_query = count_query.where(Novel.is_favorite == is_favorite) total = int(db.scalar(count_query) or 0) rows = db.scalars( query.order_by(Novel.last_viewed_at.desc().nullslast(), Novel.updated_at.desc()) .offset((page - 1) * limit) .limit(limit) ).all() data = PageResponse( items=[NovelOut.model_validate(row) for row in rows], pagination=Pagination(page=page, limit=limit, total=total, pages=math.ceil(total / limit) if total else 0), ) return ApiResponse(data=data) @router.get("/continue-reading", response_model=ApiResponse[list[NovelOut]]) def continue_reading(current_user: CurrentUser, db: DbSession) -> ApiResponse[list[NovelOut]]: rows = db.scalars( select(Novel) .where(Novel.user_id == current_user.id, Novel.last_read_at.is_not(None)) .order_by(Novel.last_read_at.desc()) .limit(20) ).all() return ApiResponse(data=[NovelOut.model_validate(row) for row in rows]) @router.get("/recent", response_model=ApiResponse[list[NovelOut]]) def recent_novels( current_user: CurrentUser, db: DbSession, limit: int = Query(default=20, ge=1, le=100), ) -> ApiResponse[list[NovelOut]]: rows = db.scalars( select(Novel) .where(Novel.user_id == current_user.id, Novel.last_viewed_at.is_not(None)) .order_by(Novel.last_viewed_at.desc()) .limit(limit) ).all() return ApiResponse(data=[NovelOut.model_validate(row) for row in rows]) @router.get("/series", response_model=ApiResponse[list[NovelSeriesGroup]]) def list_novel_series( current_user: CurrentUser, db: DbSession, include_chapters: bool = Query(default=True), ) -> ApiResponse[list[NovelSeriesGroup]]: # Mobile shelf uses include_chapters=false to avoid loading every chapter for every series. # The exact series catalog is fetched later by /series/{series_id}. if not include_chapters: rows = db.execute( select( Novel.series_id, func.min(Novel.series_title), func.min(Novel.author), func.count(Novel.id), func.min(Novel.cover_path), func.max(Novel.last_read_at), func.max(Novel.last_viewed_at), func.max(Novel.updated_at), ) .where(Novel.user_id == current_user.id, Novel.series_id.is_not(None)) .group_by(Novel.series_id) .order_by(func.max(Novel.last_viewed_at).desc().nullslast(), func.max(Novel.updated_at).desc()) ).all() return ApiResponse( data=[ NovelSeriesGroup( series_id=str(row[0]), series_title=str(row[1] or "Untitled series"), author=row[2], chapter_count=int(row[3] or 0), cover_path=row[4], last_read_at=row[5], last_viewed_at=row[6], chapters=[], ) for row in rows if row[0] ] ) rows = db.scalars( select(Novel) .where(Novel.user_id == current_user.id, Novel.series_id.is_not(None)) .order_by(Novel.series_title.asc(), Novel.chapter_order.asc(), Novel.updated_at.desc()) ).all() groups: dict[str, list[Novel]] = {} for row in rows: if not row.series_id: continue groups.setdefault(row.series_id, []).append(row) data = [] for series_id, items in groups.items(): data.append(_series_group_from_items(series_id, items, include_chapters=include_chapters)) data.sort(key=lambda item: item.last_viewed_at or item.last_read_at or datetime.min.replace(tzinfo=timezone.utc), reverse=True) return ApiResponse(data=data) @router.get("/series/{series_id}", response_model=ApiResponse[NovelSeriesGroup]) def get_novel_series(series_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelSeriesGroup]: rows = db.scalars( select(Novel) .where( Novel.user_id == current_user.id, Novel.series_id == series_id, ) .order_by(Novel.chapter_order.asc(), Novel.updated_at.desc()) ).all() if not rows: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel series not found") return ApiResponse(data=_series_group_from_items(series_id, rows, include_chapters=True)) @router.post("/import-online", response_model=ApiResponse[NovelOut], status_code=status.HTTP_201_CREATED) def import_online_novel( payload: OnlineNovelImportRequest, current_user: CurrentUser, db: DbSession, ) -> ApiResponse[NovelOut]: source_id = _online_source_id(payload.detail_url) existing = db.scalar( select(Novel).where( Novel.user_id == current_user.id, Novel.source_platform == payload.source_platform, Novel.source_id == source_id, ) ) if existing is not None: return ApiResponse(data=NovelOut.model_validate(existing)) storage_path, sha256, file_size = _write_online_novel_file(current_user.id, source_id, payload.content) blob = db.get(FileBlob, sha256) if blob is None: blob = FileBlob( sha256=sha256, storage_path=storage_path, thumbnail_path=payload.cover_url, file_size=file_size, mime_type="text/plain", ) db.add(blob) user_file = db.scalar(select(UserFile).where(UserFile.user_id == current_user.id, UserFile.file_sha256 == sha256)) if user_file is None: _ensure_storage_quota(current_user, file_size) user_file = UserFile( user_id=current_user.id, file_sha256=sha256, original_name=f"{payload.title[:80]}.txt", ) db.add(user_file) current_user.storage_used += file_size db.flush() novel = Novel( user_id=current_user.id, file_id=user_file.id, source_id=source_id, source_platform=payload.source_platform, title=payload.title.strip(), author=payload.author, file_path=storage_path, file_size=file_size, cover_path=payload.cover_url, word_count=len(payload.content), tags=payload.tags, description=payload.detail_url, ) db.add(novel) db.commit() db.refresh(novel) return ApiResponse(code=201, message="created", data=NovelOut.model_validate(novel)) @router.get("/{novel_id}/content") def get_novel_content(novel_id: str, current_user: CurrentUser, db: DbSession) -> FileResponse: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") path = _resolve_novel_storage_path(novel, db) novel.last_viewed_at = utc_now() db.commit() return FileResponse(path, media_type="text/plain", filename=path.name) @router.get("/{novel_id}", response_model=ApiResponse[NovelOut]) def get_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") novel.last_viewed_at = utc_now() db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel)) @router.delete("/{novel_id}", response_model=ApiResponse[dict[str, bool]]) def delete_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[dict[str, bool]]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") current_user.storage_used = max(0, current_user.storage_used - max(0, novel.file_size)) db.delete(novel) db.commit() return ApiResponse(data={"ok": True}) @router.post("/batch-delete", response_model=ApiResponse[dict[str, int]]) def batch_delete_novels( payload: NovelBatchDeleteRequest, current_user: CurrentUser, db: DbSession, ) -> ApiResponse[dict[str, int]]: ids = sorted({item.strip() for item in payload.ids if item.strip()}) series_ids = sorted({item.strip() for item in payload.series_ids if item.strip()}) if not ids and not series_ids: return ApiResponse(data={"deleted": 0}) rows: list[Novel] = [] if ids: rows.extend( db.scalars( select(Novel).where( Novel.user_id == current_user.id, Novel.id.in_(ids), ) ).all() ) if series_ids: rows.extend( db.scalars( select(Novel).where( Novel.user_id == current_user.id, Novel.series_id.in_(series_ids), ) ).all() ) deleted = 0 released = 0 seen: set[str] = set() for novel in rows: if novel.id in seen: continue seen.add(novel.id) released += max(0, novel.file_size) db.delete(novel) deleted += 1 if deleted: current_user.storage_used = max(0, current_user.storage_used - released) db.commit() return ApiResponse(data={"deleted": deleted}) @router.post("/{novel_id}/favorite", response_model=ApiResponse[NovelOut]) def favorite_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") novel.is_favorite = True db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel)) @router.delete("/{novel_id}/favorite", response_model=ApiResponse[NovelOut]) def unfavorite_novel(novel_id: str, current_user: CurrentUser, db: DbSession) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") novel.is_favorite = False db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel)) @router.post("/{novel_id}/progress", response_model=ApiResponse[NovelOut]) def update_progress( novel_id: str, payload: ReadingProgressUpdate, current_user: CurrentUser, db: DbSession, ) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") novel.current_page = payload.current_page novel.last_read_at = utc_now() novel.last_viewed_at = novel.last_read_at db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel)) @router.post("/{novel_id}/bookmark", response_model=ApiResponse[NovelOut]) def update_bookmark( novel_id: str, payload: BookmarkUpdate, current_user: CurrentUser, db: DbSession, ) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") novel.bookmark = payload.bookmark db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel)) @router.post("/{novel_id}/view", response_model=ApiResponse[NovelOut]) def mark_novel_viewed( novel_id: str, payload: NovelViewUpdate, current_user: CurrentUser, db: DbSession, ) -> ApiResponse[NovelOut]: novel = db.get(Novel, novel_id) if novel is None or novel.user_id != current_user.id: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Novel not found") if payload.viewed: novel.last_viewed_at = utc_now() db.commit() db.refresh(novel) return ApiResponse(data=NovelOut.model_validate(novel))