app/routes/reports.py

"""
API routes for report generation.
"""
from fastapi import APIRouter, HTTPException, Depends, status
from fastapi.responses import FileResponse
from sqlalchemy.orm import Session
from typing import Optional, Dict
from pydantic import BaseModel
import os

from app.database.connection import get_db
from app.database.models import User, Report
from app.middleware.auth import get_current_user_optional
from app.services.report_service import report_generation_service


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


class GenerateContentRequest(BaseModel):
    """Request schema for AI content generation."""
    section_name: str
    context: Dict[str, str] = {}


class GenerateReportRequest(BaseModel):
    """Request schema for full report generation."""
    template_id: str
    data: Dict[str, str]


@router.post("/generate-content")
async def generate_section_content(
    request: GenerateContentRequest,
    db: Session = Depends(get_db),
    current_user: Optional[User] = Depends(get_current_user_optional)
):
    """
    Generate AI content for a report section.
    
    Args:
        request: Generation request with section name and context
        db: Database session
        current_user: Optional current user
        
    Returns:
        Generated content
    """
    try:
        content = report_generation_service.generate_section_content(
            section_name=request.section_name,
            context=request.context
        )
        
        return {
            "success": True,
            "content": content,
            "section_name": request.section_name
        }
        
    except Exception as e:
        print(f"Error generating report content: {e}")
        raise HTTPException(
            status_code=500,
            detail=f"Error generating content: {str(e)}"
        )


@router.post("/generate")
async def generate_report(
    request: GenerateReportRequest,
    current_user: Optional[User] = Depends(get_current_user_optional)
):
    """
    Generate a full report and return its ID.
    """
    try:
        user_id = current_user.id if current_user else None
        report_id = report_generation_service.generate_full_pdf(
            template_id=request.template_id,
            data=request.data,
            user_id=user_id
        )
        return {"report_id": report_id, "success": True}
    except Exception as e:
        print(f"Error generating report: {e}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=str(e)
        )


@router.get("/download-pdf/{report_id}")
async def download_report_pdf(
    report_id: str,
    db: Session = Depends(get_db)
):
    """
    Download a generated PDF report.
    """
    report = db.query(Report).filter(Report.id == report_id).first()
    if not report:
        raise HTTPException(status_code=404, detail="Report not found")
        
    if not os.path.exists(report.file_path):
        raise HTTPException(status_code=404, detail="Report file not found")
        
    return FileResponse(
        path=report.file_path,
        filename=report.filename,
        media_type="application/pdf"
    )