hyungi_document_server/app/api/briefing.py

"""Morning Briefing API — read-only + 수동 regenerate.

엔드포인트:
- GET  /api/briefing/latest                : 가장 최근 briefing
- GET  /api/briefing?date=YYYY-MM-DD       : 특정 날짜 briefing
- POST /api/briefing/regenerate?date=...   : 동기 워커 트리거 (admin), DELETE+INSERT tx

응답은 topic 평면 list (axis 반대 — Phase 4 와 달리 country 그룹 X).
각 topic 안에 country_perspectives JSONB 가 들어있어 cross-country 비교 분석을 표현.
"""

from datetime import date as date_type
from datetime import datetime
from typing import Annotated

from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from core.auth import get_current_user, require_admin
from core.database import get_session
from models.briefing import BriefingTopic, MorningBriefing
from models.user import User

router = APIRouter()


# ─── Pydantic 응답 모델 ───


class CountryPerspective(BaseModel):
    country: str
    summary: str
    article_ids: list[int] = []


class KeyQuote(BaseModel):
    country: str = ""
    source: str = ""
    quote: str


class TopicResponse(BaseModel):
    topic_rank: int
    topic_label: str
    headline: str
    country_perspectives: list[CountryPerspective]
    divergences: list[str]
    convergences: list[str]
    key_quotes: list[KeyQuote]
    historical_context: str | None = None
    cluster_members: list[int] = []
    article_count: int
    country_count: int
    importance_score: float
    llm_fallback_used: bool


class BriefingResponse(BaseModel):
    briefing_date: date_type
    window_start: datetime
    window_end: datetime
    decay_lambda: float
    total_articles: int
    total_countries: int
    total_topics: int
    generation_ms: int | None
    llm_calls: int
    llm_failures: int
    status: str
    headline_oneliner: str | None = None
    topics: list[TopicResponse]


class RegenerateResponse(BaseModel):
    status: str
    briefing_id: int | None
    briefing_date: date_type
    total_topics: int
    total_articles: int
    llm_calls: int
    llm_failures: int
    generation_ms: int
    regenerated: bool


# ─── helpers ───


def _build_response(b: MorningBriefing) -> BriefingResponse:
    topics = []
    for t in sorted(b.topics, key=lambda x: x.topic_rank):
        topics.append(
            TopicResponse(
                topic_rank=t.topic_rank,
                topic_label=t.topic_label,
                headline=t.headline,
                country_perspectives=[
                    CountryPerspective(**cp) for cp in (t.country_perspectives or [])
                ],
                divergences=list(t.divergences or []),
                convergences=list(t.convergences or []),
                key_quotes=[KeyQuote(**q) for q in (t.key_quotes or [])],
                historical_context=t.historical_context,
                cluster_members=list(t.cluster_members or []),
                article_count=t.article_count,
                country_count=t.country_count,
                importance_score=t.importance_score,
                llm_fallback_used=t.llm_fallback_used,
            )
        )

    return BriefingResponse(
        briefing_date=b.briefing_date,
        window_start=b.window_start,
        window_end=b.window_end,
        decay_lambda=b.decay_lambda,
        total_articles=b.total_articles,
        total_countries=b.total_countries,
        total_topics=b.total_topics,
        generation_ms=b.generation_ms,
        llm_calls=b.llm_calls,
        llm_failures=b.llm_failures,
        status=b.status,
        headline_oneliner=b.headline_oneliner,
        topics=topics,
    )


async def _load_briefing(
    session: AsyncSession,
    target_date: date_type | None,
) -> MorningBriefing | None:
    query = select(MorningBriefing).options(selectinload(MorningBriefing.topics))
    if target_date is not None:
        query = query.where(MorningBriefing.briefing_date == target_date)
    else:
        query = query.order_by(MorningBriefing.briefing_date.desc())
    query = query.limit(1)
    result = await session.execute(query)
    return result.scalar_one_or_none()


# ─── Routes ───


@router.get("/latest", response_model=BriefingResponse)
async def get_latest(
    user: Annotated[User, Depends(get_current_user)],
    session: Annotated[AsyncSession, Depends(get_session)],
):
    """가장 최근 morning briefing."""
    b = await _load_briefing(session, target_date=None)
    if b is None:
        raise HTTPException(status_code=404, detail="아직 생성된 briefing 없음")
    return _build_response(b)


@router.get("", response_model=BriefingResponse)
async def get_briefing(
    user: Annotated[User, Depends(get_current_user)],
    session: Annotated[AsyncSession, Depends(get_session)],
    date: date_type | None = Query(default=None, description="YYYY-MM-DD (KST briefing_date)"),
):
    """특정 날짜 briefing (date 미지정 시 최신)."""
    b = await _load_briefing(session, target_date=date)
    if b is None:
        raise HTTPException(
            status_code=404,
            detail=f"briefing 없음 (date={date})" if date else "아직 생성된 briefing 없음",
        )
    return _build_response(b)


@router.post("/regenerate", response_model=RegenerateResponse)
async def regenerate(
    user: Annotated[User, Depends(require_admin)],
    date: date_type | None = Query(default=None, description="YYYY-MM-DD KST 기준 briefing_date"),
):
    """수동 트리거 (admin). 동기 실행 — delete+insert transaction.

    date 미지정 시 오늘 KST. 같은 날 row 존재 시 transaction 안에서 삭제 후 신규 생성.
    응답 status='success' | 'partial' | 'failed' | 'empty'.
    """
    from workers.briefing_worker import run

    result = await run(target_date=date)
    if result is None:
        raise HTTPException(status_code=500, detail="briefing 워커 실행 실패 (로그 확인)")

    return RegenerateResponse(
        status=result["status"],
        briefing_id=result.get("briefing_id"),
        briefing_date=date or datetime.now().date(),
        total_topics=result["total_topics"],
        total_articles=result["total_articles"],
        llm_calls=result["llm_calls"],
        llm_failures=result["llm_failures"],
        generation_ms=result["generation_ms"],
        regenerated=result.get("regenerated", True),
    )