from fastapi import APIRouter,Depends, Query
from fastapi.responses import JSONResponse
from fastapi import HTTPException
from pydantic import BaseModel
from db_setup import get_session
from inbox.enums import Candidate_application_Status
from sqlalchemy.ext.asyncio import AsyncSession
from inbox.views import Email
from users.permissions import PermissionTag, require_permission
from dotenv import load_dotenv
load_dotenv()

router = APIRouter()


class AssignJobPostBody(BaseModel):
    job_post_id: str | None = None


class ProcessingStateBody(BaseModel):
    processing_state: str


class DuplicateBody(BaseModel):
    is_duplicate: bool


class ReadBody(BaseModel):
    read: bool = True


class BulkReadBody(BaseModel):
    record_ids: list[str]
    read: bool = True


class ReadAllBody(BaseModel):
    """The caller's CURRENT list filter, echoed back so the update narrows the same way.

    Every field defaults to the same "no filter" value the list endpoint uses, so an
    empty body means "the All Applications tab" — exactly what GET
    /inbox/all-applications returns with no query params.
    """

    read: bool = True
    search: str | None = None
    isread: bool = True
    application_status: Candidate_application_Status = Candidate_application_Status.CLOSED
    assigned: bool | None = None
    is_duplicate: bool | None = None


class TriageOverrideBody(BaseModel):
    is_application: bool


class EmailSendBody(BaseModel):
    to: str
    subject: str
    body: str
    content_type: str | None = "html"
    inbox_id: int | None = None


class EmailReplyBody(BaseModel):
    record_id: str
    body: str

@router.get("/email/fetch")
async def fetch_email(
    top:int=Query(100,ge=1,le=100),
    skip:int=Query(0,ge=0),
    test_on: bool = Query(True),
    token: str | None = Query(None),
    session: AsyncSession = Depends(get_session),
):
    """Synchronous one-shot sync — kept for scripts/compat. UI uses POST /email/sync."""
    try:
        service=Email(session=session,token=token)
        if not service.token:
            raise HTTPException(status_code=401,detail="Unauthorized")
        summary=await service.run_mailbox_sync_page(top=top,skip=skip,test_on=test_on)
        if test_on:
            return JSONResponse(content={
                "data":summary["entries"],
                "triage":summary["triage"],
                "status_code":200,
            })
        return JSONResponse(content={
            "data":summary["entries"],
            "account_setup":summary["account_setup"],
            "triage":summary["triage"],
            "status_code":200,
        })
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/email/sync")
async def start_email_sync(
    top:int=Query(100,ge=1,le=100),
    skip:int=Query(0,ge=0),
    test_on: bool = Query(True),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    """Enqueue mailbox sync on the dedicated mailbox_sync Taskiq queue.

    Returns immediately with a run id. Poll GET /email/sync/fetch until completed.
    Closing the browser does not cancel the worker.
    """
    try:
        service=Email(session=session)
        if not service.token:
            raise HTTPException(status_code=401,detail="Unauthorized")
        data=await service.start_mailbox_sync(
            current_user=current_user,top=top,skip=skip,test_on=test_on,
        )
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/email/sync/fetch")
async def fetch_email_sync(
    run_id: str | None = Query(None),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.get_mailbox_sync(run_id=run_id)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/fetch")
async def fetch_inbox(
    record_id: str | None = Query(None),
    search: str | None = Query(None),
    top: int | None = Query(None, ge=1, le=500),
    skip: int = Query(0, ge=0),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        if record_id:
            item=await service.get_inbox_message_by_id(record_id)
            return JSONResponse(content={"data":item,"total":1,"status_code":200})

        items=await service.get_inbox_messages(top,skip,search)
        total=await service.count_inbox_messages(search)
        return JSONResponse(content={"data":items,"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/inbox/{record_id}/match")
async def rematch_inbox(
    record_id: str,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        queued_id=await service.queue_rematch(record_id)
        task_ids=await service.enqueue_matching([queued_id], force=True)
        return JSONResponse(content={"data":{"queued":True,"task_ids":task_ids},"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/{record_id}/assign-job-post")
async def assign_job_post(
    record_id: str,
    payload: AssignJobPostBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.assign_job_post(record_id,payload.job_post_id)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/inbox/{record_id}/read")
async def mark_inbox_read(
    record_id: str,
    payload: ReadBody | None = None,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    """Flip one row. The body is OPTIONAL and defaults to read=true, so the original
    bodyless POST this route shipped with keeps working unchanged."""
    try:
        service=Email(session=session)
        data=await service.mark_read(record_id,payload.read if payload else True)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/read")
async def bulk_mark_inbox_read(
    payload: BulkReadBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    """Selected rows -> read/unread. Single segment after /inbox, so it never collides
    with the two-segment /inbox/{record_id}/read above."""
    try:
        service=Email(session=session)
        data=await service.set_read_bulk(payload.record_ids,payload.read)
        return JSONResponse(content={"data":data,"total":data["updated"],"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/read-all")
async def mark_all_inbox_read(
    payload: ReadAllBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    """Every row matching the caller's current list filter -> read/unread."""
    try:
        service=Email(session=session)
        data=await service.set_read_all(
            payload.read,
            search=payload.search,
            isread=payload.isread,
            application_status=payload.application_status,
            assigned=payload.assigned,
            is_duplicate=payload.is_duplicate,
        )
        return JSONResponse(content={"data":data,"total":data["updated"],"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/{record_id}/read-status")
async def get_inbox_read_status(
    record_id: str,
    token: str | None = Query(None),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session,token=token)
        data=await service.refresh_read_status(record_id)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))

@router.get("/inbox/all-applications")
async def get_all_applications(
    record_id: str | None = Query(None),
    application_status: Candidate_application_Status = Query(default=Candidate_application_Status.CLOSED),
    isread: bool = Query(default=True),
    assigned: bool | None = Query(default=None),
    is_duplicate: bool | None = Query(default=None),
    no_suggestions: bool | None = Query(default=None),
    search: str | None = Query(None),
    # Caller-chosen page size (Inbox / Job Matching send 10/25/50/100). None = unpaged.
    top: int | None = Query(None, ge=1, le=500),
    skip: int = Query(0, ge=0),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        
        if application_status in (Candidate_application_Status.PROCESS, Candidate_application_Status.REJECTED, Candidate_application_Status.SCREENING, Candidate_application_Status.ASSESSMENT, Candidate_application_Status.INTERVIEW, Candidate_application_Status.OFFER, Candidate_application_Status.HIRED):
            items=await service.get_all_applications(top, skip, search, application_status=application_status, assigned=assigned, is_duplicate=is_duplicate, no_suggestions=no_suggestions)
            total=await service.count_inbox_messages(search, application_status=application_status, assigned=assigned, is_duplicate=is_duplicate, no_suggestions=no_suggestions)
            return JSONResponse(content={"data":items,"total":total,"status_code":200})
        if isread==False:
            items=await service.get_all_applications(top, skip, search, isread=False, assigned=assigned, is_duplicate=is_duplicate, no_suggestions=no_suggestions)
            total=await service.count_inbox_messages(search, isread=False, assigned=assigned, is_duplicate=is_duplicate, no_suggestions=no_suggestions)
            return JSONResponse(content={"data":items,"total":total,"status_code":200})
        if record_id:
            item=await service.get_application_by_id(record_id)
            return JSONResponse(content={"data":item,"total":1,"status_code":200})

        items=await service.get_all_applications(top,skip,search,assigned=assigned,is_duplicate=is_duplicate,no_suggestions=no_suggestions)
        total=await service.count_inbox_messages(search,assigned=assigned,is_duplicate=is_duplicate,no_suggestions=no_suggestions)
        return JSONResponse(content={"data":items,"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/all-applications/count")
async def count_all_applications(
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    """Unfiltered application total. Called once when Inbox Email opens."""
    try:
        service=Email(session=session)
        total=await service.count_inbox_messages()
        return JSONResponse(content={"data":{"total":total},"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/counts")
async def get_inbox_counts(
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.get_counts()
        return JSONResponse(content={"data":data,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.get("/inbox/triage")
async def fetch_triage(
    search: str | None = Query(None),
    is_application: bool | None = Query(None),
    status: str | None = Query(None),
    top: int = Query(100),
    skip: int = Query(0, ge=0),
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_VIEW)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.get_triage_messages(top,skip,search,is_application,status)
        total=await service.count_triage(search,is_application,status)
        return JSONResponse(content={"data":data,"total":total,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/triage/{record_id}/override")
async def override_triage(
    record_id: str,
    payload: TriageOverrideBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.override_triage(record_id,payload.is_application,current_user)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/{record_id}/processing-state")
async def set_processing_state(
    record_id: str,
    payload: ProcessingStateBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.set_processing_state(record_id,payload.processing_state)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.patch("/inbox/{record_id}/duplicate")
async def set_duplicate(
    record_id: str,
    payload: DuplicateBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.set_duplicate(record_id,payload.is_duplicate)
        return JSONResponse(content={"data":data,"total":1,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/email/send")
async def send_email(
    payload: EmailSendBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.send_email(payload.model_dump(exclude_unset=True),current_user)
        return JSONResponse(content={"data":data,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))


@router.post("/email/reply")
async def reply_email(
    payload: EmailReplyBody,
    current_user: dict = Depends(require_permission(PermissionTag.INBOX_EDIT)),
    session: AsyncSession = Depends(get_session),
):
    try:
        service=Email(session=session)
        data=await service.reply_email(payload.model_dump(exclude_unset=True),current_user)
        return JSONResponse(content={"data":data,"status_code":200})
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500,detail=str(e))