from __future__ import annotations

from fastapi import APIRouter, HTTPException, Query
from pydantic import EmailStr

from app.services.financial_reports import (
    FinancialReportOut,
    approve_report_advice,
    create_draft_report,
    get_report,
    list_reports,
)
from app.services.ledger_auth import require_firm
from app.services.reminders import run_upload_reminders
from app.store import FirmActorMixin

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


class RunRemindersRequest(FirmActorMixin):
    dryRun: bool = False


class CreateReportRequest(FirmActorMixin):
    clientId: str
    period: str


@router.post("/jobs/upload-reminders")
def trigger_upload_reminders(payload: RunRemindersRequest):
    """Run the two-week invoice upload reminder job (firm-only)."""
    require_firm(platform=payload.platform, email=payload.email, actor=payload.actor)
    return run_upload_reminders(dry_run=payload.dryRun)


@router.get("/financial-reports")
def get_financial_reports(
    platform: str = Query(pattern="^(firm|client)$"),
    email: EmailStr = Query(...),
    clientId: str | None = None,
):
    from app.services.notifications import resolve_client_id

    if platform == "firm":
        require_firm(platform=platform, email=str(email))
        return {"items": list_reports(client_id=clientId), "integrationRequired": True}

    client_id = resolve_client_id(platform, str(email))
    if not client_id:
        return {"items": [], "integrationRequired": True}
    items = [r for r in list_reports(client_id=client_id) if r.status in {"approved", "sent"}]
    return {"items": items, "integrationRequired": True}


@router.post("/financial-reports")
def create_financial_report(payload: CreateReportRequest):
    actor = require_firm(platform=payload.platform, email=payload.email, actor=payload.actor)
    from app.store import store

    if not any(c.id == payload.clientId for c in store.snapshot().clients):
        raise HTTPException(status_code=404, detail="Client not found")
    return create_draft_report(client_id=payload.clientId, period=payload.period, actor=actor)


@router.post("/financial-reports/{report_id}/approve-advice")
def approve_financial_report_advice(report_id: int, payload: RunRemindersRequest):
    actor = require_firm(platform=payload.platform, email=payload.email, actor=payload.actor)
    result = approve_report_advice(report_id=report_id, actor=actor)
    if not result:
        raise HTTPException(status_code=404, detail="Report not found")
    return result


@router.get("/financial-reports/{report_id}")
def get_financial_report(
    report_id: int,
    platform: str = Query(pattern="^(firm|client)$"),
    email: EmailStr = Query(...),
):
    from app.services.notifications import resolve_client_id

    report = get_report(report_id)
    if not report:
        raise HTTPException(status_code=404, detail="Report not found")

    if platform == "client":
        client_id = resolve_client_id(platform, str(email))
        if not client_id or report.clientId != client_id or report.status not in {"approved", "sent"}:
            raise HTTPException(status_code=403, detail="Access denied")
    else:
        require_firm(platform=platform, email=str(email))

    return report