"""Tier B APIs: personas, simulador, plantillas, índice, benchmarks, clip, telegram."""

from __future__ import annotations

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

from app.api.deps import get_current_user, require_admin
from app.core.database import get_db
from app.models import CV, Job, User
from app.services import wow_tier_b as wb

router = APIRouter(tags=["tier-b"])


class PersonaIn(BaseModel):
    label: str = "Persona"
    relation: str = "self"
    from_current: bool = True
    snapshot: dict | None = None


class InterviewAnswerIn(BaseModel):
    job_id: int
    question: str
    answer: str


class ClipIn(BaseModel):
    url: str
    title: str = ""
    company: str = ""
    location: str = ""
    description: str = ""


class TelegramChatIn(BaseModel):
    telegram_chat_id: str = ""


class TemplateApplyIn(BaseModel):
    key: str
    as_base: bool = True


# —— Public lead magnet ——
@router.get("/public/salary-index")
def public_salary_index(db: Session = Depends(get_db)):
    return wb.salary_index_es(db)


@router.get("/public/remote-spain")
def public_remote_spain(db: Session = Depends(get_db)):
    return wb.remote_spain_graph(db)


# —— Personas ——
@router.get("/personas")
def personas(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return {"items": wb.list_personas(db, user), "active_persona_id": user.active_persona_id}


@router.post("/personas")
def create_persona(payload: PersonaIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return wb.create_persona(
        db, user, payload.label, payload.relation, payload.from_current, payload.snapshot
    )


@router.post("/personas/{persona_id}/activate")
def activate_persona(persona_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    try:
        return wb.switch_persona(db, user, persona_id)
    except ValueError as e:
        raise HTTPException(404, str(e)) from e


@router.post("/personas/save-current")
def save_persona(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    wb.save_current_to_active_persona(db, user)
    return {"ok": True}


# —— Interview simulator ——
@router.get("/intelligence/interview-sim/{job_id}")
def interview_sim_start(job_id: int, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    try:
        return wb.interview_simulator_start(db, user, job_id)
    except ValueError as e:
        raise HTTPException(404, str(e)) from e


@router.post("/intelligence/interview-sim/score")
def interview_sim_score(payload: InterviewAnswerIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    job = db.get(Job, payload.job_id)
    return wb.score_interview_answer(payload.question, payload.answer, job=job, profile=user.profile)


# —— CV templates ——
@router.get("/cv-templates")
def cv_templates(_: User = Depends(get_current_user)):
    return {"items": wb.list_cv_templates()}


@router.post("/cv-templates/apply")
def apply_template(payload: TemplateApplyIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    tpl = wb.get_cv_template(payload.key)
    if not tpl:
        raise HTTPException(404, "Plantilla no encontrada")
    cv = CV(
        user_id=user.id,
        title=tpl["title"],
        content_md=tpl["content_md"],
        is_base=payload.as_base,
    )
    db.add(cv)
    db.commit()
    db.refresh(cv)
    return {"ok": True, "cv_id": cv.id, "title": cv.title, "wow": tpl.get("wow")}


# —— Market intel ——
@router.get("/intelligence/portal-benchmark")
def portal_bench(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return wb.portal_benchmark(db, user)


@router.get("/intelligence/remote-spain")
def remote_spain(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return wb.remote_spain_graph(db)


@router.get("/intelligence/salary-index")
def salary_index_auth(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    data = wb.salary_index_es(db)
    data["personalized"] = True
    return data


# —— Clipper ——
@router.post("/clip/jobs")
def clip_jobs(payload: ClipIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    try:
        return wb.clip_job(db, user, payload.model_dump())
    except ValueError as e:
        raise HTTPException(400, str(e)) from e


# —— Telegram ——
@router.get("/alerts/telegram/status")
def tg_status(_: User = Depends(get_current_user)):
    return wb.telegram_status()


@router.post("/alerts/telegram/chat")
def tg_chat(payload: TelegramChatIn, user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    user.telegram_chat_id = payload.telegram_chat_id.strip() or None
    db.commit()
    return {"ok": True, "telegram_chat_id": user.telegram_chat_id}


@router.post("/alerts/telegram/test")
def tg_test(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
    return wb.telegram_send_test(db, user)


@router.get("/admin/tier-b-overview")
def tier_b_overview(admin: User = Depends(require_admin), db: Session = Depends(get_db)):
    return {
        "templates": len(wb.list_cv_templates()),
        "salary_index_sample": wb.salary_index_es(db).get("sample_size"),
        "remote_spain": wb.remote_spain_graph(db).get("totals"),
        "telegram": wb.telegram_status(),
        "wow": "Tier B overview para Health / demos.",
    }