"""Document management endpoints."""

from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
from fastapi.responses import FileResponse
from sqlalchemy.orm import Session
from sqlalchemy import desc
from datetime import datetime, timezone

from app.auth.dependencies import get_current_user, verify_csrf
from app.db import get_db
from app.models.document import Document
from app.models.annotation_state import AnnotationState
from app.models.version import Version
from app.schemas.document import (
    DocumentListResponse, DocumentMeta, BulkDeleteRequest, 
    BulkRestoreRequest, DocumentUpdateRequest
)
from app.services.storage import save_upload_file, delete_pdf_file
from app.services.thumbnails import generate_thumbnail, delete_thumbnail
from app.config import settings

router = APIRouter(
    prefix="/documents", 
    tags=["documents"],
    dependencies=[Depends(get_current_user)]
)


@router.get("", response_model=DocumentListResponse)
def list_documents(
    query: str = "",
    skip: int = Query(0, ge=0),
    limit: int = Query(50, ge=1, le=100),
    db: Session = Depends(get_db)
):
    """List non-trashed documents."""
    q = db.query(Document).filter(Document.deleted_at.is_(None))
    if query:
        q = q.filter(Document.title.ilike(f"%{query}%"))
        
    total = q.count()
    items = q.order_by(desc(Document.updated_at)).offset(skip).limit(limit).all()
    
    return DocumentListResponse(items=items, total=total)


@router.get("/trash", response_model=DocumentListResponse)
def list_trash(
    skip: int = Query(0, ge=0),
    limit: int = Query(50, ge=1, le=100),
    db: Session = Depends(get_db)
):
    """List trashed documents."""
    q = db.query(Document).filter(Document.deleted_at.is_not(None))
    total = q.count()
    items = q.order_by(desc(Document.deleted_at)).offset(skip).limit(limit).all()
    return DocumentListResponse(items=items, total=total)


@router.post("", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
async def upload_document(
    file: UploadFile = File(...),
    db: Session = Depends(get_db)
):
    """Upload a new PDF document."""
    # Note: Starlette/FastAPI loads file into memory/spooled file.
    # To truly enforce max size before reading we rely on Nginx and logic in storage.py.
    # But checking size if available:
    if file.size and file.size > settings.MAX_UPLOAD_MB * 1024 * 1024:
        raise HTTPException(status_code=413, detail="File too large")
        
    file_id, size_bytes, page_count = await save_upload_file(file)
    
    # Generate thumbnail synchronously
    generate_thumbnail(file_id)
    
    now = datetime.now(timezone.utc).isoformat()
    doc = Document(
        id=file_id,
        title=file.filename or "Untitled",
        original_filename=file.filename or "Untitled.pdf",
        file_path=str(settings.PDF_STORAGE_PATH / f"{file_id}.pdf"),
        page_count=page_count,
        size_bytes=size_bytes,
        created_at=now,
        updated_at=now
    )
    db.add(doc)
    db.commit()
    db.refresh(doc)
    return doc


@router.get("/{id}", response_model=DocumentMeta)
def get_document(id: str, db: Session = Depends(get_db)):
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
    return doc


@router.patch("/{id}", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
def update_document(id: str, update: DocumentUpdateRequest, db: Session = Depends(get_db)):
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
        
    if update.title is not None:
        doc.title = update.title
        
    if update.in_trash is not None:
        if update.in_trash:
            doc.deleted_at = datetime.now(timezone.utc).isoformat()
        else:
            doc.deleted_at = None
            
    doc.updated_at = datetime.now(timezone.utc).isoformat()
    db.commit()
    db.refresh(doc)
    return doc


@router.delete("/{id}", dependencies=[Depends(verify_csrf)])
def delete_document(id: str, permanent: bool = False, db: Session = Depends(get_db)):
    """Soft delete by default. Hard delete if permanent=True AND already in trash."""
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
        
    if permanent:
        if doc.deleted_at is None:
            raise HTTPException(status_code=400, detail="Must be in trash to delete permanently")
        
        # Hard delete
        delete_pdf_file(doc.id)
        delete_thumbnail(doc.id)
        db.query(AnnotationState).filter(AnnotationState.document_id == doc.id).delete()
        db.query(Version).filter(Version.document_id == doc.id).delete()
        db.delete(doc)
        db.commit()
        return {"status": "deleted"}
    else:
        # Soft delete
        doc.deleted_at = datetime.now(timezone.utc).isoformat()
        db.commit()
        return {"status": "trashed"}


@router.post("/{id}/restore", dependencies=[Depends(verify_csrf)], response_model=DocumentMeta)
def restore_document(id: str, db: Session = Depends(get_db)):
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
        
    doc.deleted_at = None
    doc.updated_at = datetime.now(timezone.utc).isoformat()
    db.commit()
    db.refresh(doc)
    return doc


@router.post("/bulk-delete", dependencies=[Depends(verify_csrf)])
def bulk_delete(data: BulkDeleteRequest, db: Session = Depends(get_db)):
    now = datetime.now(timezone.utc).isoformat()
    db.query(Document).filter(Document.id.in_(data.ids)).update({
        Document.deleted_at: now
    }, synchronize_session=False)
    db.commit()
    return {"status": "ok", "count": len(data.ids)}


@router.post("/bulk-restore", dependencies=[Depends(verify_csrf)])
def bulk_restore(data: BulkRestoreRequest, db: Session = Depends(get_db)):
    now = datetime.now(timezone.utc).isoformat()
    db.query(Document).filter(Document.id.in_(data.ids)).update({
        Document.deleted_at: None,
        Document.updated_at: now
    }, synchronize_session=False)
    db.commit()
    return {"status": "ok", "count": len(data.ids)}


@router.post("/trash/empty", dependencies=[Depends(verify_csrf)])
def empty_trash(db: Session = Depends(get_db)):
    docs = db.query(Document).filter(Document.deleted_at.is_not(None)).all()
    count = 0
    for doc in docs:
        delete_pdf_file(doc.id)
        delete_thumbnail(doc.id)
        db.query(AnnotationState).filter(AnnotationState.document_id == doc.id).delete()
        db.query(Version).filter(Version.document_id == doc.id).delete()
        db.delete(doc)
        count += 1
    db.commit()
    return {"status": "ok", "deleted": count}


@router.get("/{id}/file")
def get_document_file(id: str, db: Session = Depends(get_db)):
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
        
    path = settings.PDF_STORAGE_PATH / f"{doc.id}.pdf"
    if not path.exists():
        raise HTTPException(status_code=404, detail="File missing")
        
    return FileResponse(path, media_type="application/pdf", filename=doc.filename)


@router.get("/{id}/thumbnail")
def get_document_thumbnail(id: str, db: Session = Depends(get_db)):
    doc = db.query(Document).filter(Document.id == id).first()
    if not doc:
        raise HTTPException(status_code=404, detail="Document not found")
        
    path = settings.THUMBNAILS_PATH / f"{doc.id}.png"
    if not path.exists():
        raise HTTPException(status_code=404, detail="Thumbnail missing")
        
    return FileResponse(path, media_type="image/png")