from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile
from sqlalchemy.orm import Session

from app import crud
from app.config import (
    FOLLOW_UP_SCHEDULE,
    FOLLOW_UP_STATUSES,
    NOTE_QUICK_TAGS,
    PIPELINE_STAGES,
)
from app.csv_import import parse_leads_upload
from app.database import get_db
from app.import_validate import annotate_duplicates, summarize
from app.email_service import EmailSendError, send_follow_up_email
from app.schemas import (
    FollowUpOut,
    FollowUpUpdate,
    ImportPreviewOut,
    ImportPreviewRow,
    ImportResult,
    LeadCreate,
    LeadOut,
    LeadUpdate,
    MetaOut,
    SendFollowUpOut,
    StatsOut,
)
from app.services import next_lead_code

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


@router.get("/meta", response_model=MetaOut)
def meta(db: Session = Depends(get_db)):
    return {
        "stages": PIPELINE_STAGES,
        "follow_up_schedule": FOLLOW_UP_SCHEDULE,
        "follow_up_statuses": FOLLOW_UP_STATUSES,
        "note_quick_tags": NOTE_QUICK_TAGS,
        "next_lead_code": next_lead_code(db),
    }


@router.get("/stats", response_model=StatsOut)
def stats(db: Session = Depends(get_db)):
    return crud.get_stats(db)


@router.get("/action-queue")
def action_queue(db: Session = Depends(get_db)):
    return crud.action_queue(db)


@router.get("/leads", response_model=list[LeadOut])
def list_leads(
    q: str | None = Query(None),
    stage: str | None = Query(None),
    status: str | None = Query(None),
    sort: str | None = Query(None),
    db: Session = Depends(get_db),
):
    return crud.list_leads(db, q=q, stage=stage, status=status, sort=sort)


@router.get("/leads/{lead_id}", response_model=LeadOut)
def get_lead(lead_id: int, db: Session = Depends(get_db)):
    lead = crud.get_lead(db, lead_id)
    if not lead:
        raise HTTPException(404, "Lead not found")
    return lead


@router.post("/leads", response_model=LeadOut, status_code=201)
def create_lead(payload: LeadCreate, db: Session = Depends(get_db)):
    try:
        return crud.create_lead(db, payload)
    except ValueError as exc:
        raise HTTPException(400, str(exc)) from exc


def _read_import_file(file: UploadFile, content: bytes):
    filename = (file.filename or "").lower()
    if filename and not (filename.endswith(".csv") or filename.endswith(".xlsx")):
        raise HTTPException(400, "Please upload a .csv or .xlsx file")
    if not content:
        raise HTTPException(400, "Uploaded file is empty")
    try:
        rows, parse_errors = parse_leads_upload(filename, content)
    except ValueError as exc:
        raise HTTPException(400, str(exc)) from exc
    except Exception as exc:  # noqa: BLE001
        raise HTTPException(400, f"Could not read spreadsheet: {exc}") from exc
    return rows, parse_errors


def _preview_payload(db: Session, rows: list[dict], parse_errors: list[str]) -> ImportPreviewOut:
    annotated = annotate_duplicates(db, rows)
    summary = summarize(annotated)
    preview_rows = [
        ImportPreviewRow(
            row_number=r.get("row_number"),
            lead_code=r.get("lead_code"),
            contact_name=r.get("contact_name") or "",
            client_email=r.get("client_email") or "",
            our_email=r.get("our_email"),
            website=r.get("website"),
            date_added=r.get("date_added"),
            stage=r.get("stage"),
            deal_value=r.get("deal_value"),
            status=r.get("status") or "ready",
            issues=r.get("issues") or [],
        )
        for r in annotated
    ]
    issues = list(summary["issues"])
    for msg in parse_errors:
        issues.append(
            {
                "severity": "warning",
                "code": "parse_notice",
                "message": msg,
                "field": None,
                "row_number": None,
                "lead_code": None,
                "contact_name": None,
                "client_email": None,
            }
        )
    return ImportPreviewOut(
        total=summary["total"],
        ready=summary["ready"],
        duplicates=summary["duplicates"],
        invalid=summary["invalid"],
        warnings=summary["warnings"],
        rows=preview_rows,
        issues=issues[:100],
    )


@router.post("/leads/import/preview", response_model=ImportPreviewOut)
async def preview_leads_import(
    file: UploadFile = File(...),
    db: Session = Depends(get_db),
):
    content = await file.read()
    rows, parse_errors = _read_import_file(file, content)
    if not rows:
        detail = "; ".join(parse_errors[:5]) if parse_errors else "No lead rows found in the file"
        raise HTTPException(400, detail)
    return _preview_payload(db, rows, parse_errors)


@router.post("/leads/import", response_model=ImportResult)
async def import_leads_file(
    file: UploadFile = File(...),
    db: Session = Depends(get_db),
):
    content = await file.read()
    rows, parse_errors = _read_import_file(file, content)
    if not rows:
        detail = "; ".join(parse_errors[:5]) if parse_errors else "No lead rows found in the file"
        raise HTTPException(400, detail)

    annotated = annotate_duplicates(db, rows)
    summary = summarize(annotated)
    ready = summary["ready_rows"]
    if not ready:
        raise HTTPException(
            400,
            "No rows ready to import. Fix validation errors or remove duplicates and try again.",
        )

    created = crud.import_leads(db, ready)
    return ImportResult(
        imported=len(created),
        skipped=summary["duplicates"] + summary["invalid"],
        duplicates_skipped=summary["duplicates"],
        invalid_skipped=summary["invalid"],
        errors=parse_errors[:50],
        issues=summary["issues"][:100],
        leads=created,
    )


@router.patch("/leads/{lead_id}", response_model=LeadOut)
def update_lead(lead_id: int, payload: LeadUpdate, db: Session = Depends(get_db)):
    lead = crud.get_lead(db, lead_id)
    if not lead:
        raise HTTPException(404, "Lead not found")
    try:
        return crud.update_lead(db, lead, payload)
    except ValueError as exc:
        raise HTTPException(400, str(exc)) from exc


@router.delete("/leads/{lead_id}", status_code=204)
def delete_lead(lead_id: int, db: Session = Depends(get_db)):
    lead = crud.get_lead(db, lead_id)
    if not lead:
        raise HTTPException(404, "Lead not found")
    crud.delete_lead(db, lead)


@router.patch("/leads/{lead_id}/follow-ups/{number}", response_model=FollowUpOut)
def update_follow_up(
    lead_id: int,
    number: int,
    payload: FollowUpUpdate,
    db: Session = Depends(get_db),
):
    if number < 1 or number > 7:
        raise HTTPException(400, "Follow-up number must be 1-7")
    fu = crud.update_follow_up(
        db,
        lead_id,
        number,
        status=payload.status,
        scheduled_date=payload.scheduled_date,
    )
    if not fu:
        raise HTTPException(404, "Follow-up not found")
    return fu


@router.post(
    "/leads/{lead_id}/follow-ups/{number}/send",
    response_model=SendFollowUpOut,
)
def send_follow_up(
    lead_id: int,
    number: int,
    dry_run: bool = Query(False),
    db: Session = Depends(get_db),
):
    """Send the FU email via Gmail API (OAuth) or SMTP and mark Done on success."""
    if number < 1 or number > 7:
        raise HTTPException(400, "Follow-up number must be 1-7")
    lead = crud.get_lead(db, lead_id)
    if not lead:
        raise HTTPException(404, "Lead not found")
    try:
        result = send_follow_up_email(db, lead, number, dry_run=dry_run)
        return result
    except EmailSendError as exc:
        raise HTTPException(502, str(exc)) from exc
    except ValueError as exc:
        raise HTTPException(400, str(exc)) from exc
