from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
from fastapi.responses import RedirectResponse
from pydantic import BaseModel

from app.core.database import get_session
from app.repositories.resume_repository import ResumeRepository
from celery_worker.interview_analysis_task import (
    analyze_multiple_candidates,
    generate_interview_report,
)

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


class AnalysisResponse(BaseModel):
    """Ответ запуска задачи анализа"""

    message: str
    resume_id: int
    task_id: str


class BulkAnalysisRequest(BaseModel):
    """Запрос массового анализа"""

    resume_ids: list[int]


class BulkAnalysisResponse(BaseModel):
    """Ответ массового анализа"""

    message: str
    resume_count: int
    task_id: str


class CandidateRanking(BaseModel):
    """Рейтинг кандидата"""

    resume_id: int
    candidate_name: str
    overall_score: int
    recommendation: str
    position: str


class PDFGenerationResponse(BaseModel):
    """Ответ генерации PDF отчета"""

    message: str
    resume_id: int
    candidate_name: str
    pdf_url: str | None = None
    status: str  # "generated", "exists", "failed"


@router.post("/interview-report/{resume_id}", response_model=AnalysisResponse)
async def start_interview_analysis(
    resume_id: int,
    background_tasks: BackgroundTasks,
    resume_repo: ResumeRepository = Depends(ResumeRepository),
):
    """
    Запускает анализ интервью для конкретного кандидата

    Анализирует:
    - Соответствие резюме вакансии
    - Качество ответов в диалоге интервью
    - Технические навыки и опыт
    - Коммуникативные способности
    - Общую рекомендацию и рейтинг
    """

    # Проверяем, существует ли резюме
    resume = await resume_repo.get_by_id(resume_id)

    if not resume:
        raise HTTPException(status_code=404, detail="Resume not found")

    # Запускаем задачу анализа
    task = generate_interview_report.delay(resume_id)

    return AnalysisResponse(
        message="Interview analysis started", resume_id=resume_id, task_id=task.id
    )


@router.post("/bulk-analysis", response_model=BulkAnalysisResponse)
async def start_bulk_analysis(
    request: BulkAnalysisRequest,
    background_tasks: BackgroundTasks,
    resume_repo: ResumeRepository = Depends(ResumeRepository),
):
    """
    Запускает массовый анализ нескольких кандидатов

    Возвращает ранжированный список кандидатов по общему баллу
    Полезно для сравнения кандидатов на одну позицию
    """

    # Проверяем, что все резюме существуют
    existing_resumes = []

    for resume_id in request.resume_ids:
        resume = await resume_repo.get_by_id(resume_id)
        if resume:
            existing_resumes.append(resume_id)

    if not existing_resumes:
        raise HTTPException(status_code=404, detail="No valid resumes found")

    # Запускаем задачу массового анализа
    task = analyze_multiple_candidates.delay(existing_resumes)

    return BulkAnalysisResponse(
        message="Bulk analysis started",
        resume_count=len(existing_resumes),
        task_id=task.id,
    )


@router.get("/ranking/{vacancy_id}")
async def get_candidates_ranking(
    vacancy_id: int, resume_repo: ResumeRepository = Depends(ResumeRepository)
):
    """
    Получить ранжированный список кандидатов для вакансии

    Сортирует кандидатов по результатам анализа интервью
    Показывает только тех, кто прошел интервью
    """

    # Получаем все резюме для вакансии со статусом "interviewed"
    resumes = await resume_repo.get_by_vacancy_id(vacancy_id)
    interviewed_resumes = [r for r in resumes if r.status in ["interviewed"]]

    if not interviewed_resumes:
        return {
            "vacancy_id": vacancy_id,
            "candidates": [],
            "message": "No interviewed candidates found",
        }

    # Запускаем массовый анализ если еще не было
    resume_ids = [r.id for r in interviewed_resumes]
    task = analyze_multiple_candidates.delay(resume_ids)

    # В реальности здесь нужно дождаться выполнения или получить из кэша
    # Пока возвращаем информацию о запущенной задаче
    return {
        "vacancy_id": vacancy_id,
        "task_id": task.id,
        "message": f"Analysis started for {len(resume_ids)} candidates",
        "resume_ids": resume_ids,
    }


@router.get("/report/{resume_id}")
async def get_interview_report(
    resume_id: int, resume_repo: ResumeRepository = Depends(ResumeRepository)
):
    """
    Получить готовый отчет анализа интервью

    Если отчет еще не готов - запускает анализ
    """

    resume = await resume_repo.get_by_id(resume_id)

    if not resume:
        raise HTTPException(status_code=404, detail="Resume not found")

    # Проверяем, есть ли уже готовый отчет в notes
    if resume.notes and "ОЦЕНКА КАНДИДАТА" in resume.notes:
        return {
            "resume_id": resume_id,
            "candidate_name": resume.applicant_name,
            "status": "completed",
            "report_summary": resume.notes,
            "message": "Report available",
        }

    # Если отчета нет - запускаем анализ
    task = generate_interview_report.delay(resume_id)

    return {
        "resume_id": resume_id,
        "candidate_name": resume.applicant_name,
        "status": "in_progress",
        "task_id": task.id,
        "message": "Analysis started, check back later",
    }


@router.get("/statistics/{vacancy_id}")
async def get_analysis_statistics(
    vacancy_id: int, resume_repo: ResumeRepository = Depends(ResumeRepository)
):
    """
    Получить статистику анализа кандидатов по вакансии
    """

    resumes = await resume_repo.get_by_vacancy_id(vacancy_id)

    total_candidates = len(resumes)
    interviewed = len([r for r in resumes if r.status == "interviewed"])
    with_reports = len(
        [r for r in resumes if r.notes and "ОЦЕНКА КАНДИДАТА" in r.notes]
    )

    # Подсчитываем рекомендации из notes (упрощенно)
    recommendations = {
        "strongly_recommend": 0,
        "recommend": 0,
        "consider": 0,
        "reject": 0,
    }

    for resume in resumes:
        if resume.notes and "ОЦЕНКА КАНДИДАТА" in resume.notes:
            notes = resume.notes.lower()
            if "strongly_recommend" in notes:
                recommendations["strongly_recommend"] += 1
            elif "recommend" in notes and "strongly_recommend" not in notes:
                recommendations["recommend"] += 1
            elif "consider" in notes:
                recommendations["consider"] += 1
            elif "reject" in notes:
                recommendations["reject"] += 1

    return {
        "vacancy_id": vacancy_id,
        "statistics": {
            "total_candidates": total_candidates,
            "interviewed_candidates": interviewed,
            "analyzed_candidates": with_reports,
            "recommendations": recommendations,
            "analysis_completion": round((with_reports / max(interviewed, 1)) * 100, 1)
            if interviewed > 0
            else 0,
        },
    }


@router.get("/pdf-report/{resume_id}")
async def get_pdf_report(
    resume_id: int,
    session=Depends(get_session),
    resume_repo: ResumeRepository = Depends(ResumeRepository),
):
    """
    Получить PDF отчет по интервью

    Если отчет готов - перенаправляет на S3 URL
    Если отчета нет - возвращает информацию о статусе
    """
    from sqlmodel import select

    from app.models.interview import InterviewSession
    from app.models.interview_report import InterviewReport

    # Проверяем, существует ли резюме
    resume = await resume_repo.get_by_id(resume_id)
    if not resume:
        raise HTTPException(status_code=404, detail="Resume not found")

    # Ищем сессию интервью и отчет
    statement = (
        select(InterviewReport, InterviewSession)
        .join(
            InterviewSession,
            InterviewReport.interview_session_id == InterviewSession.id,
        )
        .where(InterviewSession.resume_id == resume_id)
    )

    result = await session.execute(statement)
    report_session = result.first()

    if not report_session:
        # Если отчета нет - возможно, нужно запустить анализ
        raise HTTPException(
            status_code=404,
            detail="Interview report not found. Run analysis first using POST /analysis/interview-report/{resume_id}",
        )

    report, interview_session = report_session

    if not report.pdf_report_url:
        # PDF еще не сгенерирован
        return {
            "status": "pdf_not_ready",
            "message": "PDF report is being generated or failed to generate",
            "report_id": report.id,
            "candidate_name": resume.applicant_name,
        }

    # Перенаправляем на S3 URL
    return RedirectResponse(url=report.pdf_report_url, status_code=302)


@router.post("/generate-pdf/{resume_id}")
async def generate_pdf_report(
    resume_id: int,
    session=Depends(get_session),
    resume_repo: ResumeRepository = Depends(ResumeRepository),
):
    """
    Запускает асинхронную генерацию PDF отчета по интервью

    Проверяет наличие отчета в базе данных и запускает Celery задачу для генерации PDF файла.
    Если PDF уже существует, возвращает существующий URL.
    """
    from sqlmodel import select

    from app.models.interview import InterviewSession
    from app.models.interview_report import InterviewReport
    from celery_worker.tasks import generate_pdf_report_task

    # Проверяем, существует ли резюме
    resume = await resume_repo.get_by_id(resume_id)
    if not resume:
        raise HTTPException(status_code=404, detail="Resume not found")

    # Ищем отчет интервью
    statement = (
        select(InterviewReport, InterviewSession)
        .join(
            InterviewSession,
            InterviewReport.interview_session_id == InterviewSession.id,
        )
        .where(InterviewSession.resume_id == resume_id)
    )

    result = await session.execute(statement)
    report_session = result.first()

    if not report_session:
        raise HTTPException(
            status_code=404,
            detail="Interview report not found. Run analysis first using POST /analysis/interview-report/{resume_id}",
        )

    report, interview_session = report_session

    # Если PDF уже существует, возвращаем его
    if report.pdf_report_url:
        return {
            "message": "PDF report already exists",
            "resume_id": resume_id,
            "report_id": report.id,
            "candidate_name": resume.applicant_name,
            "pdf_url": report.pdf_report_url,
            "status": "exists",
        }

    # Получаем позицию из связанной вакансии
    from app.models.vacancy import Vacancy

    vacancy_stmt = select(Vacancy).where(Vacancy.id == resume.vacancy_id)
    vacancy_result = await session.execute(vacancy_stmt)
    vacancy = vacancy_result.scalar_one_or_none()

    position = vacancy.title if vacancy else "Позиция не указана"

    # Сериализуем данные отчета
    report_data = {
        "id": report.id,
        "interview_session_id": report.interview_session_id,
        "technical_skills_score": report.technical_skills_score,
        "technical_skills_justification": report.technical_skills_justification,
        "technical_skills_concerns": report.technical_skills_concerns,
        "experience_relevance_score": report.experience_relevance_score,
        "experience_relevance_justification": report.experience_relevance_justification,
        "experience_relevance_concerns": report.experience_relevance_concerns,
        "communication_score": report.communication_score,
        "communication_justification": report.communication_justification,
        "communication_concerns": report.communication_concerns,
        "problem_solving_score": report.problem_solving_score,
        "problem_solving_justification": report.problem_solving_justification,
        "problem_solving_concerns": report.problem_solving_concerns,
        "cultural_fit_score": report.cultural_fit_score,
        "cultural_fit_justification": report.cultural_fit_justification,
        "cultural_fit_concerns": report.cultural_fit_concerns,
        "overall_score": report.overall_score,
        "recommendation": report.recommendation,
        "strengths": report.strengths,
        "weaknesses": report.weaknesses,
        "red_flags": report.red_flags,
        "questions_quality_score": report.questions_quality_score,
        "interview_duration_minutes": report.interview_duration_minutes,
        "response_count": report.response_count,
        "dialogue_messages_count": report.dialogue_messages_count,
        "next_steps": report.next_steps,
        "interviewer_notes": report.interviewer_notes,
        "questions_analysis": report.questions_analysis,
        "analysis_method": report.analysis_method,
        "llm_model_used": report.llm_model_used,
        "analysis_duration_seconds": report.analysis_duration_seconds,
        "pdf_report_url": report.pdf_report_url,
        "created_at": report.created_at.isoformat() if report.created_at else None,
        "updated_at": report.updated_at.isoformat() if report.updated_at else None,
    }

    # Запускаем Celery задачу для генерации PDF
    task = generate_pdf_report_task.delay(
        report_data=report_data,
        candidate_name=resume.applicant_name,
        position=position,
        resume_file_url=resume.resume_file_url,
    )

    return {
        "message": "PDF generation started",
        "resume_id": resume_id,
        "report_id": report.id,
        "candidate_name": resume.applicant_name,
        "task_id": task.id,
        "status": "in_progress",
    }


@router.get("/pdf-task-status/{task_id}")
async def get_pdf_task_status(task_id: str):
    """
    Получить статус выполнения Celery задачи генерации PDF
    """
    from celery_worker.celery_app import celery_app

    try:
        task_result = celery_app.AsyncResult(task_id)

        if task_result.state == "PENDING":
            return {
                "task_id": task_id,
                "status": "pending",
                "message": "Task is waiting to be processed",
            }
        elif task_result.state == "PROGRESS":
            return {
                "task_id": task_id,
                "status": "in_progress",
                "progress": task_result.info.get("progress", 0),
                "message": task_result.info.get("status", "Processing..."),
            }
        elif task_result.state == "SUCCESS":
            result = task_result.result
            return {
                "task_id": task_id,
                "status": "completed",
                "progress": 100,
                "message": "PDF generation completed successfully",
                "pdf_url": result.get("pdf_url"),
                "file_size": result.get("file_size"),
                "report_id": result.get("interview_report_id"),
            }
        elif task_result.state == "FAILURE":
            return {
                "task_id": task_id,
                "status": "failed",
                "message": str(task_result.info),
                "error": str(task_result.info),
            }
        else:
            return {
                "task_id": task_id,
                "status": task_result.state.lower(),
                "message": f"Task state: {task_result.state}",
            }

    except Exception as e:
        raise HTTPException(
            status_code=500, detail=f"Error checking task status: {str(e)}"
        )


@router.get("/report-data/{resume_id}")
async def get_report_data(
    resume_id: int,
    session=Depends(get_session),
    resume_repo: ResumeRepository = Depends(ResumeRepository),
):
    """
    Получить данные отчета в JSON формате (без PDF)
    """
    from sqlmodel import select

    from app.models.interview import InterviewSession
    from app.models.interview_report import InterviewReport

    # Проверяем, существует ли резюме
    resume = await resume_repo.get_by_id(resume_id)
    if not resume:
        raise HTTPException(status_code=404, detail="Resume not found")

    # Ищем отчет
    statement = (
        select(InterviewReport, InterviewSession)
        .join(
            InterviewSession,
            InterviewReport.interview_session_id == InterviewSession.id,
        )
        .where(InterviewSession.resume_id == resume_id)
    )

    result = await session.execute(statement)
    report_session = result.first()

    if not report_session:
        raise HTTPException(status_code=404, detail="Interview report not found")

    report, interview_session = report_session

    # Получаем позицию из связанной вакансии
    from app.models.vacancy import Vacancy

    vacancy_stmt = select(Vacancy).where(Vacancy.id == resume.vacancy_id)
    vacancy_result = await session.execute(vacancy_stmt)
    vacancy = vacancy_result.scalar_one_or_none()

    position = vacancy.title if vacancy else "Позиция не указана"

    return {
        "report_id": report.id,
        "candidate_name": resume.applicant_name,
        "position": position,
        "interview_date": report.created_at.isoformat(),
        "overall_score": report.overall_score,
        "recommendation": report.recommendation.value,
        "scores": {
            "technical_skills": {
                "score": report.technical_skills_score,
                "justification": report.technical_skills_justification,
                "concerns": report.technical_skills_concerns,
            },
            "experience_relevance": {
                "score": report.experience_relevance_score,
                "justification": report.experience_relevance_justification,
                "concerns": report.experience_relevance_concerns,
            },
            "communication": {
                "score": report.communication_score,
                "justification": report.communication_justification,
                "concerns": report.communication_concerns,
            },
            "problem_solving": {
                "score": report.problem_solving_score,
                "justification": report.problem_solving_justification,
                "concerns": report.problem_solving_concerns,
            },
            "cultural_fit": {
                "score": report.cultural_fit_score,
                "justification": report.cultural_fit_justification,
                "concerns": report.cultural_fit_concerns,
            },
        },
        "strengths": report.strengths,
        "weaknesses": report.weaknesses,
        "red_flags": report.red_flags,
        "next_steps": report.next_steps,
        "metrics": {
            "interview_duration_minutes": report.interview_duration_minutes,
            "dialogue_messages_count": report.dialogue_messages_count,
            "questions_quality_score": report.questions_quality_score,
        },
        "pdf_available": bool(report.pdf_report_url),
        "pdf_url": report.pdf_report_url,
        "analysis_metadata": {
            "method": report.analysis_method,
            "model_used": report.llm_model_used,
            "analysis_duration": report.analysis_duration_seconds,
        },
    }