feat(export): implement comprehensive document export system

- Add export service with PDF, Excel, CSV and bulk export capabilities
- Integrate PDF generation into Tiradentes agent with _render_pdf method
- Create export API routes for investigations, contracts and anomalies
- Add support for bulk export with ZIP compression
- Include comprehensive test coverage for export functionality
- Update requirements.txt with reportlab, openpyxl, markdown, beautifulsoup4

The system now supports full document export in multiple formats:
- PDF generation with custom styling and metadata
- Excel export with multiple sheets and formatting
- CSV export for data analysis
- Bulk export with ZIP compression for multiple files

requirements.txt

@@ -36,4 +36,11 @@ graphql-core>=3.2.0
 
 # Basic OpenTelemetry without complex dependencies
 opentelemetry-api==1.21.0
-opentelemetry-sdk==1.21.0
+opentelemetry-sdk==1.21.0
+
+# Export libraries
+reportlab>=4.0.9
+openpyxl>=3.1.2
+markdown>=3.5.1
+beautifulsoup4>=4.12.2
+weasyprint>=60.2

src/agents/tiradentes.py

@@ -18,6 +18,7 @@ from pydantic import BaseModel, Field as PydanticField
 from src.agents.deodoro import BaseAgent, AgentContext, AgentMessage, AgentResponse
 from src.core import get_logger, AgentStatus
 from src.core.exceptions import AgentExecutionError
+from src.services.export_service import export_service
 
 
 class ReportFormat(str, Enum):
@@ -127,6 +128,7 @@ class ReporterAgent(BaseAgent):
             ReportFormat.MARKDOWN: self._render_markdown,
             ReportFormat.HTML: self._render_html,
             ReportFormat.JSON: self._render_json,
+            ReportFormat.PDF: self._render_pdf,
             ReportFormat.EXECUTIVE_SUMMARY: self._render_executive_summary,
         }
         
@@ -1034,4 +1036,32 @@ class ReporterAgent(BaseAgent):
             content.append(f"Explicação: {anomaly.get('explanation', 'N/A')}")
             content.append("")
         
-        return "\n".join(content)
+        return "\n".join(content)
+    
+    async def _render_pdf(
+        self,
+        sections: List[ReportSection],
+        request: ReportRequest,
+        context: AgentContext
+    ) -> str:
+        """Render report in PDF format and return base64 encoded string."""
+        # First convert sections to markdown
+        markdown_content = await self._render_markdown(sections, request, context)
+        
+        # Generate PDF using export service
+        pdf_bytes = await export_service.generate_pdf(
+            content=markdown_content,
+            title=f"Relatório: {request.report_type.value.replace('_', ' ').title()}",
+            metadata={
+                'generated_at': datetime.utcnow().isoformat(),
+                'report_type': request.report_type.value,
+                'investigation_id': context.investigation_id,
+                'target_audience': request.target_audience,
+                'author': 'Agente Tiradentes - Cidadão.AI'
+            },
+            format_type="report"
+        )
+        
+        # Return base64 encoded PDF for easy transmission
+        import base64
+        return base64.b64encode(pdf_bytes).decode('utf-8')

src/api/app.py

@@ -287,6 +287,13 @@ app.include_router(
     tags=["Reports"]
 )
 
+from src.api.routes import export
+app.include_router(
+    export.router,
+    prefix="/api/v1/export",
+    tags=["Export"]
+)
+
 app.include_router(
     chat.router,
     prefix="/api/v1/chat",

src/api/routes/export.py

@@ -0,0 +1,387 @@
+"""
+Module: api.routes.export
+Description: Export endpoints for downloading investigations, reports and data
+Author: Anderson H. Silva
+Date: 2025-01-25
+License: Proprietary - All rights reserved
+"""
+
+import io
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Union
+from uuid import uuid4
+
+from fastapi import APIRouter, HTTPException, Depends, Query, Response
+from fastapi.responses import StreamingResponse
+import pandas as pd
+from pydantic import BaseModel, Field as PydanticField, validator
+
+from src.core import json_utils
+from src.core import get_logger
+from src.api.middleware.authentication import get_current_user
+from src.services.export_service import export_service
+from src.services.investigation_service import investigation_service
+from src.services.data_service import data_service
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+
+class ExportRequest(BaseModel):
+    """Request model for data export."""
+    
+    export_type: str = PydanticField(description="Type of data to export")
+    format: str = PydanticField(description="Export format")
+    filters: Optional[Dict[str, Any]] = PydanticField(default={}, description="Filters to apply")
+    include_metadata: bool = PydanticField(default=True, description="Include metadata")
+    compress: bool = PydanticField(default=False, description="Compress output")
+    
+    @validator('export_type')
+    def validate_export_type(cls, v):
+        """Validate export type."""
+        allowed_types = [
+            'investigations', 'contracts', 'anomalies', 
+            'reports', 'analytics', 'full_data'
+        ]
+        if v not in allowed_types:
+            raise ValueError(f'Export type must be one of: {allowed_types}')
+        return v
+    
+    @validator('format')
+    def validate_format(cls, v):
+        """Validate export format."""
+        allowed_formats = ['excel', 'csv', 'json', 'pdf']
+        if v not in allowed_formats:
+            raise ValueError(f'Format must be one of: {allowed_formats}')
+        return v
+
+
+class BulkExportRequest(BaseModel):
+    """Request model for bulk export."""
+    
+    exports: List[Dict[str, Any]] = PydanticField(description="List of exports to generate")
+    compress: bool = PydanticField(default=True, description="Compress all exports")
+    
+    @validator('exports')
+    def validate_exports(cls, v):
+        """Validate exports list."""
+        if not v:
+            raise ValueError('At least one export must be specified')
+        if len(v) > 50:
+            raise ValueError('Maximum 50 exports allowed per request')
+        return v
+
+
+@router.post("/investigations/{investigation_id}/download")
+async def export_investigation(
+    investigation_id: str,
+    format: str = Query("excel", description="Export format: excel, csv, pdf, json"),
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Export investigation data in various formats.
+    
+    Exports complete investigation data including anomalies, 
+    contracts, and analysis results.
+    """
+    # Get investigation data
+    investigation = await investigation_service.get_investigation(
+        investigation_id, 
+        user_id=current_user.get("user_id")
+    )
+    
+    if not investigation:
+        raise HTTPException(status_code=404, detail="Investigation not found")
+    
+    filename = f"investigation_{investigation_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    if format == "excel":
+        # Convert to Excel
+        file_bytes = await export_service.convert_investigation_to_excel(investigation)
+        
+        return Response(
+            content=file_bytes,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.xlsx"
+            }
+        )
+    
+    elif format == "csv":
+        # Create CSV with main data
+        main_data = {
+            'investigation_id': investigation['id'],
+            'type': investigation['type'],
+            'status': investigation['status'],
+            'created_at': investigation['created_at'],
+            'anomalies_count': len(investigation.get('anomalies', [])),
+            'total_value': investigation.get('total_value', 0),
+        }
+        
+        df = pd.DataFrame([main_data])
+        csv_bytes = await export_service.generate_csv(df)
+        
+        return Response(
+            content=csv_bytes,
+            media_type="text/csv",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.csv"
+            }
+        )
+    
+    elif format == "pdf":
+        # Generate PDF report
+        content = _format_investigation_as_markdown(investigation)
+        pdf_bytes = await export_service.generate_pdf(
+            content=content,
+            title=f"Investigação {investigation_id}",
+            metadata={
+                'investigation_id': investigation_id,
+                'generated_at': datetime.now().isoformat(),
+                'user': current_user.get('email', 'Unknown')
+            }
+        )
+        
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.pdf"
+            }
+        )
+    
+    elif format == "json":
+        return Response(
+            content=json_utils.dumps(investigation, indent=2, ensure_ascii=False),
+            media_type="application/json",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.json"
+            }
+        )
+    
+    else:
+        raise HTTPException(status_code=400, detail="Unsupported format")
+
+
+@router.post("/contracts/export")
+async def export_contracts(
+    request: ExportRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Export contract data with filters.
+    
+    Allows exporting filtered contract data in various formats.
+    """
+    # Apply filters
+    filters = request.filters or {}
+    
+    # Get contracts data
+    contracts = await data_service.search_contracts(
+        **filters,
+        limit=10000  # Reasonable limit for exports
+    )
+    
+    if not contracts:
+        raise HTTPException(status_code=404, detail="No contracts found with given filters")
+    
+    filename = f"contracts_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    if request.format == "excel":
+        # Convert to DataFrame
+        df = pd.DataFrame(contracts)
+        
+        # Generate Excel with formatting
+        excel_bytes = await export_service.generate_excel(
+            data=df,
+            title="Contratos - Portal da Transparência",
+            metadata={
+                'exported_at': datetime.now().isoformat(),
+                'total_records': len(contracts),
+                'filters': filters
+            }
+        )
+        
+        return Response(
+            content=excel_bytes,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.xlsx"
+            }
+        )
+    
+    elif request.format == "csv":
+        df = pd.DataFrame(contracts)
+        csv_bytes = await export_service.generate_csv(df)
+        
+        return Response(
+            content=csv_bytes,
+            media_type="text/csv",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.csv"
+            }
+        )
+    
+    else:
+        raise HTTPException(status_code=400, detail="Format not supported for contracts export")
+
+
+@router.post("/anomalies/export")
+async def export_anomalies(
+    request: ExportRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Export anomaly data with filters.
+    
+    Exports detected anomalies in various formats.
+    """
+    # Get anomalies from investigations
+    filters = request.filters or {}
+    
+    # For now, get anomalies from recent investigations
+    # In production, this would query a dedicated anomalies table
+    investigations = await investigation_service.list_investigations(
+        user_id=current_user.get("user_id"),
+        status="completed",
+        limit=100
+    )
+    
+    all_anomalies = []
+    for inv in investigations:
+        anomalies = inv.get('anomalies', [])
+        for anomaly in anomalies:
+            anomaly['investigation_id'] = inv['id']
+            all_anomalies.append(anomaly)
+    
+    if not all_anomalies:
+        raise HTTPException(status_code=404, detail="No anomalies found")
+    
+    filename = f"anomalies_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+    
+    if request.format == "excel":
+        df = pd.DataFrame(all_anomalies)
+        
+        # Separate by severity
+        high_severity = df[df['severity'] >= 0.7]
+        medium_severity = df[(df['severity'] >= 0.4) & (df['severity'] < 0.7)]
+        low_severity = df[df['severity'] < 0.4]
+        
+        dataframes = {
+            'Alta Severidade': high_severity,
+            'Média Severidade': medium_severity,
+            'Baixa Severidade': low_severity,
+            'Todas Anomalias': df
+        }
+        
+        excel_bytes = await export_service.generate_excel(
+            data=dataframes,
+            title="Anomalias Detectadas - Cidadão.AI",
+            metadata={
+                'exported_at': datetime.now().isoformat(),
+                'total_anomalies': len(all_anomalies),
+                'high_severity_count': len(high_severity),
+                'medium_severity_count': len(medium_severity),
+                'low_severity_count': len(low_severity),
+            }
+        )
+        
+        return Response(
+            content=excel_bytes,
+            media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            headers={
+                "Content-Disposition": f"attachment; filename={filename}.xlsx"
+            }
+        )
+    
+    else:
+        raise HTTPException(status_code=400, detail="Format not supported for anomalies export")
+
+
+@router.post("/bulk")
+async def bulk_export(
+    request: BulkExportRequest,
+    current_user: Dict[str, Any] = Depends(get_current_user)
+):
+    """
+    Create bulk export with multiple files.
+    
+    Generates a ZIP file containing multiple exports.
+    """
+    exports_config = []
+    
+    for export in request.exports:
+        export_type = export.get('type')
+        export_format = export.get('format', 'json')
+        
+        if export_type == 'investigation':
+            investigation = await investigation_service.get_investigation(
+                export['id'],
+                user_id=current_user.get("user_id")
+            )
+            
+            if investigation:
+                if export_format == 'pdf':
+                    content = _format_investigation_as_markdown(investigation)
+                    exports_config.append({
+                        'filename': f"investigation_{export['id']}.pdf",
+                        'content': content,
+                        'format': 'pdf',
+                        'title': f"Investigação {export['id']}",
+                        'metadata': {'investigation_id': export['id']}
+                    })
+                else:
+                    exports_config.append({
+                        'filename': f"investigation_{export['id']}.json",
+                        'content': json_utils.dumps(investigation, indent=2),
+                        'format': 'json'
+                    })
+    
+    if not exports_config:
+        raise HTTPException(status_code=404, detail="No data found for bulk export")
+    
+    # Generate ZIP
+    zip_bytes = await export_service.generate_bulk_export(exports_config)
+    
+    return Response(
+        content=zip_bytes,
+        media_type="application/zip",
+        headers={
+            "Content-Disposition": f"attachment; filename=bulk_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+        }
+    )
+
+
+def _format_investigation_as_markdown(investigation: Dict[str, Any]) -> str:
+    """Format investigation data as markdown for PDF generation."""
+    lines = []
+    
+    lines.append(f"# Investigação {investigation['id']}")
+    lines.append("")
+    lines.append(f"**Tipo**: {investigation.get('type', 'N/A')}")
+    lines.append(f"**Status**: {investigation.get('status', 'N/A')}")
+    lines.append(f"**Data de Criação**: {investigation.get('created_at', 'N/A')}")
+    lines.append("")
+    
+    if investigation.get('summary'):
+        lines.append("## Resumo")
+        lines.append(investigation['summary'])
+        lines.append("")
+    
+    anomalies = investigation.get('anomalies', [])
+    if anomalies:
+        lines.append("## Anomalias Detectadas")
+        lines.append("")
+        lines.append(f"Total de anomalias: {len(anomalies)}")
+        lines.append("")
+        
+        for i, anomaly in enumerate(anomalies, 1):
+            lines.append(f"### Anomalia {i}")
+            lines.append(f"**Tipo**: {anomaly.get('type', 'N/A')}")
+            lines.append(f"**Severidade**: {anomaly.get('severity', 0):.2f}")
+            lines.append(f"**Descrição**: {anomaly.get('description', 'N/A')}")
+            lines.append(f"**Explicação**: {anomaly.get('explanation', 'N/A')}")
+            lines.append("")
+    
+    return "\n".join(lines)

src/api/routes/reports.py

@@ -16,7 +16,8 @@ from fastapi.responses import HTMLResponse, FileResponse
 from pydantic import BaseModel, Field as PydanticField, validator
 from src.core import json_utils
 from src.core import get_logger
-from src.agents import ReporterAgent, AgentContext
+from src.agents.tiradentes import ReporterAgent
+from src.agents import AgentContext
 from src.api.middleware.authentication import get_current_user
 
 
@@ -346,6 +347,34 @@ async def download_report(
             }
         )
     
+    elif format == "pdf":
+        # Check if content is base64 encoded PDF
+        import base64
+        try:
+            # If content is already a base64 PDF, decode it
+            if report["output_format"] == "pdf":
+                pdf_bytes = base64.b64decode(content)
+            else:
+                # Convert markdown/html content to PDF
+                from src.services.export_service import export_service
+                pdf_bytes = await export_service.generate_pdf(
+                    content=content,
+                    title=report["title"],
+                    metadata=report["metadata"],
+                    format_type="report"
+                )
+            
+            return Response(
+                content=pdf_bytes,
+                media_type="application/pdf",
+                headers={
+                    "Content-Disposition": f"attachment; filename={title}.pdf"
+                }
+            )
+        except Exception as e:
+            logger.error("pdf_download_error", error=str(e), report_id=report_id)
+            raise HTTPException(status_code=500, detail="Failed to generate PDF")
+    
     else:
         raise HTTPException(status_code=400, detail="Unsupported format")
 
@@ -458,47 +487,56 @@ async def _generate_report(report_id: str, request: ReportRequest):
         report["current_phase"] = "content_generation"
         report["progress"] = 0.3
         
-        # Generate report content based on type
-        if request.report_type == "executive_summary":
-            content = await reporter.generate_executive_summary(
-                investigation_ids=request.investigation_ids,
-                analysis_ids=request.analysis_ids,
-                time_range=request.time_range,
-                context=context
-            )
-        elif request.report_type == "detailed_analysis":
-            content = await reporter.generate_detailed_analysis(
-                data_sources=request.data_sources,
-                analysis_ids=request.analysis_ids,
-                time_range=request.time_range,
-                context=context
-            )
-        elif request.report_type == "investigation_report":
-            content = await reporter.generate_investigation_report(
-                investigation_ids=request.investigation_ids,
-                include_evidence=True,
-                context=context
-            )
-        else:
-            content = await reporter.generate_custom_report(
-                report_type=request.report_type,
-                title=request.title,
-                data_sources=request.data_sources,
-                investigation_ids=request.investigation_ids,
-                analysis_ids=request.analysis_ids,
-                context=context
-            )
+        # Create report request for Tiradentes
+        from src.agents.tiradentes import ReportRequest as TiradentesReportRequest, ReportType, ReportFormat
+        
+        # Map report type
+        report_type_map = {
+            "executive_summary": ReportType.EXECUTIVE_SUMMARY,
+            "detailed_analysis": ReportType.ANALYSIS_REPORT,
+            "investigation_report": ReportType.INVESTIGATION_REPORT,
+            "transparency_dashboard": ReportType.COMBINED_REPORT,
+            "comparative_analysis": ReportType.TREND_ANALYSIS,
+            "audit_report": ReportType.INVESTIGATION_REPORT,
+        }
+        
+        # Map format
+        format_map = {
+            "markdown": ReportFormat.MARKDOWN,
+            "html": ReportFormat.HTML,
+            "json": ReportFormat.JSON,
+            "pdf": ReportFormat.PDF,
+        }
+        
+        tiradentes_request = TiradentesReportRequest(
+            report_type=report_type_map.get(request.report_type, ReportType.INVESTIGATION_REPORT),
+            format=format_map.get(request.output_format, ReportFormat.MARKDOWN),
+            target_audience=request.target_audience,
+            language="pt-BR",
+        )
+        
+        # Process with Tiradentes
+        from src.agents import AgentMessage
+        message = AgentMessage(
+            agent_id=reporter.agent_id,
+            content={
+                "request": tiradentes_request,
+                "investigation_ids": request.investigation_ids,
+                "analysis_ids": request.analysis_ids,
+                "data_sources": request.data_sources,
+                "time_range": request.time_range,
+            },
+            requires_response=True
+        )
+        
+        result = await reporter.process(message, context)
+        content = result.data.get("report_content", "")
         
         report["current_phase"] = "formatting"
         report["progress"] = 0.7
         
-        # Format content according to output format
-        if request.output_format == "html":
-            formatted_content = await reporter.format_as_html(content, request.title)
-        elif request.output_format == "json":
-            formatted_content = await reporter.format_as_json(content, report)
-        else:
-            formatted_content = content  # Keep as markdown
+        # Content is already formatted by Tiradentes based on the format requested
+        formatted_content = content
         
         report["current_phase"] = "finalization"
         report["progress"] = 0.9

src/services/export_service.py

@@ -0,0 +1,467 @@
+"""
+Module: services.export_service
+Description: Document export service for generating PDF, Excel and CSV files
+Author: Anderson H. Silva
+Date: 2025-01-25
+License: Proprietary - All rights reserved
+"""
+
+import io
+import zipfile
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Union
+from pathlib import Path
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+import pandas as pd
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, Image
+from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY
+import markdown
+from bs4 import BeautifulSoup
+import openpyxl
+from openpyxl.styles import Font, PatternFill, Alignment
+from openpyxl.utils import get_column_letter
+
+from src.core import get_logger
+from src.core import json_utils
+
+logger = get_logger(__name__)
+
+# Thread pool for CPU-intensive PDF generation
+_pdf_thread_pool = ThreadPoolExecutor(max_workers=2, thread_name_prefix="pdf_export")
+
+
+class ExportService:
+    """Service for exporting documents in various formats."""
+    
+    def __init__(self):
+        """Initialize export service."""
+        self.styles = getSampleStyleSheet()
+        self._create_custom_styles()
+    
+    def _create_custom_styles(self):
+        """Create custom PDF styles."""
+        # Title style
+        self.styles.add(ParagraphStyle(
+            name='CustomTitle',
+            parent=self.styles['Title'],
+            fontSize=24,
+            textColor=colors.HexColor('#1a73e8'),
+            spaceAfter=30,
+            alignment=TA_CENTER
+        ))
+        
+        # Subtitle style
+        self.styles.add(ParagraphStyle(
+            name='CustomSubtitle',
+            parent=self.styles['Heading2'],
+            fontSize=16,
+            textColor=colors.HexColor('#34495e'),
+            spaceBefore=20,
+            spaceAfter=10
+        ))
+        
+        # Body text style
+        self.styles.add(ParagraphStyle(
+            name='CustomBody',
+            parent=self.styles['BodyText'],
+            fontSize=11,
+            leading=16,
+            alignment=TA_JUSTIFY,
+            spaceBefore=6,
+            spaceAfter=6
+        ))
+        
+        # Footer style
+        self.styles.add(ParagraphStyle(
+            name='CustomFooter',
+            parent=self.styles['Normal'],
+            fontSize=9,
+            textColor=colors.grey,
+            alignment=TA_CENTER
+        ))
+    
+    async def generate_pdf(
+        self,
+        content: str,
+        title: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        format_type: str = "report"
+    ) -> bytes:
+        """
+        Generate PDF from content.
+        
+        Args:
+            content: Content in markdown format
+            title: Document title
+            metadata: Additional metadata
+            format_type: Type of document (report, investigation, analysis)
+            
+        Returns:
+            PDF bytes
+        """
+        # Run PDF generation in thread pool to avoid blocking
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            _pdf_thread_pool,
+            self._generate_pdf_sync,
+            content,
+            title,
+            metadata or {},
+            format_type
+        )
+    
+    def _generate_pdf_sync(
+        self,
+        content: str,
+        title: str,
+        metadata: Dict[str, Any],
+        format_type: str
+    ) -> bytes:
+        """Synchronous PDF generation."""
+        # Create buffer
+        buffer = io.BytesIO()
+        
+        # Create PDF
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=A4,
+            rightMargin=72,
+            leftMargin=72,
+            topMargin=72,
+            bottomMargin=48
+        )
+        
+        # Build story
+        story = []
+        
+        # Add header with logo/branding
+        story.append(Paragraph("Cidadão.AI - Transparência Governamental", self.styles['CustomFooter']))
+        story.append(Spacer(1, 0.2*inch))
+        
+        # Add title
+        story.append(Paragraph(title, self.styles['CustomTitle']))
+        
+        # Add metadata if provided
+        if metadata:
+            meta_data = []
+            if 'generated_at' in metadata:
+                meta_data.append(f"Gerado em: {metadata['generated_at']}")
+            if 'report_type' in metadata:
+                meta_data.append(f"Tipo: {metadata['report_type']}")
+            if 'author' in metadata:
+                meta_data.append(f"Autor: {metadata['author']}")
+            
+            if meta_data:
+                story.append(Paragraph(" | ".join(meta_data), self.styles['CustomFooter']))
+                story.append(Spacer(1, 0.3*inch))
+        
+        # Convert markdown to HTML
+        html_content = markdown.markdown(
+            content,
+            extensions=['extra', 'codehilite', 'toc', 'tables']
+        )
+        
+        # Parse HTML and convert to PDF elements
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        for element in soup.find_all():
+            if element.name == 'h1':
+                story.append(PageBreak())
+                story.append(Paragraph(element.text, self.styles['Heading1']))
+            elif element.name == 'h2':
+                story.append(Spacer(1, 0.2*inch))
+                story.append(Paragraph(element.text, self.styles['CustomSubtitle']))
+            elif element.name == 'h3':
+                story.append(Spacer(1, 0.15*inch))
+                story.append(Paragraph(element.text, self.styles['Heading3']))
+            elif element.name == 'p':
+                story.append(Paragraph(element.text, self.styles['CustomBody']))
+            elif element.name == 'ul':
+                for li in element.find_all('li'):
+                    story.append(Paragraph(f"• {li.text}", self.styles['CustomBody']))
+            elif element.name == 'ol':
+                for i, li in enumerate(element.find_all('li'), 1):
+                    story.append(Paragraph(f"{i}. {li.text}", self.styles['CustomBody']))
+            elif element.name == 'table':
+                # Convert HTML table to ReportLab table
+                table_data = []
+                rows = element.find_all('tr')
+                
+                for row in rows:
+                    cells = row.find_all(['td', 'th'])
+                    table_data.append([cell.text.strip() for cell in cells])
+                
+                if table_data:
+                    t = Table(table_data)
+                    t.setStyle(TableStyle([
+                        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                        ('FONTSIZE', (0, 0), (-1, 0), 12),
+                        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+                    ]))
+                    story.append(Spacer(1, 0.1*inch))
+                    story.append(t)
+                    story.append(Spacer(1, 0.1*inch))
+        
+        # Add footer
+        story.append(Spacer(1, 0.5*inch))
+        story.append(Paragraph(
+            f"Documento gerado automaticamente pelo Cidadão.AI em {datetime.now().strftime('%d/%m/%Y %H:%M')}",
+            self.styles['CustomFooter']
+        ))
+        
+        # Build PDF
+        doc.build(story)
+        
+        # Get PDF bytes
+        pdf_bytes = buffer.getvalue()
+        buffer.close()
+        
+        return pdf_bytes
+    
+    async def generate_excel(
+        self,
+        data: Union[Dict[str, pd.DataFrame], pd.DataFrame],
+        title: str,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> bytes:
+        """
+        Generate Excel file from data.
+        
+        Args:
+            data: DataFrame or dict of DataFrames (for multiple sheets)
+            title: Document title
+            metadata: Additional metadata
+            
+        Returns:
+            Excel bytes
+        """
+        buffer = io.BytesIO()
+        
+        # Create Excel writer
+        with pd.ExcelWriter(buffer, engine='openpyxl') as writer:
+            # Handle single or multiple DataFrames
+            if isinstance(data, pd.DataFrame):
+                data = {'Dados': data}
+            
+            # Write each DataFrame to a sheet
+            for sheet_name, df in data.items():
+                df.to_excel(writer, sheet_name=sheet_name[:31], index=False)  # Excel sheet name limit
+                
+                # Get the worksheet
+                worksheet = writer.sheets[sheet_name]
+                
+                # Apply formatting
+                self._format_excel_sheet(worksheet, title, metadata)
+            
+            # Add metadata sheet
+            if metadata:
+                meta_df = pd.DataFrame([
+                    {'Campo': k, 'Valor': str(v)}
+                    for k, v in metadata.items()
+                ])
+                meta_df.to_excel(writer, sheet_name='Metadados', index=False)
+                self._format_excel_sheet(writer.sheets['Metadados'], 'Metadados', {})
+        
+        return buffer.getvalue()
+    
+    def _format_excel_sheet(self, worksheet, title: str, metadata: Dict[str, Any]):
+        """Apply formatting to Excel worksheet."""
+        # Set column widths
+        for column_cells in worksheet.columns:
+            length = max(len(str(cell.value or '')) for cell in column_cells)
+            worksheet.column_dimensions[column_cells[0].column_letter].width = min(length + 2, 50)
+        
+        # Add title row
+        worksheet.insert_rows(1)
+        worksheet.merge_cells('A1:' + get_column_letter(worksheet.max_column) + '1')
+        title_cell = worksheet['A1']
+        title_cell.value = title
+        title_cell.font = Font(size=16, bold=True, color="1a73e8")
+        title_cell.alignment = Alignment(horizontal='center', vertical='center')
+        
+        # Add generation date
+        worksheet.insert_rows(2)
+        worksheet.merge_cells('A2:' + get_column_letter(worksheet.max_column) + '2')
+        date_cell = worksheet['A2']
+        date_cell.value = f"Gerado em: {datetime.now().strftime('%d/%m/%Y %H:%M')}"
+        date_cell.font = Font(size=10, italic=True)
+        date_cell.alignment = Alignment(horizontal='center')
+        
+        # Format headers
+        header_fill = PatternFill(start_color="4285F4", end_color="4285F4", fill_type="solid")
+        header_font = Font(bold=True, color="FFFFFF")
+        
+        for cell in worksheet[4]:  # Assuming headers are now in row 4
+            if cell.value:
+                cell.fill = header_fill
+                cell.font = header_font
+                cell.alignment = Alignment(horizontal='center')
+        
+        # Add borders
+        from openpyxl.styles import Border, Side
+        thin_border = Border(
+            left=Side(style='thin'),
+            right=Side(style='thin'),
+            top=Side(style='thin'),
+            bottom=Side(style='thin')
+        )
+        
+        for row in worksheet.iter_rows(min_row=4):
+            for cell in row:
+                if cell.value:
+                    cell.border = thin_border
+    
+    async def generate_csv(
+        self,
+        data: pd.DataFrame,
+        encoding: str = 'utf-8'
+    ) -> bytes:
+        """
+        Generate CSV file from DataFrame.
+        
+        Args:
+            data: DataFrame to export
+            encoding: File encoding
+            
+        Returns:
+            CSV bytes
+        """
+        return data.to_csv(index=False).encode(encoding)
+    
+    async def generate_bulk_export(
+        self,
+        exports: List[Dict[str, Any]],
+        format: str = "zip"
+    ) -> bytes:
+        """
+        Generate bulk export with multiple files.
+        
+        Args:
+            exports: List of export configurations
+                Each dict should have: 'filename', 'content', 'format'
+            format: Archive format (zip)
+            
+        Returns:
+            Archive bytes
+        """
+        if format != "zip":
+            raise ValueError("Currently only ZIP format is supported for bulk exports")
+        
+        buffer = io.BytesIO()
+        
+        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for export in exports:
+                filename = export['filename']
+                content = export['content']
+                file_format = export.get('format', 'txt')
+                
+                # Generate file based on format
+                if file_format == 'pdf':
+                    file_bytes = await self.generate_pdf(
+                        content=content,
+                        title=export.get('title', filename),
+                        metadata=export.get('metadata', {})
+                    )
+                elif file_format == 'excel':
+                    file_bytes = await self.generate_excel(
+                        data=export.get('data', pd.DataFrame()),
+                        title=export.get('title', filename),
+                        metadata=export.get('metadata', {})
+                    )
+                elif file_format == 'csv':
+                    file_bytes = await self.generate_csv(
+                        data=export.get('data', pd.DataFrame())
+                    )
+                else:
+                    # Default to text
+                    file_bytes = content.encode('utf-8')
+                
+                # Add to zip
+                zipf.writestr(filename, file_bytes)
+                
+                logger.info(
+                    "bulk_export_file_added",
+                    filename=filename,
+                    format=file_format,
+                    size=len(file_bytes)
+                )
+        
+        return buffer.getvalue()
+    
+    async def convert_investigation_to_excel(
+        self,
+        investigation_data: Dict[str, Any]
+    ) -> bytes:
+        """
+        Convert investigation data to Excel format.
+        
+        Args:
+            investigation_data: Investigation data dict
+            
+        Returns:
+            Excel bytes
+        """
+        # Create multiple DataFrames for different aspects
+        dataframes = {}
+        
+        # Summary sheet
+        summary_data = {
+            'Campo': ['ID', 'Tipo', 'Status', 'Data Início', 'Data Fim', 'Duração (min)'],
+            'Valor': [
+                investigation_data.get('id', 'N/A'),
+                investigation_data.get('type', 'N/A'),
+                investigation_data.get('status', 'N/A'),
+                investigation_data.get('created_at', 'N/A'),
+                investigation_data.get('completed_at', 'N/A'),
+                investigation_data.get('duration_minutes', 'N/A')
+            ]
+        }
+        dataframes['Resumo'] = pd.DataFrame(summary_data)
+        
+        # Anomalies sheet
+        anomalies = investigation_data.get('anomalies', [])
+        if anomalies:
+            anomaly_df = pd.DataFrame(anomalies)
+            dataframes['Anomalias'] = anomaly_df
+        
+        # Contracts sheet
+        contracts = investigation_data.get('contracts', [])
+        if contracts:
+            contract_df = pd.DataFrame(contracts)
+            dataframes['Contratos'] = contract_df
+        
+        # Analysis results
+        results = investigation_data.get('results', {})
+        if results:
+            results_data = []
+            for key, value in results.items():
+                results_data.append({
+                    'Métrica': key,
+                    'Valor': str(value)
+                })
+            dataframes['Resultados'] = pd.DataFrame(results_data)
+        
+        # Generate Excel
+        return await self.generate_excel(
+            data=dataframes,
+            title=f"Investigação {investigation_data.get('id', 'N/A')}",
+            metadata={
+                'generated_at': datetime.now().isoformat(),
+                'investigation_id': investigation_data.get('id', 'N/A')
+            }
+        )
+
+
+# Global instance
+export_service = ExportService()

tests/unit/agents/test_tiradentes_pdf.py

@@ -0,0 +1,311 @@
+"""
+Module: tests.unit.agents.test_tiradentes_pdf
+Description: Unit tests for Tiradentes PDF generation functionality
+Author: Anderson H. Silva
+Date: 2025-01-25
+License: Proprietary - All rights reserved
+"""
+
+import pytest
+import base64
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from src.agents.tiradentes import (
+    ReporterAgent, ReportRequest, ReportFormat, ReportType,
+    ReportSection, AgentContext
+)
+
+
+class TestTiradentePDFGeneration:
+    """Test suite for Tiradentes PDF generation."""
+    
+    @pytest.fixture
+    def reporter_agent(self):
+        """Create ReporterAgent instance."""
+        return ReporterAgent()
+    
+    @pytest.fixture
+    def agent_context(self):
+        """Create agent context for testing."""
+        return AgentContext(
+            conversation_id="test-conv-001",
+            user_id="test-user-123",
+            investigation_id="INV-001",
+            session_data={}
+        )
+    
+    @pytest.fixture
+    def sample_sections(self):
+        """Create sample report sections."""
+        return [
+            ReportSection(
+                title="Resumo Executivo",
+                content="Este relatório apresenta as principais descobertas da investigação.",
+                importance=5,
+                subsections=None,
+                charts=None,
+                tables=None
+            ),
+            ReportSection(
+                title="Anomalias Detectadas",
+                content="""
+## Anomalia 1: Valor Atípico
+- **Severidade**: 0.85
+- **Descrição**: Contrato com valor 300% acima da média
+- **Recomendação**: Investigação detalhada necessária
+
+## Anomalia 2: Padrão Temporal
+- **Severidade**: 0.72
+- **Descrição**: Concentração anormal de contratos
+""",
+                importance=4,
+                subsections=None,
+                charts=None,
+                tables=None
+            ),
+            ReportSection(
+                title="Conclusões",
+                content="As anomalias identificadas sugerem possíveis irregularidades.",
+                importance=3,
+                subsections=None,
+                charts=None,
+                tables=None
+            )
+        ]
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_basic(
+        self, mock_export_service, reporter_agent, sample_sections, agent_context
+    ):
+        """Test basic PDF rendering."""
+        # Setup mock
+        mock_export_service.generate_pdf.return_value = b'mock-pdf-content'
+        
+        # Create request
+        request = ReportRequest(
+            report_type=ReportType.INVESTIGATION_REPORT,
+            format=ReportFormat.PDF,
+            target_audience="technical",
+            language="pt-BR"
+        )
+        
+        # Render PDF
+        result = await reporter_agent._render_pdf(
+            sections=sample_sections,
+            request=request,
+            context=agent_context
+        )
+        
+        # Verify result is base64 encoded
+        assert isinstance(result, str)
+        decoded = base64.b64decode(result)
+        assert decoded == b'mock-pdf-content'
+        
+        # Verify export service was called
+        mock_export_service.generate_pdf.assert_called_once()
+        call_args = mock_export_service.generate_pdf.call_args
+        
+        # Check arguments
+        assert "Este relatório apresenta" in call_args[1]['content']
+        assert call_args[1]['title'] == "Relatório: Investigation Report"
+        assert call_args[1]['metadata']['report_type'] == 'investigation_report'
+        assert call_args[1]['metadata']['investigation_id'] == 'INV-001'
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_with_metadata(
+        self, mock_export_service, reporter_agent, sample_sections, agent_context
+    ):
+        """Test PDF rendering with full metadata."""
+        # Setup mock
+        mock_export_service.generate_pdf.return_value = b'pdf-with-metadata'
+        
+        # Create request
+        request = ReportRequest(
+            report_type=ReportType.EXECUTIVE_SUMMARY,
+            format=ReportFormat.PDF,
+            target_audience="executive",
+            language="pt-BR"
+        )
+        
+        # Render PDF
+        result = await reporter_agent._render_pdf(
+            sections=sample_sections,
+            request=request,
+            context=agent_context
+        )
+        
+        # Verify metadata passed to export service
+        call_metadata = mock_export_service.generate_pdf.call_args[1]['metadata']
+        assert call_metadata['target_audience'] == 'executive'
+        assert call_metadata['author'] == 'Agente Tiradentes - Cidadão.AI'
+        assert 'generated_at' in call_metadata
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_format_type(
+        self, mock_export_service, reporter_agent, sample_sections, agent_context
+    ):
+        """Test PDF rendering passes correct format type."""
+        # Setup mock
+        mock_export_service.generate_pdf.return_value = b'typed-pdf'
+        
+        # Create request
+        request = ReportRequest(
+            report_type=ReportType.TREND_ANALYSIS,
+            format=ReportFormat.PDF,
+            target_audience="researcher",
+            language="pt-BR"
+        )
+        
+        # Render PDF
+        await reporter_agent._render_pdf(
+            sections=sample_sections,
+            request=request,
+            context=agent_context
+        )
+        
+        # Verify format_type parameter
+        assert mock_export_service.generate_pdf.call_args[1]['format_type'] == "report"
+    
+    @pytest.mark.asyncio
+    async def test_pdf_format_in_renderers(self, reporter_agent):
+        """Test PDF format is registered in format renderers."""
+        assert ReportFormat.PDF in reporter_agent.format_renderers
+        assert reporter_agent.format_renderers[ReportFormat.PDF] == reporter_agent._render_pdf
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_markdown_conversion(
+        self, mock_export_service, reporter_agent, agent_context
+    ):
+        """Test PDF rendering converts sections to markdown first."""
+        # Setup mock to capture markdown content
+        markdown_content = None
+        
+        async def capture_markdown(*args, **kwargs):
+            nonlocal markdown_content
+            markdown_content = kwargs['content']
+            return b'test-pdf'
+        
+        mock_export_service.generate_pdf.side_effect = capture_markdown
+        
+        # Create simple sections
+        sections = [
+            ReportSection(
+                title="Test Section",
+                content="Test content",
+                importance=5
+            )
+        ]
+        
+        request = ReportRequest(
+            report_type=ReportType.INVESTIGATION_REPORT,
+            format=ReportFormat.PDF,
+            target_audience="general",
+            language="pt-BR"
+        )
+        
+        # Render PDF
+        await reporter_agent._render_pdf(sections, request, agent_context)
+        
+        # Verify markdown was generated
+        assert markdown_content is not None
+        assert "# Relatório: Investigation Report" in markdown_content
+        assert "## Test Section" in markdown_content
+        assert "Test content" in markdown_content
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_error_handling(
+        self, mock_export_service, reporter_agent, sample_sections, agent_context
+    ):
+        """Test PDF rendering error handling."""
+        # Setup mock to raise exception
+        mock_export_service.generate_pdf.side_effect = Exception("PDF generation failed")
+        
+        request = ReportRequest(
+            report_type=ReportType.INVESTIGATION_REPORT,
+            format=ReportFormat.PDF,
+            target_audience="technical",
+            language="pt-BR"
+        )
+        
+        # Should raise exception
+        with pytest.raises(Exception) as exc_info:
+            await reporter_agent._render_pdf(
+                sections=sample_sections,
+                request=request,
+                context=agent_context
+            )
+        
+        assert "PDF generation failed" in str(exc_info.value)
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_empty_sections(
+        self, mock_export_service, reporter_agent, agent_context
+    ):
+        """Test PDF rendering with empty sections."""
+        # Setup mock
+        mock_export_service.generate_pdf.return_value = b'empty-pdf'
+        
+        request = ReportRequest(
+            report_type=ReportType.INVESTIGATION_REPORT,
+            format=ReportFormat.PDF,
+            target_audience="general",
+            language="pt-BR"
+        )
+        
+        # Render with empty sections
+        result = await reporter_agent._render_pdf(
+            sections=[],
+            request=request,
+            context=agent_context
+        )
+        
+        # Should still generate PDF
+        assert isinstance(result, str)
+        decoded = base64.b64decode(result)
+        assert decoded == b'empty-pdf'
+    
+    @pytest.mark.asyncio
+    @patch('src.agents.tiradentes.export_service')
+    async def test_render_pdf_large_content(
+        self, mock_export_service, reporter_agent, agent_context
+    ):
+        """Test PDF rendering with large content."""
+        # Create large sections
+        large_sections = []
+        for i in range(10):
+            large_sections.append(
+                ReportSection(
+                    title=f"Section {i}",
+                    content="Very long content. " * 100,
+                    importance=3
+                )
+            )
+        
+        # Setup mock
+        mock_export_service.generate_pdf.return_value = b'large-pdf'
+        
+        request = ReportRequest(
+            report_type=ReportType.INVESTIGATION_REPORT,
+            format=ReportFormat.PDF,
+            target_audience="technical",
+            language="pt-BR"
+        )
+        
+        # Render PDF
+        result = await reporter_agent._render_pdf(
+            sections=large_sections,
+            request=request,
+            context=agent_context
+        )
+        
+        # Verify it handles large content
+        assert isinstance(result, str)
+        call_content = mock_export_service.generate_pdf.call_args[1]['content']
+        assert len(call_content) > 10000  # Should be quite large

tests/unit/api/routes/test_export.py

@@ -0,0 +1,434 @@
+"""
+Module: tests.unit.api.routes.test_export
+Description: Unit tests for export routes
+Author: Anderson H. Silva
+Date: 2025-01-25
+License: Proprietary - All rights reserved
+"""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from datetime import datetime
+import pandas as pd
+import base64
+from fastapi import HTTPException
+from fastapi.testclient import TestClient
+
+from src.api.routes.export import (
+    export_investigation, export_contracts, export_anomalies,
+    bulk_export, _format_investigation_as_markdown
+)
+
+
+class TestExportRoutes:
+    """Test suite for export API routes."""
+    
+    @pytest.fixture
+    def mock_current_user(self):
+        """Mock current user."""
+        return {
+            'user_id': 'test-user-123',
+            'email': '[email protected]',
+            'roles': ['user']
+        }
+    
+    @pytest.fixture
+    def mock_investigation(self):
+        """Mock investigation data."""
+        return {
+            'id': 'INV-001',
+            'type': 'contract_analysis',
+            'status': 'completed',
+            'created_at': '2024-01-20T10:00:00',
+            'completed_at': '2024-01-20T10:30:00',
+            'summary': 'Investigation completed successfully',
+            'anomalies': [
+                {
+                    'type': 'value_outlier',
+                    'severity': 0.85,
+                    'description': 'High value contract',
+                    'explanation': 'Contract value exceeds threshold'
+                }
+            ],
+            'contracts': [
+                {
+                    'id': 'C001',
+                    'value': 500000,
+                    'supplier': 'Company A',
+                    'date': '2024-01-15'
+                }
+            ],
+            'total_value': 500000
+        }
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    @patch('src.api.routes.export.export_service')
+    async def test_export_investigation_excel(
+        self, mock_export_service, mock_investigation_service, 
+        mock_current_user, mock_investigation
+    ):
+        """Test export investigation as Excel."""
+        # Setup mocks
+        mock_investigation_service.get_investigation.return_value = mock_investigation
+        mock_export_service.convert_investigation_to_excel.return_value = b'excel-content'
+        
+        # Call function
+        response = await export_investigation(
+            investigation_id='INV-001',
+            format='excel',
+            current_user=mock_current_user
+        )
+        
+        # Verify
+        assert response.body == b'excel-content'
+        assert response.media_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        assert 'attachment' in response.headers['Content-Disposition']
+        assert '.xlsx' in response.headers['Content-Disposition']
+        
+        mock_investigation_service.get_investigation.assert_called_once_with(
+            'INV-001', 
+            user_id='test-user-123'
+        )
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    @patch('src.api.routes.export.export_service')
+    async def test_export_investigation_csv(
+        self, mock_export_service, mock_investigation_service,
+        mock_current_user, mock_investigation
+    ):
+        """Test export investigation as CSV."""
+        # Setup mocks
+        mock_investigation_service.get_investigation.return_value = mock_investigation
+        mock_export_service.generate_csv.return_value = b'csv-content'
+        
+        # Call function
+        response = await export_investigation(
+            investigation_id='INV-001',
+            format='csv',
+            current_user=mock_current_user
+        )
+        
+        # Verify
+        assert response.body == b'csv-content'
+        assert response.media_type == "text/csv"
+        assert '.csv' in response.headers['Content-Disposition']
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    @patch('src.api.routes.export.export_service')
+    async def test_export_investigation_pdf(
+        self, mock_export_service, mock_investigation_service,
+        mock_current_user, mock_investigation
+    ):
+        """Test export investigation as PDF."""
+        # Setup mocks
+        mock_investigation_service.get_investigation.return_value = mock_investigation
+        mock_export_service.generate_pdf.return_value = b'pdf-content'
+        
+        # Call function
+        response = await export_investigation(
+            investigation_id='INV-001',
+            format='pdf',
+            current_user=mock_current_user
+        )
+        
+        # Verify
+        assert response.body == b'pdf-content'
+        assert response.media_type == "application/pdf"
+        assert '.pdf' in response.headers['Content-Disposition']
+        
+        # Check PDF generation was called with correct params
+        mock_export_service.generate_pdf.assert_called_once()
+        call_args = mock_export_service.generate_pdf.call_args[1]
+        assert 'Investigação INV-001' in call_args['title']
+        assert call_args['metadata']['investigation_id'] == 'INV-001'
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    async def test_export_investigation_not_found(
+        self, mock_investigation_service, mock_current_user
+    ):
+        """Test export investigation when not found."""
+        # Setup mock
+        mock_investigation_service.get_investigation.return_value = None
+        
+        # Call function and expect exception
+        with pytest.raises(HTTPException) as exc_info:
+            await export_investigation(
+                investigation_id='INV-999',
+                format='excel',
+                current_user=mock_current_user
+            )
+        
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.detail == "Investigation not found"
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.data_service')
+    @patch('src.api.routes.export.export_service')
+    async def test_export_contracts_excel(
+        self, mock_export_service, mock_data_service, mock_current_user
+    ):
+        """Test export contracts as Excel."""
+        from src.api.routes.export import ExportRequest
+        
+        # Setup mocks
+        mock_contracts = [
+            {'id': 'C001', 'value': 100000, 'supplier': 'Company A'},
+            {'id': 'C002', 'value': 200000, 'supplier': 'Company B'}
+        ]
+        mock_data_service.search_contracts.return_value = mock_contracts
+        mock_export_service.generate_excel.return_value = b'excel-content'
+        
+        # Create request
+        request = ExportRequest(
+            export_type='contracts',
+            format='excel',
+            filters={'year': 2024},
+            include_metadata=True,
+            compress=False
+        )
+        
+        # Call function
+        response = await export_contracts(request, mock_current_user)
+        
+        # Verify
+        assert response.body == b'excel-content'
+        assert response.media_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        
+        # Check search was called with filters
+        mock_data_service.search_contracts.assert_called_once()
+        call_kwargs = mock_data_service.search_contracts.call_args[1]
+        assert call_kwargs['year'] == 2024
+        assert call_kwargs['limit'] == 10000
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    @patch('src.api.routes.export.export_service')
+    async def test_export_anomalies_excel(
+        self, mock_export_service, mock_investigation_service, mock_current_user
+    ):
+        """Test export anomalies as Excel."""
+        from src.api.routes.export import ExportRequest
+        
+        # Setup mocks
+        mock_investigations = [
+            {
+                'id': 'INV-001',
+                'anomalies': [
+                    {'severity': 0.8, 'type': 'high', 'description': 'High risk'},
+                    {'severity': 0.5, 'type': 'medium', 'description': 'Medium risk'}
+                ]
+            },
+            {
+                'id': 'INV-002',
+                'anomalies': [
+                    {'severity': 0.3, 'type': 'low', 'description': 'Low risk'}
+                ]
+            }
+        ]
+        mock_investigation_service.list_investigations.return_value = mock_investigations
+        mock_export_service.generate_excel.return_value = b'excel-content'
+        
+        # Create request
+        request = ExportRequest(
+            export_type='anomalies',
+            format='excel',
+            filters={},
+            include_metadata=True,
+            compress=False
+        )
+        
+        # Call function
+        response = await export_anomalies(request, mock_current_user)
+        
+        # Verify
+        assert response.body == b'excel-content'
+        
+        # Check Excel generation was called with multiple sheets
+        mock_export_service.generate_excel.assert_called_once()
+        call_args = mock_export_service.generate_excel.call_args[1]
+        data_arg = call_args['data']
+        
+        # Should have sheets for different severity levels
+        assert 'Alta Severidade' in data_arg
+        assert 'Média Severidade' in data_arg
+        assert 'Baixa Severidade' in data_arg
+        assert 'Todas Anomalias' in data_arg
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    @patch('src.api.routes.export.export_service')
+    @patch('src.api.routes.export.json_utils')
+    async def test_bulk_export(
+        self, mock_json_utils, mock_export_service, 
+        mock_investigation_service, mock_current_user, mock_investigation
+    ):
+        """Test bulk export functionality."""
+        from src.api.routes.export import BulkExportRequest
+        
+        # Setup mocks
+        mock_investigation_service.get_investigation.return_value = mock_investigation
+        mock_export_service.generate_bulk_export.return_value = b'zip-content'
+        mock_json_utils.dumps.return_value = '{"test": "json"}'
+        
+        # Create request
+        request = BulkExportRequest(
+            exports=[
+                {'type': 'investigation', 'id': 'INV-001', 'format': 'pdf'},
+                {'type': 'investigation', 'id': 'INV-002', 'format': 'json'}
+            ],
+            compress=True
+        )
+        
+        # Call function
+        response = await bulk_export(request, mock_current_user)
+        
+        # Verify
+        assert response.body == b'zip-content'
+        assert response.media_type == "application/zip"
+        assert '.zip' in response.headers['Content-Disposition']
+        
+        # Check bulk export was called
+        mock_export_service.generate_bulk_export.assert_called_once()
+        exports_config = mock_export_service.generate_bulk_export.call_args[0][0]
+        assert len(exports_config) == 2
+    
+    def test_format_investigation_as_markdown(self, mock_investigation):
+        """Test investigation markdown formatting."""
+        markdown = _format_investigation_as_markdown(mock_investigation)
+        
+        # Verify content
+        assert '# Investigação INV-001' in markdown
+        assert '**Tipo**: contract_analysis' in markdown
+        assert '**Status**: completed' in markdown
+        assert '## Resumo' in markdown
+        assert 'Investigation completed successfully' in markdown
+        assert '## Anomalias Detectadas' in markdown
+        assert 'Total de anomalias: 1' in markdown
+        assert '### Anomalia 1' in markdown
+        assert '**Severidade**: 0.85' in markdown
+    
+    def test_format_investigation_as_markdown_no_anomalies(self):
+        """Test investigation markdown formatting without anomalies."""
+        investigation = {
+            'id': 'INV-002',
+            'type': 'routine_check',
+            'status': 'completed',
+            'created_at': '2024-01-21T10:00:00',
+            'anomalies': []
+        }
+        
+        markdown = _format_investigation_as_markdown(investigation)
+        
+        # Should not have anomalies section
+        assert '## Anomalias Detectadas' not in markdown
+        assert '# Investigação INV-002' in markdown
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.data_service')
+    async def test_export_contracts_not_found(
+        self, mock_data_service, mock_current_user
+    ):
+        """Test export contracts when none found."""
+        from src.api.routes.export import ExportRequest
+        
+        # Setup mock
+        mock_data_service.search_contracts.return_value = []
+        
+        # Create request
+        request = ExportRequest(
+            export_type='contracts',
+            format='excel',
+            filters={'year': 2025}
+        )
+        
+        # Call function and expect exception
+        with pytest.raises(HTTPException) as exc_info:
+            await export_contracts(request, mock_current_user)
+        
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.detail == "No contracts found with given filters"
+    
+    @pytest.mark.asyncio
+    @patch('src.api.routes.export.investigation_service')
+    async def test_export_anomalies_none_found(
+        self, mock_investigation_service, mock_current_user
+    ):
+        """Test export anomalies when none found."""
+        from src.api.routes.export import ExportRequest
+        
+        # Setup mock - investigations without anomalies
+        mock_investigations = [
+            {'id': 'INV-001', 'anomalies': []},
+            {'id': 'INV-002', 'anomalies': []}
+        ]
+        mock_investigation_service.list_investigations.return_value = mock_investigations
+        
+        # Create request
+        request = ExportRequest(
+            export_type='anomalies',
+            format='excel'
+        )
+        
+        # Call function and expect exception
+        with pytest.raises(HTTPException) as exc_info:
+            await export_anomalies(request, mock_current_user)
+        
+        assert exc_info.value.status_code == 404
+        assert exc_info.value.detail == "No anomalies found"
+    
+    def test_export_request_validation(self):
+        """Test ExportRequest validation."""
+        from src.api.routes.export import ExportRequest
+        
+        # Valid request
+        request = ExportRequest(
+            export_type='investigations',
+            format='excel'
+        )
+        assert request.export_type == 'investigations'
+        assert request.format == 'excel'
+        assert request.include_metadata is True
+        assert request.compress is False
+        
+        # Invalid export type
+        with pytest.raises(ValueError) as exc_info:
+            ExportRequest(
+                export_type='invalid_type',
+                format='excel'
+            )
+        assert 'Export type must be one of' in str(exc_info.value)
+        
+        # Invalid format
+        with pytest.raises(ValueError) as exc_info:
+            ExportRequest(
+                export_type='contracts',
+                format='invalid_format'
+            )
+        assert 'Format must be one of' in str(exc_info.value)
+    
+    def test_bulk_export_request_validation(self):
+        """Test BulkExportRequest validation."""
+        from src.api.routes.export import BulkExportRequest
+        
+        # Valid request
+        request = BulkExportRequest(
+            exports=[{'type': 'investigation', 'id': '123'}]
+        )
+        assert len(request.exports) == 1
+        assert request.compress is True
+        
+        # Empty exports
+        with pytest.raises(ValueError) as exc_info:
+            BulkExportRequest(exports=[])
+        assert 'At least one export must be specified' in str(exc_info.value)
+        
+        # Too many exports
+        with pytest.raises(ValueError) as exc_info:
+            BulkExportRequest(
+                exports=[{'type': 'investigation', 'id': str(i)} for i in range(51)]
+            )
+        assert 'Maximum 50 exports allowed' in str(exc_info.value)

tests/unit/services/test_export_service.py

@@ -0,0 +1,363 @@
+"""
+Module: tests.unit.services.test_export_service
+Description: Unit tests for export service
+Author: Anderson H. Silva
+Date: 2025-01-25
+License: Proprietary - All rights reserved
+"""
+
+import pytest
+import base64
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+import pandas as pd
+from io import BytesIO
+
+from src.services.export_service import ExportService, export_service
+
+
+class TestExportService:
+    """Test suite for ExportService."""
+    
+    @pytest.fixture
+    def service(self):
+        """Create export service instance."""
+        return ExportService()
+    
+    @pytest.fixture
+    def sample_markdown_content(self):
+        """Sample markdown content for testing."""
+        return """
+# Relatório de Investigação
+
+## Resumo Executivo
+
+Este relatório apresenta os resultados da investigação realizada.
+
+## Anomalias Detectadas
+
+### Anomalia 1
+- **Tipo**: Valor atípico
+- **Severidade**: 0.85
+- **Descrição**: Contrato com valor 300% acima da média
+
+### Anomalia 2
+- **Tipo**: Padrão temporal
+- **Severidade**: 0.72
+- **Descrição**: Concentração anormal de contratos em período específico
+
+## Conclusões
+
+As anomalias detectadas indicam possíveis irregularidades que requerem investigação adicional.
+
+| Métrica | Valor |
+|---------|--------|
+| Total de contratos | 150 |
+| Valor total | R$ 1.500.000 |
+| Anomalias detectadas | 12 |
+"""
+    
+    @pytest.fixture
+    def sample_dataframe(self):
+        """Sample DataFrame for testing."""
+        return pd.DataFrame({
+            'contract_id': ['C001', 'C002', 'C003'],
+            'value': [100000, 250000, 180000],
+            'date': ['2024-01-15', '2024-02-20', '2024-03-10'],
+            'supplier': ['Empresa A', 'Empresa B', 'Empresa C'],
+            'status': ['active', 'completed', 'active']
+        })
+    
+    @pytest.mark.asyncio
+    async def test_generate_pdf_basic(self, service, sample_markdown_content):
+        """Test basic PDF generation."""
+        # Generate PDF
+        pdf_bytes = await service.generate_pdf(
+            content=sample_markdown_content,
+            title="Test Report",
+            metadata={'author': 'Test'},
+            format_type="report"
+        )
+        
+        # Verify PDF generated
+        assert isinstance(pdf_bytes, bytes)
+        assert len(pdf_bytes) > 1000  # Reasonable PDF size
+        assert pdf_bytes.startswith(b'%PDF')  # PDF header
+    
+    @pytest.mark.asyncio
+    async def test_generate_pdf_with_metadata(self, service, sample_markdown_content):
+        """Test PDF generation with metadata."""
+        metadata = {
+            'generated_at': datetime.now().isoformat(),
+            'report_type': 'investigation',
+            'author': 'Cidadão.AI System'
+        }
+        
+        pdf_bytes = await service.generate_pdf(
+            content=sample_markdown_content,
+            title="Investigation Report",
+            metadata=metadata,
+            format_type="investigation"
+        )
+        
+        assert isinstance(pdf_bytes, bytes)
+        assert pdf_bytes.startswith(b'%PDF')
+    
+    @pytest.mark.asyncio
+    async def test_generate_excel_single_sheet(self, service, sample_dataframe):
+        """Test Excel generation with single sheet."""
+        excel_bytes = await service.generate_excel(
+            data=sample_dataframe,
+            title="Contracts Report",
+            metadata={'exported_at': datetime.now().isoformat()}
+        )
+        
+        # Verify Excel generated
+        assert isinstance(excel_bytes, bytes)
+        assert len(excel_bytes) > 500  # Reasonable Excel size
+        
+        # Verify can be read as Excel
+        df_read = pd.read_excel(BytesIO(excel_bytes), sheet_name='Dados')
+        assert len(df_read) == 3
+        assert 'contract_id' in df_read.columns
+    
+    @pytest.mark.asyncio
+    async def test_generate_excel_multiple_sheets(self, service, sample_dataframe):
+        """Test Excel generation with multiple sheets."""
+        data = {
+            'Contratos': sample_dataframe,
+            'Resumo': pd.DataFrame({
+                'Métrica': ['Total Contratos', 'Valor Total', 'Média'],
+                'Valor': [3, 530000, 176666.67]
+            })
+        }
+        
+        excel_bytes = await service.generate_excel(
+            data=data,
+            title="Complete Report",
+            metadata={'version': '1.0'}
+        )
+        
+        assert isinstance(excel_bytes, bytes)
+        
+        # Verify sheets exist
+        excel_file = pd.ExcelFile(BytesIO(excel_bytes))
+        assert 'Contratos' in excel_file.sheet_names
+        assert 'Resumo' in excel_file.sheet_names
+        assert 'Metadados' in excel_file.sheet_names
+    
+    @pytest.mark.asyncio
+    async def test_generate_csv(self, service, sample_dataframe):
+        """Test CSV generation."""
+        csv_bytes = await service.generate_csv(sample_dataframe)
+        
+        assert isinstance(csv_bytes, bytes)
+        csv_str = csv_bytes.decode('utf-8')
+        
+        # Verify CSV content
+        assert 'contract_id,value,date,supplier,status' in csv_str
+        assert 'C001,100000' in csv_str
+        assert 'Empresa A' in csv_str
+    
+    @pytest.mark.asyncio
+    async def test_generate_bulk_export(self, service, sample_markdown_content, sample_dataframe):
+        """Test bulk export with ZIP."""
+        exports = [
+            {
+                'filename': 'report1.pdf',
+                'content': sample_markdown_content,
+                'format': 'pdf',
+                'title': 'Report 1',
+                'metadata': {}
+            },
+            {
+                'filename': 'data.csv',
+                'data': sample_dataframe,
+                'format': 'csv'
+            },
+            {
+                'filename': 'summary.txt',
+                'content': 'Summary of investigations',
+                'format': 'txt'
+            }
+        ]
+        
+        zip_bytes = await service.generate_bulk_export(exports)
+        
+        assert isinstance(zip_bytes, bytes)
+        assert len(zip_bytes) > 1000  # Reasonable ZIP size
+        
+        # Verify ZIP content
+        import zipfile
+        with zipfile.ZipFile(BytesIO(zip_bytes), 'r') as zf:
+            assert 'report1.pdf' in zf.namelist()
+            assert 'data.csv' in zf.namelist()
+            assert 'summary.txt' in zf.namelist()
+    
+    @pytest.mark.asyncio
+    async def test_convert_investigation_to_excel(self, service):
+        """Test investigation data to Excel conversion."""
+        investigation_data = {
+            'id': 'INV-001',
+            'type': 'contract_analysis',
+            'status': 'completed',
+            'created_at': '2024-01-20T10:00:00',
+            'completed_at': '2024-01-20T10:30:00',
+            'duration_minutes': 30,
+            'anomalies': [
+                {
+                    'type': 'value_outlier',
+                    'severity': 0.85,
+                    'description': 'High value detected',
+                    'contract_id': 'C001'
+                },
+                {
+                    'type': 'temporal_pattern',
+                    'severity': 0.72,
+                    'description': 'Unusual timing',
+                    'contract_id': 'C002'
+                }
+            ],
+            'contracts': [
+                {
+                    'id': 'C001',
+                    'value': 500000,
+                    'supplier': 'Company A'
+                },
+                {
+                    'id': 'C002',
+                    'value': 300000,
+                    'supplier': 'Company B'
+                }
+            ],
+            'results': {
+                'total_analyzed': 100,
+                'anomalies_found': 2,
+                'risk_score': 0.78
+            }
+        }
+        
+        excel_bytes = await service.convert_investigation_to_excel(investigation_data)
+        
+        assert isinstance(excel_bytes, bytes)
+        
+        # Verify sheets
+        excel_file = pd.ExcelFile(BytesIO(excel_bytes))
+        assert 'Resumo' in excel_file.sheet_names
+        assert 'Anomalias' in excel_file.sheet_names
+        assert 'Contratos' in excel_file.sheet_names
+        assert 'Resultados' in excel_file.sheet_names
+    
+    @pytest.mark.asyncio
+    async def test_pdf_generation_thread_safety(self, service, sample_markdown_content):
+        """Test PDF generation is thread-safe."""
+        # Generate multiple PDFs concurrently
+        import asyncio
+        
+        tasks = []
+        for i in range(5):
+            task = service.generate_pdf(
+                content=sample_markdown_content + f"\n\n## Report {i}",
+                title=f"Report {i}",
+                metadata={'report_id': i}
+            )
+            tasks.append(task)
+        
+        results = await asyncio.gather(*tasks)
+        
+        # All PDFs should be generated successfully
+        assert len(results) == 5
+        for pdf_bytes in results:
+            assert isinstance(pdf_bytes, bytes)
+            assert pdf_bytes.startswith(b'%PDF')
+    
+    def test_custom_styles_creation(self, service):
+        """Test custom PDF styles are created."""
+        assert 'CustomTitle' in service.styles
+        assert 'CustomSubtitle' in service.styles
+        assert 'CustomBody' in service.styles
+        assert 'CustomFooter' in service.styles
+    
+    @pytest.mark.asyncio
+    async def test_excel_formatting(self, service, sample_dataframe):
+        """Test Excel formatting is applied."""
+        excel_bytes = await service.generate_excel(
+            data=sample_dataframe,
+            title="Formatted Report",
+            metadata={'test': 'formatting'}
+        )
+        
+        # Load and check formatting
+        from openpyxl import load_workbook
+        wb = load_workbook(BytesIO(excel_bytes))
+        ws = wb['Dados']
+        
+        # Check title is merged
+        assert ws.merged_cells
+        
+        # Check title cell has custom font
+        title_cell = ws['A1']
+        assert title_cell.font.bold
+        assert title_cell.font.size == 16
+    
+    @pytest.mark.asyncio
+    async def test_empty_dataframe_handling(self, service):
+        """Test handling of empty DataFrames."""
+        empty_df = pd.DataFrame()
+        
+        csv_bytes = await service.generate_csv(empty_df)
+        assert csv_bytes == b''
+        
+        # Excel should still generate with headers
+        excel_bytes = await service.generate_excel(
+            data=empty_df,
+            title="Empty Report"
+        )
+        assert isinstance(excel_bytes, bytes)
+    
+    @pytest.mark.asyncio
+    async def test_large_content_handling(self, service):
+        """Test handling of large content."""
+        # Generate large markdown content
+        large_content = "# Large Report\n\n"
+        for i in range(100):
+            large_content += f"## Section {i}\n"
+            large_content += "This is a paragraph with some content. " * 50
+            large_content += "\n\n"
+        
+        pdf_bytes = await service.generate_pdf(
+            content=large_content,
+            title="Large Report",
+            format_type="report"
+        )
+        
+        assert isinstance(pdf_bytes, bytes)
+        assert len(pdf_bytes) > 10000  # Should be a sizeable PDF
+    
+    @pytest.mark.asyncio
+    async def test_special_characters_handling(self, service):
+        """Test handling of special characters."""
+        content_with_special = """
+# Relatório com Caracteres Especiais
+
+## Seção com acentuação: áéíóú àèìòù ãõ ç
+
+### Símbolos: @#$%^&*()_+-={}[]|:";'<>?,./
+
+**Texto em negrito** e *texto em itálico*
+
+Código: `print("Olá, Mundo!")`
+"""
+        
+        pdf_bytes = await service.generate_pdf(
+            content=content_with_special,
+            title="Relatório Especial"
+        )
+        
+        assert isinstance(pdf_bytes, bytes)
+        assert pdf_bytes.startswith(b'%PDF')
+    
+    def test_global_service_instance(self):
+        """Test global service instance is available."""
+        assert export_service is not None
+        assert isinstance(export_service, ExportService)