"""FastAPI router for Content Brief v2 — struggle-first pipeline."""

import os
from fastapi import APIRouter, HTTPException, Query, Header, Depends
from typing import Optional

from .models import (
BriefListResponse,
BriefDetailResponse,
CreateBriefRequest,
UpdateBriefRequest,
SubmitBriefResponse,
ApproveBriefResponse,
RejectBriefResponse,
BriefOutputResponse,
StruggleScoreResponse,
StyleReferenceListResponse,
StyleReference,
)
from .brief_service import (
create_brief, get_brief, list_briefs, update_brief,
submit_brief, approve_brief, reject_brief, update_generation_status,
calculate_struggle_score,
BriefNotFoundError, BriefValidationError,
)
from .service import list_posts # For style references

from .notifications import on_brief_submitted, on_brief_approved

from .generation_v2 import trigger_generation
from .notifications import on_brief_submitted, on_brief_approved

Admin token auth — same as main router

ADMIN_TOKEN = os.getenv("BLOG_ADMIN_TOKEN", "changeme-please-update")

def verify_admin_token(x_admin_token: str = Header(None)) -> str:
"""Verify admin token from header."""
if x_admin_token != ADMIN_TOKEN:
raise HTTPException(status_code=401, detail="Unauthorized - invalid or missing token")
return x_admin_token

router = APIRouter(tags=["content-briefs"])

@router.post("/", response_model=BriefDetailResponse)
async def api_create_brief(
request: CreateBriefRequest,
token: str = Depends(verify_admin_token),
):
"""Create a new content brief."""
brief = create_brief(request)
return {"brief": brief}

@router.get("/", response_model=BriefListResponse)
async def api_list_briefs(
status: Optional[str] = Query(None, description="Filter by status"),
created_by: Optional[str] = Query(None, description="Filter by creator"),
page: int = Query(1, ge=1),
per_page: int = Query(20, ge=1, le=100),
token: str = Depends(verify_admin_token),
):
"""List content briefs with optional filtering."""
briefs, total = list_briefs(status=status, created_by=created_by, page=page, per_page=per_page)
total_pages = (total + per_page - 1) // per_page
return {
"briefs": briefs,
"total": total,
"page": page,
"per_page": per_page,
"total_pages": total_pages,
}

@router.get("/{brief_id}", response_model=BriefDetailResponse)
async def api_get_brief(
brief_id: str,
token: str = Depends(verify_admin_token),
):
"""Get a single content brief by ID."""
try:
brief = get_brief(brief_id)
return {"brief": brief}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")

@router.patch("/{brief_id}", response_model=BriefDetailResponse)
async def api_update_brief(
brief_id: str,
request: UpdateBriefRequest,
token: str = Depends(verify_admin_token),
):
"""Update an existing brief. Only works in draft or rejected status."""
try:
brief = update_brief(brief_id, request)
return {"brief": brief}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")
except BriefValidationError as e:
raise HTTPException(status_code=400, detail=str(e))

@router.post("/{brief_id}/submit", response_model=SubmitBriefResponse)
async def api_submit_brief(
brief_id: str,
token: str = Depends(verify_admin_token),
):
"""Submit a brief for approval. Validates voice checklist first."""
try:
brief = submit_brief(brief_id)
# Notify Matt via Telegram
on_brief_submitted(brief.id, brief.title, brief.created_by)
return {
"id": brief.id,
"status": brief.status,
"message": "Brief submitted for approval. Awaiting review.",
}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")
except BriefValidationError as e:
raise HTTPException(status_code=400, detail=str(e))

@router.post("/{brief_id}/approve", response_model=ApproveBriefResponse)
async def api_approve_brief(
brief_id: str,
token: str = Depends(verify_admin_token),
):
"""Approve a brief and trigger generation. Matt-only."""
try:
brief = approve_brief(brief_id, approved_by="matt")
# Notify via Telegram
on_brief_approved(brief.id, brief.title, brief.generation_job_id or "")
# Trigger content generation
trigger_generation(brief_id)
return {
"id": brief.id,
"status": brief.status,
"message": "Brief approved. Generation started.",
"generation_job_id": brief.generation_job_id,
}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")
except BriefValidationError as e:
raise HTTPException(status_code=400, detail=str(e))

@router.post("/{brief_id}/reject", response_model=RejectBriefResponse)
async def api_reject_brief(
brief_id: str,
feedback: str = Query("", description="Rejection feedback"),
token: str = Depends(verify_admin_token),
):
"""Reject a brief and return to draft with feedback."""
try:
brief = reject_brief(brief_id, feedback=feedback)
return {
"id": brief.id,
"status": brief.status,
"message": f"Brief rejected. Feedback appended to reflection.",
}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")
except BriefValidationError as e:
raise HTTPException(status_code=400, detail=str(e))

@router.get("/{brief_id}/output", response_model=BriefOutputResponse)
async def api_get_brief_output(
brief_id: str,
token: str = Depends(verify_admin_token),
):
"""Get generated content output for a brief."""
try:
brief = get_brief(brief_id)
if brief.status != "completed":
raise HTTPException(status_code=400, detail=f"Brief status is '{brief.status}', not 'completed'")
return {
"id": brief.id,
"title": brief.title,
"content_md": brief.content_output or "",
"content_html": brief.content_html or "",
"struggle_score": brief.struggle_score,
"generated_at": brief.updated_at,
}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")

@router.post("/{brief_id}/score", response_model=StruggleScoreResponse)
async def api_calculate_score(
brief_id: str,
token: str = Depends(verify_admin_token),
):
"""Calculate struggle score for a brief's generated content."""
try:
brief = get_brief(brief_id)
if not brief.content_output:
raise HTTPException(status_code=400, detail="Brief has no generated content to score")
result = calculate_struggle_score(brief.content_output)
return {
"score": result["score"],
"max_score": 100.0,
"checks": result["checks"],
"interpretation": result["interpretation"],
}
except BriefNotFoundError:
raise HTTPException(status_code=404, detail=f"Brief '{brief_id}' not found")

@router.get("/style-references", response_model=StyleReferenceListResponse)
async def api_list_style_references(
limit: int = Query(20, ge=1, le=100),
token: str = Depends(verify_admin_token),
):
"""List published posts that can be used as style references."""
posts, _ = list_posts(status="published", page=1, per_page=limit)
styles = [
StyleReference(
slug=p.slug,
title=p.title,
excerpt=p.excerpt or "",
)
for p in posts
]
return {"styles": styles}