SurfSense/surfsense_backend/app/routes/editor_routes.py

"""
Editor routes for BlockNote document editing.
"""

from datetime import UTC, datetime
from typing import Any

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from app.db import Document, DocumentType, Permission, User, get_async_session
from app.users import current_active_user
from app.utils.rbac import check_permission

router = APIRouter()


@router.get("/search-spaces/{search_space_id}/documents/{document_id}/editor-content")
async def get_editor_content(
    search_space_id: int,
    document_id: int,
    session: AsyncSession = Depends(get_async_session),
    user: User = Depends(current_active_user),
):
    """
    Get document content for editing.

    Returns BlockNote JSON document. If blocknote_document is NULL,
    attempts to generate it from chunks (lazy migration).

    Requires DOCUMENTS_READ permission.
    """
    # Check RBAC permission
    await check_permission(
        session,
        user,
        search_space_id,
        Permission.DOCUMENTS_READ.value,
        "You don't have permission to read documents in this search space",
    )

    result = await session.execute(
        select(Document)
        .options(selectinload(Document.chunks))
        .filter(
            Document.id == document_id,
            Document.search_space_id == search_space_id,
        )
    )
    document = result.scalars().first()

    if not document:
        raise HTTPException(status_code=404, detail="Document not found")

    # If blocknote_document exists, return it
    if document.blocknote_document:
        return {
            "document_id": document.id,
            "title": document.title,
            "document_type": document.document_type.value,
            "blocknote_document": document.blocknote_document,
            "updated_at": document.updated_at.isoformat()
            if document.updated_at
            else None,
        }

    # For NOTE type documents, return empty BlockNote structure if no content exists
    if document.document_type == DocumentType.NOTE:
        # Return empty BlockNote structure
        empty_blocknote = [
            {
                "type": "paragraph",
                "content": [],
                "children": [],
            }
        ]
        # Save empty structure if not already saved
        if not document.blocknote_document:
            document.blocknote_document = empty_blocknote
            await session.commit()
        return {
            "document_id": document.id,
            "title": document.title,
            "document_type": document.document_type.value,
            "blocknote_document": empty_blocknote,
            "updated_at": document.updated_at.isoformat()
            if document.updated_at
            else None,
        }

    # Lazy migration: Try to generate blocknote_document from chunks (for other document types)
    from app.utils.blocknote_converter import convert_markdown_to_blocknote

    chunks = sorted(document.chunks, key=lambda c: c.id)

    if not chunks:
        raise HTTPException(
            status_code=400,
            detail="This document has no chunks and cannot be edited. Please re-upload to enable editing.",
        )

    # Reconstruct markdown from chunks
    markdown_content = "\n\n".join(chunk.content for chunk in chunks)

    if not markdown_content.strip():
        raise HTTPException(
            status_code=400,
            detail="This document has empty content and cannot be edited.",
        )

    # Convert to BlockNote
    blocknote_json = await convert_markdown_to_blocknote(markdown_content)

    if not blocknote_json:
        raise HTTPException(
            status_code=500,
            detail="Failed to convert document to editable format. Please try again later.",
        )

    # Save the generated blocknote_document (lazy migration)
    document.blocknote_document = blocknote_json
    document.content_needs_reindexing = False
    await session.commit()

    return {
        "document_id": document.id,
        "title": document.title,
        "document_type": document.document_type.value,
        "blocknote_document": blocknote_json,
        "updated_at": document.updated_at.isoformat() if document.updated_at else None,
    }


@router.post("/search-spaces/{search_space_id}/documents/{document_id}/save")
async def save_document(
    search_space_id: int,
    document_id: int,
    data: dict[str, Any],
    session: AsyncSession = Depends(get_async_session),
    user: User = Depends(current_active_user),
):
    """
    Save BlockNote document and trigger reindexing.
    Called when user clicks 'Save & Exit'.

    Requires DOCUMENTS_UPDATE permission.
    """
    from app.tasks.celery_tasks.document_reindex_tasks import reindex_document_task

    # Check RBAC permission
    await check_permission(
        session,
        user,
        search_space_id,
        Permission.DOCUMENTS_UPDATE.value,
        "You don't have permission to update documents in this search space",
    )

    result = await session.execute(
        select(Document).filter(
            Document.id == document_id,
            Document.search_space_id == search_space_id,
        )
    )
    document = result.scalars().first()

    if not document:
        raise HTTPException(status_code=404, detail="Document not found")

    blocknote_document = data.get("blocknote_document")
    if not blocknote_document:
        raise HTTPException(status_code=400, detail="blocknote_document is required")

    # Add type validation
    if not isinstance(blocknote_document, list):
        raise HTTPException(status_code=400, detail="blocknote_document must be a list")

    # For NOTE type documents, extract title from first block (heading)
    if (
        document.document_type == DocumentType.NOTE
        and blocknote_document
        and len(blocknote_document) > 0
    ):
        first_block = blocknote_document[0]
        if (
            first_block
            and first_block.get("content")
            and isinstance(first_block["content"], list)
        ):
            # Extract text from first block content
            # Match the frontend extractTitleFromBlockNote logic exactly
            title_parts = []
            for item in first_block["content"]:
                if isinstance(item, str):
                    title_parts.append(item)
                elif (
                    isinstance(item, dict)
                    and "text" in item
                    and isinstance(item["text"], str)
                ):
                    # BlockNote structure: {"type": "text", "text": "...", "styles": {}}
                    title_parts.append(item["text"])

            new_title = "".join(title_parts).strip()
            if new_title:
                document.title = new_title
            else:
                # Only set to "Untitled" if content exists but is empty
                document.title = "Untitled"

    # Save BlockNote document
    document.blocknote_document = blocknote_document
    document.updated_at = datetime.now(UTC)
    document.content_needs_reindexing = True

    await session.commit()

    # Queue reindex task
    reindex_document_task.delay(document_id, str(user.id))

    return {
        "status": "saved",
        "document_id": document_id,
        "message": "Document saved and will be reindexed in the background",
        "updated_at": document.updated_at.isoformat(),
    }