updated

backend/services/report_generator.py

@@ -153,183 +153,194 @@ from typing import List, Tuple
 import textwrap
 
 def create_pdf_report(report_text: str) -> BytesIO:
-    """Convert a formatted report into a visually appealing PDF with enhanced formatting."""
+    """Convert a formatted report into a clean, well-organized PDF."""
+    from matplotlib.backends.backend_pdf import PdfPages
+    import matplotlib.pyplot as plt
+    import matplotlib.patches as mpatches
+    from io import BytesIO
+    import textwrap
+    
     buffer = BytesIO()
     
-    # Configuration
+    # Page configuration - A4 size
     PAGE_WIDTH = 8.27  # A4 width in inches
     PAGE_HEIGHT = 11.69  # A4 height in inches
-    MARGIN_LEFT = 0.75
-    MARGIN_RIGHT = 0.75
-    MARGIN_TOP = 1.0
-    MARGIN_BOTTOM = 1.0
-    
-    # Calculate usable width for text
-    usable_width = PAGE_WIDTH - MARGIN_LEFT - MARGIN_RIGHT
-    chars_per_inch = 12  # Approximate for 10pt font
-    wrap_width = int(usable_width * chars_per_inch)
+    MARGIN = 0.75  # Uniform margins
     
-    # Text styling
-    FONT_SIZE_NORMAL = 10
-    FONT_SIZE_HEADING = 12
-    LINE_HEIGHT = 0.02  # Relative to page height
-    QUESTION_COLOR = '#2C3E50'  # Dark blue-gray
-    ANSWER_COLOR = '#34495E'  # Slightly lighter
-    SCORE_COLOR = '#27AE60'  # Green
-    FEEDBACK_COLOR = '#E74C3C'  # Red
+    # Text configuration
+    CHARS_PER_LINE = 80  # Characters per line for wrapping
+    LINES_PER_PAGE = 45  # Lines that fit on one page
     
-    # Prepare formatted content
-    raw_lines = report_text.split("\n")
-    wrapper = textwrap.TextWrapper(width=wrap_width, break_long_words=False, replace_whitespace=False)
+    # Colors
+    COLORS = {
+        'question': '#1e3a8a',  # Dark blue
+        'answer': '#374151',    # Dark gray
+        'score': '#059669',     # Green
+        'feedback': '#dc2626',  # Red
+        'header': '#111827',    # Almost black
+        'normal': '#374151'     # Gray
+    }
     
-    formatted_content = []
+    # Process the text
+    lines = report_text.split('\n')
+    processed_lines = []
+    wrapper = textwrap.TextWrapper(width=CHARS_PER_LINE, break_long_words=False)
     
-    for line in raw_lines:
-        stripped = line.strip()
-        
-        if stripped.startswith("Question"):
-            # Add spacing before questions (except the first one)
-            if formatted_content:
-                formatted_content.append({"text": "", "style": "normal"})
+    for line in lines:
+        if not line.strip():
+            processed_lines.append({'text': '', 'type': 'blank'})
+            continue
             
-            # Question with special formatting
-            formatted_content.append({
-                "text": stripped,
-                "style": "question",
-                "color": QUESTION_COLOR,
-                "bold": True,
-                "size": FONT_SIZE_HEADING
+        # Identify line type
+        if line.strip().startswith('Question'):
+            # Add spacing before questions (except first)
+            if processed_lines and processed_lines[-1]['type'] != 'blank':
+                processed_lines.append({'text': '', 'type': 'blank'})
+            processed_lines.append({
+                'text': line.strip(),
+                'type': 'question',
+                'size': 11,
+                'bold': True
             })
-            
-        elif stripped.startswith("Answer:"):
-            # Extract and wrap answer text
-            answer_text = stripped.replace("Answer:", "", 1).strip()
-            wrapped_lines = wrapper.wrap(f"Answer: {answer_text}") if answer_text else ["Answer:"]
-            
-            for idx, wrapped_line in enumerate(wrapped_lines):
-                formatted_content.append({
-                    "text": "  " + wrapped_line if idx == 0 else "         " + wrapped_line,
-                    "style": "answer",
-                    "color": ANSWER_COLOR,
-                    "size": FONT_SIZE_NORMAL
+        elif line.strip().startswith('Answer:'):
+            wrapped = wrapper.wrap(line.strip())
+            for i, wrapped_line in enumerate(wrapped):
+                processed_lines.append({
+                    'text': ('  ' + wrapped_line) if i == 0 else ('         ' + wrapped_line),
+                    'type': 'answer',
+                    'size': 10
                 })
-                
-        elif stripped.startswith("Score:"):
-            formatted_content.append({
-                "text": f"  {stripped}",
-                "style": "score",
-                "color": SCORE_COLOR,
-                "bold": True,
-                "size": FONT_SIZE_NORMAL
+        elif line.strip().startswith('Score:'):
+            processed_lines.append({
+                'text': '  ' + line.strip(),
+                'type': 'score',
+                'size': 10,
+                'bold': True
             })
-            
-        elif stripped.startswith("Feedback:"):
-            # Wrap feedback text
-            feedback_text = stripped.replace("Feedback:", "", 1).strip()
-            wrapped_lines = wrapper.wrap(f"Feedback: {feedback_text}") if feedback_text else ["Feedback:"]
-            
-            for idx, wrapped_line in enumerate(wrapped_lines):
-                formatted_content.append({
-                    "text": "  " + wrapped_line if idx == 0 else "           " + wrapped_line,
-                    "style": "feedback",
-                    "color": FEEDBACK_COLOR,
-                    "size": FONT_SIZE_NORMAL
+        elif line.strip().startswith('Feedback:'):
+            wrapped = wrapper.wrap(line.strip())
+            for i, wrapped_line in enumerate(wrapped):
+                processed_lines.append({
+                    'text': ('  ' + wrapped_line) if i == 0 else ('           ' + wrapped_line),
+                    'type': 'feedback',
+                    'size': 10
                 })
+        elif any(line.strip().startswith(x) for x in ['Interview Report', 'Candidate Name:', 'Candidate Email:', 
+                                                       'Job Applied:', 'Company:', 'Date Applied:', 
+                                                       'Skills Match Summary:', 'Interview Transcript']):
+            # Headers and metadata
+            if 'Interview Report' in line:
+                processed_lines.append({
+                    'text': line.strip(),
+                    'type': 'header',
+                    'size': 14,
+                    'bold': True
+                })
+                processed_lines.append({'text': '=' * 50, 'type': 'header', 'size': 10})
+            else:
+                wrapped = wrapper.wrap(line.strip())
+                for wrapped_line in enumerate(wrapped):
+                    processed_lines.append({
+                        'text': wrapped_line[1],
+                        'type': 'header',
+                        'size': 10,
+                        'bold': True if ':' in wrapped_line[1] and wrapped_line[0] == 0 else False
+                    })
         else:
             # Regular text
-            if stripped:
-                wrapped_lines = wrapper.wrap(line)
-                for wrapped_line in wrapped_lines:
-                    formatted_content.append({
-                        "text": wrapped_line,
-                        "style": "normal",
-                        "color": "black",
-                        "size": FONT_SIZE_NORMAL
-                    })
-            else:
-                formatted_content.append({"text": "", "style": "normal"})
-    
-    # Calculate lines per page based on actual line height
-    usable_height = PAGE_HEIGHT - MARGIN_TOP - MARGIN_BOTTOM
-    lines_per_page = int(usable_height / (LINE_HEIGHT * PAGE_HEIGHT))
+            wrapped = wrapper.wrap(line)
+            for wrapped_line in wrapped:
+                processed_lines.append({
+                    'text': wrapped_line,
+                    'type': 'normal',
+                    'size': 10
+                })
     
-    # Create PDF
+    # Create PDF with consistent pages
     with PdfPages(buffer) as pdf:
-        page_start = 0
-        page_num = 1
+        page_count = 0
+        line_index = 0
         
-        while page_start < len(formatted_content):
-            # Create figure
+        while line_index < len(processed_lines):
+            # Create new page
             fig = plt.figure(figsize=(PAGE_WIDTH, PAGE_HEIGHT))
             fig.patch.set_facecolor('white')
             ax = fig.add_subplot(111)
             ax.axis('off')
+            ax.set_xlim(0, 1)
+            ax.set_ylim(0, 1)
             
             # Add subtle page border
             border = mpatches.Rectangle(
-                (0.5, 0.5), PAGE_WIDTH - 1, PAGE_HEIGHT - 1,
-                fill=False, edgecolor='#BDC3C7', linewidth=0.5
+                (MARGIN/PAGE_WIDTH, MARGIN/PAGE_HEIGHT), 
+                1 - 2*MARGIN/PAGE_WIDTH, 
+                1 - 2*MARGIN/PAGE_HEIGHT,
+                fill=False, 
+                edgecolor='#e5e7eb', 
+                linewidth=1
             )
             ax.add_patch(border)
             
-            # Add page content
-            y_position = 1 - MARGIN_TOP / PAGE_HEIGHT
+            # Current y position (start from top)
+            y_pos = 1 - MARGIN/PAGE_HEIGHT - 0.05
             lines_on_page = 0
             
-            for idx in range(page_start, min(page_start + lines_per_page, len(formatted_content))):
-                item = formatted_content[idx]
+            # Add content to page
+            while line_index < len(processed_lines) and lines_on_page < LINES_PER_PAGE:
+                line_data = processed_lines[line_index]
                 
-                # Apply text styling
-                weight = 'bold' if item.get('bold', False) else 'normal'
-                size = item.get('size', FONT_SIZE_NORMAL)
-                color = item.get('color', 'black')
+                # Skip if too close to bottom
+                if y_pos < MARGIN/PAGE_HEIGHT + 0.05:
+                    break
+                
+                # Set text properties
+                color = COLORS.get(line_data['type'], COLORS['normal'])
+                size = line_data.get('size', 10)
+                weight = 'bold' if line_data.get('bold', False) else 'normal'
                 
-                # Add text to page
+                # Add text
                 ax.text(
-                    MARGIN_LEFT / PAGE_WIDTH,
-                    y_position,
-                    item['text'],
+                    MARGIN/PAGE_WIDTH + 0.02,
+                    y_pos,
+                    line_data['text'],
                     transform=ax.transAxes,
                     fontsize=size,
                     fontweight=weight,
                     color=color,
-                    fontfamily='DejaVu Sans',
+                    fontfamily='sans-serif',
                     verticalalignment='top'
                 )
                 
                 # Move to next line
-                y_position -= LINE_HEIGHT
+                line_height = 0.018 if line_data['type'] == 'blank' else 0.022
+                y_pos -= line_height
                 lines_on_page += 1
-                
-                # Check if we need a new page (with some buffer)
-                if y_position < MARGIN_BOTTOM / PAGE_HEIGHT + 0.05:
-                    break
+                line_index += 1
             
-            # Add page number
+            # Add page number at bottom
+            page_count += 1
             ax.text(
                 0.5,
-                MARGIN_BOTTOM / PAGE_HEIGHT / 2,
-                f"Page {page_num}",
+                MARGIN/PAGE_HEIGHT - 0.03,
+                f'Page {page_count}',
                 transform=ax.transAxes,
                 fontsize=9,
-                color='#7F8C8D',
+                color='#9ca3af',
                 horizontalalignment='center'
             )
             
             # Save page
-            pdf.savefig(fig, bbox_inches='tight', pad_inches=0)
+            pdf.savefig(fig, bbox_inches='tight', pad_inches=0.1)
             plt.close(fig)
-            
-            # Move to next page
-            page_start += lines_on_page
-            page_num += 1
     
     buffer.seek(0)
     return buffer
 
+
 def create_pdf_report_advanced(report_text: str) -> BytesIO:
     """
-    Alternative implementation using reportlab for better PDF generation.
+    Alternative implementation using reportlab for professional PDF generation.
+    This creates cleaner, more consistent PDFs with better text handling.
     Install with: pip install reportlab
     """
     try:
@@ -338,8 +349,11 @@ def create_pdf_report_advanced(report_text: str) -> BytesIO:
         from reportlab.lib.units import inch
         from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
         from reportlab.lib.colors import HexColor
+        from reportlab.lib.enums import TA_LEFT, TA_CENTER
         
         buffer = BytesIO()
+        
+        # Create document with consistent margins
         doc = SimpleDocTemplate(
             buffer,
             pagesize=A4,
@@ -349,43 +363,68 @@ def create_pdf_report_advanced(report_text: str) -> BytesIO:
             bottomMargin=1*inch
         )
         
-        # Create custom styles
+        # Define consistent styles
         styles = getSampleStyleSheet()
         
+        # Title style
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=16,
+            textColor=HexColor('#111827'),
+            spaceAfter=12,
+            alignment=TA_CENTER
+        )
+        
+        # Header style for metadata
+        header_style = ParagraphStyle(
+            'Header',
+            parent=styles['Normal'],
+            fontSize=10,
+            textColor=HexColor('#111827'),
+            spaceAfter=4
+        )
+        
+        # Question style
         question_style = ParagraphStyle(
             'Question',
             parent=styles['Heading2'],
-            fontSize=12,
-            textColor=HexColor('#2C3E50'),
+            fontSize=11,
+            textColor=HexColor('#1e3a8a'),
+            spaceBefore=12,
             spaceAfter=6,
-            spaceBefore=12
+            fontName='Helvetica-Bold'
         )
         
+        # Answer style
         answer_style = ParagraphStyle(
             'Answer',
             parent=styles['Normal'],
             fontSize=10,
-            textColor=HexColor('#34495E'),
+            textColor=HexColor('#374151'),
             leftIndent=20,
-            spaceAfter=3
+            spaceAfter=4
         )
         
+        # Score style
         score_style = ParagraphStyle(
             'Score',
             parent=styles['Normal'],
             fontSize=10,
-            textColor=HexColor('#27AE60'),
+            textColor=HexColor('#059669'),
             leftIndent=20,
-            fontName='Helvetica-Bold'
+            fontName='Helvetica-Bold',
+            spaceAfter=4
         )
         
+        # Feedback style
         feedback_style = ParagraphStyle(
             'Feedback',
             parent=styles['Normal'],
             fontSize=10,
-            textColor=HexColor('#E74C3C'),
+            textColor=HexColor('#dc2626'),
             leftIndent=20,
-            spaceAfter=6
+            spaceAfter=8
         )
         
         # Build document content
@@ -395,7 +434,19 @@ def create_pdf_report_advanced(report_text: str) -> BytesIO:
         for line in lines:
             stripped = line.strip()
             
-            if stripped.startswith('Question'):
+            if not stripped:
+                story.append(Spacer(1, 6))
+            elif 'Interview Report' in stripped:
+                story.append(Paragraph(stripped, title_style))
+                story.append(Spacer(1, 12))
+            elif any(stripped.startswith(x) for x in ['Candidate Name:', 'Candidate Email:', 
+                                                      'Job Applied:', 'Company:', 'Date Applied:']):
+                story.append(Paragraph(stripped, header_style))
+            elif stripped.startswith('Skills Match Summary:') or stripped.startswith('Interview Transcript'):
+                story.append(Spacer(1, 12))
+                story.append(Paragraph(f"<b>{stripped}</b>", header_style))
+                story.append(Spacer(1, 6))
+            elif stripped.startswith('Question'):
                 story.append(Paragraph(stripped, question_style))
             elif stripped.startswith('Answer:'):
                 story.append(Paragraph(stripped, answer_style))
@@ -403,18 +454,28 @@ def create_pdf_report_advanced(report_text: str) -> BytesIO:
                 story.append(Paragraph(stripped, score_style))
             elif stripped.startswith('Feedback:'):
                 story.append(Paragraph(stripped, feedback_style))
-            elif stripped:
-                story.append(Paragraph(stripped, styles['Normal']))
             else:
-                story.append(Spacer(1, 12))
+                # Regular text with proper indentation for sub-items
+                if stripped.startswith(' '):
+                    indent_style = ParagraphStyle(
+                        'Indented',
+                        parent=styles['Normal'],
+                        fontSize=10,
+                        leftIndent=20,
+                        spaceAfter=2
+                    )
+                    story.append(Paragraph(stripped, indent_style))
+                else:
+                    story.append(Paragraph(stripped, styles['Normal']))
         
         # Build PDF
         doc.build(story)
         buffer.seek(0)
         return buffer
-    
+        
     except ImportError:
-        # Fallback to matplotlib version
+        # Fallback to matplotlib version if reportlab not available
+        print("Reportlab not installed. Using matplotlib version.")
         return create_pdf_report(report_text)
-
+    
 __all__ = ['generate_llm_interview_report', 'create_pdf_report']