app/main.py

from __future__ import annotations

from fastapi import BackgroundTasks, FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware

from .config import get_settings
from .email import EmailClient
from .llm import LocalLLM
from .models import AnswerPayload, AnswerResponse, ReportResponse, SessionCreate, SessionResponse
from .session import SessionManager
from .stt.whisper import WhisperService
from .agent import InterviewAgent

settings = get_settings()
session_manager = SessionManager(ttl_minutes=settings.session_ttl_minutes, questions_per_block=3)
whisper_service = WhisperService(settings.whisper_model)
email_client = EmailClient(settings)
llm_client = LocalLLM(settings.llm_model, settings.llm_local_path)
interview_agent = InterviewAgent(session_manager, llm_client)

app = FastAPI(title=settings.app_name)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"] ,
    allow_headers=["*"],
)


@app.get("/healthz")
async def healthcheck():
    return {"status": "ok"}


@app.post("/session", response_model=SessionResponse)
async def create_session(payload: SessionCreate):
    state = await session_manager.create_session(payload)
    question = await interview_agent.start(state)
    if not question:
        raise HTTPException(status_code=500, detail="Не удалось создать вопрос")
    return SessionResponse(sessionId=state.id, nextQuestion=question)


@app.post("/answer", response_model=AnswerResponse)
async def submit_answer(payload: AnswerPayload, background_tasks: BackgroundTasks):
    state = await session_manager.get_session(payload.sessionId)
    if not state:
        raise HTTPException(status_code=404, detail="Сессия не найдена")
    transcript = whisper_service.transcribe_base64(payload.audio)
    response = await interview_agent.handle_answer(state, payload.questionId, transcript)
    if response.markdownReport:
        state.markdown = response.markdownReport
        background_tasks.add_task(
            email_client.send_report,
            to_client=state.client.email,
            to_trainer=settings.trainer_email,
            markdown=response.markdownReport,
        )
    return response


@app.get("/report/{session_id}", response_model=ReportResponse)
async def get_report(session_id: str):
    state = await session_manager.get_session(session_id)
    if not state or not state.markdown:
        raise HTTPException(status_code=404, detail="Отчёт не найден")
    return ReportResponse(sessionId=session_id, markdown=state.markdown)