updated report

backend/services/report_generator.py

@@ -25,10 +25,12 @@ from __future__ import annotations
 import json
 from io import BytesIO
 import textwrap
-from typing import List
+from typing import List, Dict, Any, Tuple
 
 import matplotlib.pyplot as plt
 from matplotlib.backends.backend_pdf import PdfPages
+import matplotlib.patches as mpatches
+from matplotlib.patches import Rectangle, FancyBboxPatch
 
 def generate_llm_interview_report(application) -> str:
     """Generate a human‑readable interview report for a candidate.
@@ -145,198 +147,433 @@ def generate_llm_interview_report(application) -> str:
         lines.append(f"Error loading interview log: {e}")
 
     return '\n'.join(lines)
-from io import BytesIO
-from matplotlib.backends.backend_pdf import PdfPages
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-from typing import List, Tuple
-import textwrap
+
 
 def create_pdf_report(report_text: str) -> BytesIO:
-    """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
-    
+    """Convert a formatted report into a clean, professional A4 PDF."""
     buffer = BytesIO()
     
-    # Page configuration - A4 size
-    PAGE_WIDTH = 8.27  # A4 width in inches
-    PAGE_HEIGHT = 11.69  # A4 height in inches
-    MARGIN = 0.75  # Uniform margins
+    # A4 dimensions in inches (210mm x 297mm)
+    A4_WIDTH = 8.27
+    A4_HEIGHT = 11.69
     
-    # Text configuration
-    CHARS_PER_LINE = 80  # Characters per line for wrapping
-    LINES_PER_PAGE = 45  # Lines that fit on one page
+    # Margins in inches
+    LEFT_MARGIN = 0.75
+    RIGHT_MARGIN = 0.75
+    TOP_MARGIN = 1.0
+    BOTTOM_MARGIN = 1.0
     
-    # Colors
-    COLORS = {
-        'question': '#1e3a8a',  # Dark blue
-        'answer': '#374151',    # Dark gray
-        'score': '#059669',     # Green
-        'feedback': '#dc2626',  # Red
-        'header': '#111827',    # Almost black
-        'normal': '#374151'     # Gray
-    }
+    # Calculate content area
+    CONTENT_WIDTH = A4_WIDTH - LEFT_MARGIN - RIGHT_MARGIN
+    CONTENT_HEIGHT = A4_HEIGHT - TOP_MARGIN - BOTTOM_MARGIN
     
-    # Process the text
+    # Parse report data
+    report_data = _parse_report_text(report_text)
+    
+    # Create PDF
+    with PdfPages(buffer) as pdf:
+        # Page 1: Header and Summary
+        fig = plt.figure(figsize=(A4_WIDTH, A4_HEIGHT))
+        fig.patch.set_facecolor('white')
+        
+        # Create main axis
+        ax = fig.add_subplot(111)
+        ax.set_xlim(0, A4_WIDTH)
+        ax.set_ylim(0, A4_HEIGHT)
+        ax.axis('off')
+        
+        # Current Y position (start from top)
+        y_pos = A4_HEIGHT - TOP_MARGIN
+        
+        # Header background
+        header_rect = FancyBboxPatch(
+            (LEFT_MARGIN, y_pos - 1.5), CONTENT_WIDTH, 1.5,
+            boxstyle="round,pad=0.02",
+            facecolor='#1e40af',
+            edgecolor='none'
+        )
+        ax.add_patch(header_rect)
+        
+        # Company Logo placeholder (circle)
+        logo_circle = plt.Circle((LEFT_MARGIN + 0.5, y_pos - 0.75), 0.35, 
+                                color='white', alpha=0.3)
+        ax.add_patch(logo_circle)
+        
+        # Header text
+        ax.text(LEFT_MARGIN + 1.2, y_pos - 0.5, 'INTERVIEW REPORT',
+                fontsize=20, fontweight='bold', color='white',
+                verticalalignment='center')
+        
+        ax.text(LEFT_MARGIN + 1.2, y_pos - 1.0, 
+                f"{report_data['job_role']} • {report_data['company']}",
+                fontsize=12, color='white', alpha=0.9,
+                verticalalignment='center')
+        
+        y_pos -= 2.0
+        
+        # Overall Score Section (Prominent)
+        overall_score = _calculate_overall_score(report_data)
+        score_color = _get_score_color(overall_score['label'])
+        
+        # Score box
+        score_box = FancyBboxPatch(
+            (LEFT_MARGIN, y_pos - 1.2), CONTENT_WIDTH, 1.2,
+            boxstyle="round,pad=0.05",
+            facecolor=score_color,
+            alpha=0.1,
+            edgecolor=score_color,
+            linewidth=2
+        )
+        ax.add_patch(score_box)
+        
+        # Score text
+        ax.text(LEFT_MARGIN + CONTENT_WIDTH/2, y_pos - 0.3,
+                'OVERALL ASSESSMENT',
+                fontsize=10, color='#6b7280',
+                horizontalalignment='center')
+        
+        ax.text(LEFT_MARGIN + CONTENT_WIDTH/2, y_pos - 0.7,
+                overall_score['label'].upper(),
+                fontsize=28, fontweight='bold', color=score_color,
+                horizontalalignment='center')
+        
+        ax.text(LEFT_MARGIN + CONTENT_WIDTH/2, y_pos - 1.0,
+                f"{overall_score['percentage']}%",
+                fontsize=16, color=score_color,
+                horizontalalignment='center')
+        
+        y_pos -= 1.7
+        
+        # Candidate Information Section
+        _add_section_header(ax, LEFT_MARGIN, y_pos, 'Candidate Information', CONTENT_WIDTH)
+        y_pos -= 0.4
+        
+        # Info grid
+        info_items = [
+            ('Name', report_data['candidate_name']),
+            ('Email', report_data['candidate_email']),
+            ('Position', report_data['job_role']),
+            ('Company', report_data['company']),
+            ('Date Applied', report_data['date_applied'])
+        ]
+        
+        for i, (label, value) in enumerate(info_items):
+            y_offset = y_pos - (i * 0.3)
+            ax.text(LEFT_MARGIN + 0.2, y_offset, f"{label}:",
+                    fontsize=10, color='#6b7280')
+            ax.text(LEFT_MARGIN + 2.0, y_offset, value,
+                    fontsize=10, color='#111827', fontweight='bold')
+        
+        y_pos -= 1.8
+        
+        # Skills Match Summary
+        _add_section_header(ax, LEFT_MARGIN, y_pos, 'Skills Analysis', CONTENT_WIDTH)
+        y_pos -= 0.4
+        
+        # Skills match visualization
+        skills_data = report_data['skills_match']
+        
+        # Progress bar for match ratio
+        bar_x = LEFT_MARGIN + 0.2
+        bar_y = y_pos - 0.3
+        bar_width = CONTENT_WIDTH - 0.4
+        bar_height = 0.3
+        
+        # Background bar
+        bg_bar = Rectangle((bar_x, bar_y), bar_width, bar_height,
+                          facecolor='#e5e7eb', edgecolor='none')
+        ax.add_patch(bg_bar)
+        
+        # Progress bar
+        progress_width = bar_width * (skills_data['ratio'] / 100)
+        progress_color = _get_score_color(skills_data['score'])
+        progress_bar = Rectangle((bar_x, bar_y), progress_width, bar_height,
+                                facecolor=progress_color, edgecolor='none')
+        ax.add_patch(progress_bar)
+        
+        # Percentage text
+        ax.text(bar_x + bar_width/2, bar_y + bar_height/2,
+                f"{skills_data['ratio']:.0f}% Match",
+                fontsize=12, fontweight='bold', color='white',
+                horizontalalignment='center', verticalalignment='center')
+        
+        y_pos -= 0.8
+        
+        # Skills details
+        skills_items = [
+            ('Required Skills', skills_data['required']),
+            ('Candidate Skills', skills_data['candidate']),
+            ('Matching Skills', skills_data['common'])
+        ]
+        
+        for i, (label, value) in enumerate(skills_items):
+            y_offset = y_pos - (i * 0.4)
+            ax.text(LEFT_MARGIN + 0.2, y_offset, f"{label}:",
+                    fontsize=9, color='#6b7280')
+            # Wrap long skill lists
+            wrapped_value = textwrap.fill(value, width=60)
+            lines = wrapped_value.split('\n')
+            for j, line in enumerate(lines):
+                ax.text(LEFT_MARGIN + 0.2, y_offset - 0.2 - (j * 0.2), line,
+                        fontsize=9, color='#374151', style='italic')
+        
+        # Save first page
+        pdf.savefig(fig, bbox_inches='tight', pad_inches=0)
+        plt.close(fig)
+        
+        # Page 2+: Interview Transcript
+        if report_data['qa_log']:
+            _create_transcript_pages(pdf, report_data['qa_log'], A4_WIDTH, A4_HEIGHT,
+                                   LEFT_MARGIN, RIGHT_MARGIN, TOP_MARGIN, BOTTOM_MARGIN)
+    
+    buffer.seek(0)
+    return buffer
+
+
+def _parse_report_text(report_text: str) -> Dict[str, Any]:
+    """Parse the text report into structured data."""
     lines = report_text.split('\n')
-    processed_lines = []
-    wrapper = textwrap.TextWrapper(width=CHARS_PER_LINE, break_long_words=False)
+    data = {
+        'candidate_name': 'N/A',
+        'candidate_email': 'N/A',
+        'job_role': 'N/A',
+        'company': 'N/A',
+        'date_applied': 'N/A',
+        'skills_match': {
+            'required': 'N/A',
+            'candidate': 'N/A',
+            'common': 'N/A',
+            'ratio': 0,
+            'score': 'N/A'
+        },
+        'qa_log': []
+    }
+    
+    current_question = None
     
     for line in lines:
-        if not line.strip():
-            processed_lines.append({'text': '', 'type': 'blank'})
-            continue
-            
-        # 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 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 line.strip().startswith('Score:'):
-            processed_lines.append({
-                'text': '  ' + line.strip(),
-                'type': 'score',
-                'size': 10,
-                'bold': True
-            })
-        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
-                    })
+        line = line.strip()
+        if line.startswith('Candidate Name:'):
+            data['candidate_name'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Candidate Email:'):
+            data['candidate_email'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Job Applied:'):
+            data['job_role'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Company:'):
+            data['company'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Date Applied:'):
+            data['date_applied'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Required Skills:'):
+            data['skills_match']['required'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Candidate Skills:'):
+            data['skills_match']['candidate'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Skills in Common:'):
+            data['skills_match']['common'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Match Ratio:'):
+            try:
+                data['skills_match']['ratio'] = float(line.split(':')[1].strip().rstrip('%'))
+            except:
+                data['skills_match']['ratio'] = 0
+        elif line.startswith('Score:') and 'skills_match' in str(data):
+            data['skills_match']['score'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Question'):
+            if current_question:
+                data['qa_log'].append(current_question)
+            current_question = {
+                'question': line.split(':', 1)[1].strip() if ':' in line else line,
+                'answer': '',
+                'score': '',
+                'feedback': ''
+            }
+        elif line.startswith('Answer:') and current_question:
+            current_question['answer'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Score:') and current_question:
+            current_question['score'] = line.split(':', 1)[1].strip()
+        elif line.startswith('Feedback:') and current_question:
+            current_question['feedback'] = line.split(':', 1)[1].strip()
+    
+    if current_question:
+        data['qa_log'].append(current_question)
+    
+    return data
+
+
+def _calculate_overall_score(report_data: Dict[str, Any]) -> Dict[str, Any]:
+    """Calculate overall score from skills match and QA scores."""
+    # Skills match contributes 40%
+    skills_ratio = report_data['skills_match']['ratio'] / 100
+    
+    # QA scores contribute 60%
+    qa_scores = []
+    for qa in report_data['qa_log']:
+        score_text = qa['score'].lower()
+        if 'excellent' in score_text or '5' in score_text:
+            qa_scores.append(1.0)
+        elif 'good' in score_text or '4' in score_text:
+            qa_scores.append(0.8)
+        elif 'satisfactory' in score_text or '3' in score_text:
+            qa_scores.append(0.6)
+        elif 'needs improvement' in score_text or '2' in score_text:
+            qa_scores.append(0.4)
         else:
-            # Regular text
-            wrapped = wrapper.wrap(line)
-            for wrapped_line in wrapped:
-                processed_lines.append({
-                    'text': wrapped_line,
-                    'type': 'normal',
-                    'size': 10
-                })
+            qa_scores.append(0.2)
     
-    # Create PDF with consistent pages
-    with PdfPages(buffer) as pdf:
-        page_count = 0
-        line_index = 0
-        
-        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)
+    qa_average = sum(qa_scores) / len(qa_scores) if qa_scores else 0.5
+    
+    # Calculate weighted average
+    overall = (skills_ratio * 0.4) + (qa_average * 0.6)
+    percentage = overall * 100
+    
+    if overall >= 0.8:
+        label = 'Excellent'
+    elif overall >= 0.6:
+        label = 'Good'
+    elif overall >= 0.4:
+        label = 'Satisfactory'
+    else:
+        label = 'Needs Improvement'
+    
+    return {'percentage': percentage, 'label': label}
+
+
+def _get_score_color(score_label: str) -> str:
+    """Get color based on score label."""
+    score_label = score_label.lower()
+    if 'excellent' in score_label:
+        return '#059669'  # Green
+    elif 'good' in score_label:
+        return '#3b82f6'  # Blue
+    elif 'medium' in score_label or 'satisfactory' in score_label:
+        return '#f59e0b'  # Amber
+    else:
+        return '#ef4444'  # Red
+
+
+def _add_section_header(ax, x: float, y: float, title: str, width: float):
+    """Add a section header with separator line."""
+    # Title
+    ax.text(x, y, title.upper(), fontsize=12, fontweight='bold', 
+            color='#1e293b')
+    
+    # Separator line
+    line = plt.Line2D([x, x + width], [y - 0.15, y - 0.15],
+                      color='#e5e7eb', linewidth=1)
+    ax.add_line(line)
+
+
+def _create_transcript_pages(pdf, qa_log: List[Dict], 
+                           page_width: float, page_height: float,
+                           left_margin: float, right_margin: float,
+                           top_margin: float, bottom_margin: float):
+    """Create pages for interview transcript."""
+    content_width = page_width - left_margin - right_margin
+    wrapper = textwrap.TextWrapper(width=80)
+    
+    # Group questions for pagination
+    questions_per_page = 3
+    total_pages = (len(qa_log) + questions_per_page - 1) // questions_per_page
+    
+    for page_num in range(total_pages):
+        fig = plt.figure(figsize=(page_width, page_height))
+        fig.patch.set_facecolor('white')
+        ax = fig.add_subplot(111)
+        ax.set_xlim(0, page_width)
+        ax.set_ylim(0, page_height)
+        ax.axis('off')
+        
+        # Page header
+        y_pos = page_height - top_margin
+        ax.text(left_margin, y_pos, 'INTERVIEW TRANSCRIPT',
+                fontsize=14, fontweight='bold', color='#1e293b')
+        
+        # Page number
+        ax.text(page_width - right_margin, y_pos, f'Page {page_num + 2}',
+                fontsize=9, color='#9ca3af', horizontalalignment='right')
+        
+        y_pos -= 0.5
+        
+        # Questions for this page
+        start_idx = page_num * questions_per_page
+        end_idx = min(start_idx + questions_per_page, len(qa_log))
+        
+        for i in range(start_idx, end_idx):
+            qa = qa_log[i]
             
-            # Add subtle page border
-            border = mpatches.Rectangle(
-                (MARGIN/PAGE_WIDTH, MARGIN/PAGE_HEIGHT), 
-                1 - 2*MARGIN/PAGE_WIDTH, 
-                1 - 2*MARGIN/PAGE_HEIGHT,
-                fill=False, 
-                edgecolor='#e5e7eb', 
+            # Question box
+            q_box = FancyBboxPatch(
+                (left_margin, y_pos - 0.8), content_width, 0.8,
+                boxstyle="round,pad=0.02",
+                facecolor='#eff6ff',
+                edgecolor='#3b82f6',
                 linewidth=1
             )
-            ax.add_patch(border)
+            ax.add_patch(q_box)
             
-            # Current y position (start from top)
-            y_pos = 1 - MARGIN/PAGE_HEIGHT - 0.05
-            lines_on_page = 0
+            # Question number and text
+            ax.text(left_margin + 0.1, y_pos - 0.2, f'Q{i+1}.',
+                    fontsize=14, fontweight='bold', color='#1e40af')
             
-            # Add content to page
-            while line_index < len(processed_lines) and lines_on_page < LINES_PER_PAGE:
-                line_data = processed_lines[line_index]
-                
-                # 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
-                ax.text(
-                    MARGIN/PAGE_WIDTH + 0.02,
-                    y_pos,
-                    line_data['text'],
-                    transform=ax.transAxes,
-                    fontsize=size,
-                    fontweight=weight,
-                    color=color,
-                    fontfamily='sans-serif',
-                    verticalalignment='top'
-                )
-                
-                # Move to next line
-                line_height = 0.018 if line_data['type'] == 'blank' else 0.022
-                y_pos -= line_height
-                lines_on_page += 1
-                line_index += 1
+            # Wrap question text
+            q_wrapped = wrapper.wrap(qa['question'])
+            for j, line in enumerate(q_wrapped[:2]):  # Max 2 lines
+                ax.text(left_margin + 0.5, y_pos - 0.2 - (j * 0.25), line,
+                        fontsize=11, fontweight='bold', color='#1e293b')
+            
+            y_pos -= 1.2
+            
+            # Answer
+            ax.text(left_margin + 0.2, y_pos, 'Answer:',
+                    fontsize=10, fontweight='bold', color='#6b7280')
+            
+            a_wrapped = wrapper.wrap(qa['answer'])
+            for j, line in enumerate(a_wrapped[:3]):  # Max 3 lines
+                ax.text(left_margin + 0.2, y_pos - 0.3 - (j * 0.2), line,
+                        fontsize=10, color='#374151')
             
-            # Add page number at bottom
-            page_count += 1
-            ax.text(
-                0.5,
-                MARGIN/PAGE_HEIGHT - 0.03,
-                f'Page {page_count}',
-                transform=ax.transAxes,
-                fontsize=9,
-                color='#9ca3af',
-                horizontalalignment='center'
+            y_pos -= 1.0
+            
+            # Score and Feedback row
+            score_color = _get_score_color(qa['score'])
+            
+            # Score badge
+            score_badge = FancyBboxPatch(
+                (left_margin + 0.2, y_pos - 0.3), 1.5, 0.3,
+                boxstyle="round,pad=0.02",
+                facecolor=score_color,
+                alpha=0.2,
+                edgecolor=score_color,
+                linewidth=1
             )
+            ax.add_patch(score_badge)
             
-            # Save page
-            pdf.savefig(fig, bbox_inches='tight', pad_inches=0.1)
-            plt.close(fig)
-    
-    buffer.seek(0)
-    return buffer
+            ax.text(left_margin + 0.95, y_pos - 0.15, qa['score'],
+                    fontsize=9, fontweight='bold', color=score_color,
+                    horizontalalignment='center', verticalalignment='center')
+            
+            # Feedback
+            if qa['feedback'] and qa['feedback'] != 'N/A':
+                ax.text(left_margin + 2.0, y_pos, 'Feedback:',
+                        fontsize=9, style='italic', color='#6b7280')
+                
+                f_wrapped = wrapper.wrap(qa['feedback'])
+                for j, line in enumerate(f_wrapped[:2]):  # Max 2 lines
+                    ax.text(left_margin + 2.0, y_pos - 0.25 - (j * 0.2), line,
+                            fontsize=9, style='italic', color='#6b7280')
+            
+            y_pos -= 1.5
+            
+            # Add separator between questions (except last)
+            if i < end_idx - 1:
+                line = plt.Line2D([left_margin, left_margin + content_width], 
+                                [y_pos + 0.5, y_pos + 0.5],
+                                color='#e5e7eb', linewidth=0.5)
+                ax.add_line(line)
+        
+        pdf.savefig(fig, bbox_inches='tight', pad_inches=0)
+        plt.close(fig)
 
 
+# Keep the original advanced version as fallback
 def create_pdf_report_advanced(report_text: str) -> BytesIO:
     """
     Alternative implementation using reportlab for professional PDF generation.

backend/templates/closing.html

@@ -10,10 +10,7 @@
             <div class="luna-avatar-container">
                 <div class="luna-glow"></div>
                 <div class="luna-avatar">
-                    <video id="closingVideo" autoplay playsinline muted>
-                        <source src="{{ url_for('static', filename='videos/AI_Recruiter_Video_Generation.mp4') }}" type="video/mp4">
-                        Your browser does not support the video tag.
-                    </video>
+                    <img src="{{ url_for('static', filename='images/LUNA.png') }}" alt="LUNA AI Assistant">
                 </div>
             </div>
             <h2 style="margin-top: 1rem;">Thank you for your time,<br>we will get back to you if shortlisted.</h2>
@@ -21,10 +18,4 @@
     </div>
 </section>
 
-<script>
-    const video = document.getElementById('closingVideo');
-    video.addEventListener('ended', function() {
-        window.location.href = "{{ url_for('index') }}";
-    });
-</script>
 {% endblock %}