from datetime import datetime, timezone

from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel, Field
from sqlalchemy.orm import Session

from app.api.deps import get_current_user
from app.core.database import get_db
from app.models import Job, JobAlert, Profile, User
from app.services.intelligence import (
    company_brief,
    dashboard_payload,
    interview_prep,
    match_alerts,
    salary_intelligence,
)

router = APIRouter(tags=["intelligence"])


class OnboardingIn(BaseModel):
    headline: str = ""
    desired_roles: list[str] = Field(default_factory=list)
    job_categories: list[str] = Field(default_factory=list)
    location: str = "Spain"
    remote_only: bool = False
    salary_min: int | None = 25000
    salary_currency: str = "EUR"
    english_fluent: bool = False
    keywords: list[str] = Field(default_factory=list)


class AlertIn(BaseModel):
    name: str = "Alerta"
    query: str = ""
    location: str = ""
    remote_only: bool = False
    min_salary: int | None = None
    min_score: float = 50.0
    enabled: bool = True


class AlertOut(BaseModel):
    id: int
    name: str
    query: str
    location: str
    remote_only: bool
    min_salary: int | None = None
    min_score: float
    enabled: bool
    last_match_count: int = 0
    last_checked_at: datetime | None = None

    model_config = {"from_attributes": True}


@router.get("/dashboard")
def dashboard(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return dashboard_payload(db, user)


@router.post("/onboarding/complete")
def complete_onboarding(
    payload: OnboardingIn,
    user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    profile = user.profile
    if not profile:
        profile = Profile(user_id=user.id)
        db.add(profile)
        db.flush()
    profile.headline = payload.headline or profile.headline
    profile.desired_roles = payload.desired_roles
    profile.job_categories = payload.job_categories or ["general"]
    profile.location = payload.location
    profile.remote_only = payload.remote_only
    profile.salary_min = payload.salary_min
    profile.salary_currency = payload.salary_currency
    profile.english_fluent = payload.english_fluent
    if payload.keywords:
        profile.keywords = payload.keywords
    user.onboarding_done = True
    db.commit()
    return {"ok": True, "onboarding_done": True}


@router.get("/intelligence/salary")
def salary_intel(
    location: str | None = None,
    q: str | None = None,
    user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    return salary_intelligence(db, user, location=location, query=q)


@router.get("/intelligence/readiness")
def readiness(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.intelligence import readiness_score

    return readiness_score(db, user)


@router.get("/intelligence/digest")
def digest(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.intelligence import daily_digest

    return daily_digest(db, user)


@router.get("/intelligence/career-path")
def career(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.intelligence import career_path

    return career_path(db, user)


@router.get("/intelligence/war-room")
def war_room_ep(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.wow_tier_a import war_room

    return war_room(db, user)


@router.get("/intelligence/war-room.pdf")
def war_room_pdf_ep(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from fastapi.responses import FileResponse

    from app.core.config import get_settings
    from app.services.wow_tier_a import war_room_pdf

    settings = get_settings()
    out = settings.data_dir / "exports" / f"war_room_{user.id}.pdf"
    war_room_pdf(db, user, out)
    return FileResponse(out, filename=out.name, media_type="application/pdf")


@router.get("/intelligence/negotiate")
def negotiate_ep(
    location: str | None = None,
    q: str | None = None,
    ask: int | None = None,
    user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    from app.services.wow_tier_a import negotiation_playbook

    return negotiation_playbook(db, user, location=location, query=q, ask=ask)


@router.get("/intelligence/skills-radar")
def radar_ep(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.wow_tier_a import skills_radar

    return skills_radar(db, user)


@router.get("/intelligence/ethics-certificate")
def ethics_ep(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from app.services.wow_tier_a import ethics_certificate

    return ethics_certificate(db, user)


@router.get("/intelligence/ethics-certificate.pdf")
def ethics_pdf_ep(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    from fastapi.responses import FileResponse

    from app.core.config import get_settings
    from app.services.wow_tier_a import ethics_certificate_pdf

    settings = get_settings()
    out = settings.data_dir / "exports" / f"ethics_{user.id}.pdf"
    ethics_certificate_pdf(db, user, out)
    return FileResponse(out, filename=out.name, media_type="application/pdf")


@router.get("/intelligence/jobs/{job_id}/interview")
def interview(job_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    job = db.get(Job, job_id)
    if not job:
        raise HTTPException(404, "Oferta no encontrada")
    return interview_prep(db, user, job)


@router.get("/intelligence/jobs/{job_id}/company-brief")
def brief(job_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    job = db.get(Job, job_id)
    if not job:
        raise HTTPException(404, "Oferta no encontrada")
    return company_brief(job)


@router.get("/alerts", response_model=list[AlertOut])
def list_alerts(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return db.query(JobAlert).filter(JobAlert.user_id == user.id).order_by(JobAlert.id.desc()).all()


@router.post("/alerts", response_model=AlertOut)
def create_alert(payload: AlertIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    alert = JobAlert(user_id=user.id, **payload.model_dump())
    db.add(alert)
    db.commit()
    db.refresh(alert)
    return alert


@router.patch("/alerts/{alert_id}", response_model=AlertOut)
def update_alert(
    alert_id: int,
    payload: AlertIn,
    user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    alert = db.query(JobAlert).filter(JobAlert.id == alert_id, JobAlert.user_id == user.id).first()
    if not alert:
        raise HTTPException(404, "Alerta no encontrada")
    for k, v in payload.model_dump().items():
        setattr(alert, k, v)
    db.commit()
    db.refresh(alert)
    return alert


@router.delete("/alerts/{alert_id}")
def delete_alert(alert_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    alert = db.query(JobAlert).filter(JobAlert.id == alert_id, JobAlert.user_id == user.id).first()
    if not alert:
        raise HTTPException(404, "Alerta no encontrada")
    db.delete(alert)
    db.commit()
    return {"ok": True}


@router.post("/alerts/{alert_id}/run")
def run_alert(alert_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    alert = db.query(JobAlert).filter(JobAlert.id == alert_id, JobAlert.user_id == user.id).first()
    if not alert:
        raise HTTPException(404, "Alerta no encontrada")
    matches = match_alerts(db, user, alert)
    alert.last_match_count = len(matches)
    alert.last_checked_at = datetime.now(timezone.utc)
    db.commit()
    return {"matches": matches, "count": len(matches), "alert": AlertOut.model_validate(alert)}