from pathlib import Path

from fastapi import APIRouter, Depends, File, Form, Request, UploadFile
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session

from app.core.config import INBOX_ROOT
from app.db.deps import get_db
from app.logic.ingest import ingest_directory, ingest_file, ingest_inbox, ingest_uploaded_file

router = APIRouter(prefix="/ingest", tags=["ingest"])

BASE_DIR = Path(__file__).resolve().parent.parent
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))


@router.get("/", response_class=HTMLResponse)
def ingest_home(request: Request):
    return templates.TemplateResponse(
        request=request,
        name="ingest/index.html",
        context={
            "request": request,
            "inbox_root": INBOX_ROOT,
        },
    )


@router.post("/upload-files", response_class=HTMLResponse)
async def ingest_upload_files(
    request: Request,
    uploaded_files: list[UploadFile] = File(...),
    db: Session = Depends(get_db),
):
    documents = []
    errors = []

    for uploaded_file in uploaded_files:
        try:
            file_bytes = await uploaded_file.read()
            document = ingest_uploaded_file(
                db=db,
                filename=uploaded_file.filename or "upload.pdf",
                file_bytes=file_bytes,
                source_system="upload_ingest",
            )
            documents.append(document)
        except Exception as e:
            errors.append(f"{uploaded_file.filename}: {e}")

    if errors and not documents:
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": "Upload failed.",
                "documents": [],
                "errors": errors,
            },
            status_code=400,
        )

    message = f"Ingested {len(documents)} uploaded file(s)."
    if errors:
        message += f" {len(errors)} file(s) had errors."

    return templates.TemplateResponse(
        request=request,
        name="ingest/result.html",
        context={
            "request": request,
            "message": message,
            "documents": documents,
            "errors": errors,
        },
    )


@router.post("/server-file", response_class=HTMLResponse)
def ingest_server_file(
    request: Request,
    file_path: str = Form(...),
    db: Session = Depends(get_db),
):
    try:
        document = ingest_file(
            db=db,
            file_path=file_path,
            source_system="server_file_ingest",
        )
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Ingested server file successfully: {document.document_id}",
                "documents": [document],
                "errors": [],
            },
        )
    except Exception as e:
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Error ingesting server file: {e}",
                "documents": [],
                "errors": [],
            },
            status_code=400,
        )


@router.post("/server-directory", response_class=HTMLResponse)
def ingest_server_directory(
    request: Request,
    directory_path: str = Form(...),
    recursive: str | None = Form(None),
    db: Session = Depends(get_db),
):
    try:
        docs = ingest_directory(
            db=db,
            directory_path=directory_path,
            recursive=recursive is not None,
            source_system="server_directory_ingest",
        )
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Ingested {len(docs)} file(s) from server directory.",
                "documents": docs,
                "errors": [],
            },
        )
    except Exception as e:
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Error ingesting server directory: {e}",
                "documents": [],
                "errors": [],
            },
            status_code=400,
        )


@router.post("/inbox", response_class=HTMLResponse)
def ingest_inbox_route(request: Request, db: Session = Depends(get_db)):
    try:
        docs = ingest_inbox(db=db)
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Ingested {len(docs)} file(s) from inbox.",
                "documents": docs,
                "errors": [],
            },
        )
    except Exception as e:
        return templates.TemplateResponse(
            request=request,
            name="ingest/result.html",
            context={
                "request": request,
                "message": f"Error ingesting inbox: {e}",
                "documents": [],
                "errors": [],
            },
            status_code=400,
        )