"""Gmail OAuth connect / list / disconnect endpoints."""

from __future__ import annotations

from urllib.parse import urlencode

from fastapi import APIRouter, Depends, HTTPException
from fastapi.responses import RedirectResponse
from sqlalchemy.orm import Session

from app.config import settings
from app.database import get_db
from app.gmail_oauth import (
    GmailAuthError,
    account_has_readonly,
    delete_account,
    finish_authorization,
    list_accounts,
    set_default_account,
    start_authorization,
)
from app.schemas import GmailAccountOut, GmailAuthStartOut, GmailStatusOut

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


def _frontend_redirect(**params: str) -> RedirectResponse:
    base = (settings.frontend_url or "http://localhost:5173").rstrip("/")
    qs = urlencode({k: v for k, v in params.items() if v is not None})
    url = f"{base}/?{qs}" if qs else f"{base}/"
    return RedirectResponse(url=url, status_code=302)


def _account_out(account) -> GmailAccountOut:
    data = GmailAccountOut.model_validate(account)
    return data.model_copy(update={"has_readonly": account_has_readonly(account)})


@router.get("/status", response_model=GmailStatusOut)
def gmail_status(db: Session = Depends(get_db)):
    accounts = list_accounts(db)
    outs = [_account_out(a) for a in accounts]
    return GmailStatusOut(
        oauth_configured=settings.gmail_oauth_configured,
        email_provider=settings.email_provider,
        smtp_configured=settings.smtp_configured,
        accounts=outs,
        accounts_missing_readonly=[a.email for a in outs if not a.has_readonly],
    )


@router.get("/accounts", response_model=list[GmailAccountOut])
def gmail_accounts(db: Session = Depends(get_db)):
    return [_account_out(a) for a in list_accounts(db)]


@router.get("/auth/start", response_model=GmailAuthStartOut)
def gmail_auth_start():
    if not settings.gmail_oauth_configured:
        raise HTTPException(
            503,
            "Gmail OAuth not configured. Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET "
            "(or GOOGLE_CLIENT_SECRETS_FILE) in backend/.env",
        )
    try:
        started = start_authorization()
    except GmailAuthError as exc:
        raise HTTPException(503, str(exc)) from exc
    return GmailAuthStartOut(**started)


@router.get("/auth/callback")
def gmail_auth_callback(
    code: str | None = None,
    state: str | None = None,
    error: str | None = None,
    db: Session = Depends(get_db),
):
    if error:
        return _frontend_redirect(gmail="error", message=error)
    if not code:
        return _frontend_redirect(gmail="error", message="missing_code")
    try:
        account = finish_authorization(db, code=code, state=state)
    except GmailAuthError as exc:
        return _frontend_redirect(gmail="error", message=str(exc)[:300])
    except Exception as exc:  # noqa: BLE001 — never leave browser on a bare 500
        return _frontend_redirect(gmail="error", message=str(exc)[:300])
    return _frontend_redirect(gmail="connected", email=account.email)


@router.post("/accounts/{email}/default", response_model=GmailAccountOut)
def gmail_set_default(email: str, db: Session = Depends(get_db)):
    try:
        return set_default_account(db, email)
    except GmailAuthError as exc:
        raise HTTPException(404, str(exc)) from exc


@router.delete("/accounts/{email}", status_code=204)
def gmail_disconnect(email: str, db: Session = Depends(get_db)):
    if not delete_account(db, email):
        raise HTTPException(404, f"No connected Gmail account: {email}")
    return None
