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

from app.database import get_db
from app.api.deps import get_current_user
from app.models.user import User
from app.models.candidate import Candidate
from app.schemas.candidate import CandidateCreate, CandidateResponse, ParseRequest, ParseResponse
from app.services.gemini_service import parse_resume, create_embedding, GeminiError
from app.services.pinecone_service import upsert_candidate

router = APIRouter(prefix="/api/v1/candidates")


@router.post("/parse", response_model=ParseResponse)
async def parse(
    request: ParseRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """이력서 텍스트 → 파싱 + DB 저장 + Pinecone 업서트"""
    try:
        # 1. Gemini로 이력서 파싱
        parsed_data = parse_resume(request.resume_text)

        # 2. 임베딩 생성
        embedding = create_embedding(request.resume_text)

        # 3. DB 저장 (flush로 ID 확보)
        candidate = Candidate(
            company_id=current_user.company_id,
            name=parsed_data.get("name"),
            email=parsed_data.get("email"),
            resume_text=request.resume_text,
            parsed_data=parsed_data,
        )
        db.add(candidate)
        db.flush()

        # 4. embedding_id 설정 및 Pinecone 업서트
        embedding_id = f"cand_{candidate.id}"
        candidate.embedding_id = embedding_id

        upsert_candidate(
            candidate_id=embedding_id,
            embedding=embedding,
            metadata={
                "name": candidate.name or "",
                "email": candidate.email or "",
                "skills": parsed_data.get("skills", []),
                "experience_years": parsed_data.get("experience_years", 0),
            },
            namespace=str(current_user.company_id),
        )

        db.commit()
        return {"parsed_data": parsed_data, "embedding_id": embedding_id}

    except GeminiError as e:
        db.rollback()
        raise HTTPException(status_code=503, detail=str(e))


@router.post("", response_model=CandidateResponse)
async def create(
    request: CandidateCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    candidate = Candidate(
        company_id=current_user.company_id,
        name=request.name,
        email=request.email,
        resume_text=request.resume_text,
    )
    db.add(candidate)
    db.commit()
    db.refresh(candidate)
    return candidate


@router.get("", response_model=list[CandidateResponse])
async def list_all(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    return db.query(Candidate).filter(
        Candidate.company_id == current_user.company_id
    ).all()


@router.get("/{id}", response_model=CandidateResponse)
async def get_one(
    id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    candidate = db.query(Candidate).filter(
        Candidate.id == id,
        Candidate.company_id == current_user.company_id,
    ).first()
    if not candidate:
        raise HTTPException(status_code=404, detail="후보자를 찾을 수 없습니다")
    return candidate


@router.delete("/{id}")
async def delete(
    id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    candidate = db.query(Candidate).filter(
        Candidate.id == id,
        Candidate.company_id == current_user.company_id,
    ).first()
    if not candidate:
        raise HTTPException(status_code=404, detail="후보자를 찾을 수 없습니다")
    db.delete(candidate)
    db.commit()
    return {"message": "삭제 완료"}