Update app.py

app.py

@@ -1,25 +1,16 @@
 #!/usr/bin/env python3
 """
-CCC Plus Quiz App — Production-ready Gradio app
-
-Features / improvements:
-- Replaces unsupported gr.Card() with gr.Group(elem_classes="card")
-- Robust uploaded-file path extraction (works with multiple Gradio versions)
-- Uses tempfile for PDF generation and ensures unique filenames
-- Visual progress bar (HTML <progress>)
-- Better error handling & logging
-- CLI args for host/port/share
-- Clean UI, report preview, and PDF download
-- Reset/Start controls guarded to avoid invalid state transitions
+CCC Plus Quiz App — Enhanced Production-ready Gradio app
 """
 
 import argparse
 import logging
 import os
 import tempfile
+import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import Optional, Tuple, List, Dict
 
 import gradio as gr
 import pandas as pd
@@ -30,7 +21,7 @@ from reportlab.pdfgen import canvas
 from reportlab.platypus import Image, Table, TableStyle
 
 # -----------------------
-# Logging (production)
+# Configuration & Logging
 # -----------------------
 logging.basicConfig(
     level=logging.INFO,
@@ -38,24 +29,27 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+# Configuration constants
+DEFAULT_CSV_PATH = "quiz.csv"
+REQUIRED_COLUMNS = {"question", "option1", "option2", "option3", "option4", "answer"}
+MAX_QUESTION_LENGTH = 300
+MAX_OPTION_LENGTH = 80
+PDF_MARGIN = 20 * mm
 
 # -----------------------
-# Utility helpers
+# Enhanced Utility helpers
 # -----------------------
 def extract_file_path(uploaded) -> Optional[str]:
     """
     Robustly extract a usable file-system path from Gradio's uploaded-file object.
-    Gradio's File/Image components can return:
-      - a dict (e.g. {'name': 'file.csv', 'tmp_path': '/tmp/tmpxxx', ...})
-      - a file-like object with .name path
-      - a plain string path (older setups)
-    Return None if no usable path found.
     """
     if uploaded is None:
         return None
+    
     # If already a filesystem path string
     if isinstance(uploaded, str):
         return uploaded if os.path.exists(uploaded) else None
+    
     # If Gradio returns a dict (common)
     if isinstance(uploaded, dict):
         for key in ("tmp_path", "tempfile", "file", "name", "tmpfile", "path"):
@@ -66,9 +60,11 @@ def extract_file_path(uploaded) -> Optional[str]:
         if "name" in uploaded and os.path.exists(uploaded["name"]):
             return uploaded["name"]
         return None
+    
     # If file-like object (has .name pointing to path)
     if hasattr(uploaded, "name") and isinstance(uploaded.name, str) and os.path.exists(uploaded.name):
         return uploaded.name
+    
     # last-ditch: try repr
     try:
         s = str(uploaded)
@@ -76,466 +72,908 @@ def extract_file_path(uploaded) -> Optional[str]:
             return s
     except Exception:
         pass
+    
     return None
 
 
 def safe_read_csv(path: str) -> pd.DataFrame:
     """
-    Read CSV with some guard rails (UTF-8 fallback etc.)
+    Read CSV with enhanced error handling and encoding detection.
     """
     if path is None:
         raise FileNotFoundError("No CSV path provided.")
-    # allow reading from path-like
+    
     if not os.path.exists(path):
         raise FileNotFoundError(f"File not found: {path}")
-    # try reading with utf-8, fallback to latin1
-    try:
-        return pd.read_csv(path)
-    except Exception:
-        return pd.read_csv(path, encoding="latin1")
+    
+    # Try multiple encodings
+    encodings = ['utf-8', 'latin1', 'cp1252', 'iso-8859-1']
+    
+    for encoding in encodings:
+        try:
+            df = pd.read_csv(path, encoding=encoding)
+            logger.info(f"Successfully read CSV with {encoding} encoding")
+            return df
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            logger.warning(f"Error reading CSV with {encoding}: {e}")
+            continue
+    
+    raise ValueError("Could not read CSV file with any supported encoding")
+
+
+def validate_quiz_data(quiz: List[Dict]) -> List[str]:
+    """
+    Validate quiz data and return list of warnings/errors.
+    """
+    warnings = []
+    
+    if not quiz:
+        warnings.append("No questions found in the quiz data")
+        return warnings
+    
+    for i, q in enumerate(quiz, 1):
+        # Check for empty questions
+        if not q.get("question", "").strip():
+            warnings.append(f"Question {i}: Empty question text")
+        
+        # Check for duplicate options
+        options = [opt.strip().lower() for opt in q.get("options", []) if opt.strip()]
+        if len(options) != len(set(options)):
+            warnings.append(f"Question {i}: Duplicate answer options detected")
+        
+        # Check if answer matches any option
+        answer = q.get("answer", "").strip()
+        if answer not in q.get("options", []):
+            warnings.append(f"Question {i}: Answer '{answer}' not found in options")
+        
+        # Check for very short options
+        short_options = [opt for opt in q.get("options", []) if len(opt.strip()) < 2]
+        if short_options:
+            warnings.append(f"Question {i}: Very short answer options detected")
+    
+    return warnings
 
 
 # -----------------------
-# Quiz CSV loader
+# Enhanced Quiz CSV loader
 # -----------------------
-REQUIRED_COLUMNS = {"question", "option1", "option2", "option3", "option4", "answer"}
-
-
-def load_quiz_from_path(path: str):
+def load_quiz_from_path(path: str) -> Tuple[List[Dict], List[str]]:
+    """
+    Load quiz from CSV and return quiz data and validation warnings.
+    """
     df = safe_read_csv(path)
-    cols = set(df.columns.str.lower())
-    # Accept case-insensitive columns by mapping lower->actual
-    col_map = {c.lower(): c for c in df.columns}
-    missing = REQUIRED_COLUMNS - set(cols)
+    
+    # Normalize column names (case-insensitive)
+    df.columns = df.columns.str.strip().str.lower()
+    cols = set(df.columns)
+    
+    # Check for required columns
+    missing = REQUIRED_COLUMNS - cols
     if missing:
         raise ValueError(f"CSV missing required columns (case-insensitive): {missing}")
-    # normalize rows
+    
+    # Process quiz data
     quiz = []
-    for _, r in df.iterrows():
-        q = str(r[col_map["question"]])
-        opts = [
-            str(r[col_map["option1"]]),
-            str(r[col_map["option2"]]),
-            str(r[col_map["option3"]]),
-            str(r[col_map["option4"]]),
-        ]
-        ans = str(r[col_map["answer"]])
-        quiz.append({"question": q, "options": opts, "answer": ans})
-    return quiz
+    for idx, row in df.iterrows():
+        try:
+            question = str(row["question"]).strip()
+            options = [
+                str(row["option1"]).strip(),
+                str(row["option2"]).strip(),
+                str(row["option3"]).strip(),
+                str(row["option4"]).strip(),
+            ]
+            answer = str(row["answer"]).strip()
+            
+            # Skip empty questions
+            if not question or question.lower() in ['nan', 'none', '']:
+                continue
+                
+            quiz.append({
+                "question": question,
+                "options": options,
+                "answer": answer
+            })
+            
+        except Exception as e:
+            logger.warning(f"Error processing row {idx + 1}: {e}")
+            continue
+    
+    # Validate quiz data
+    warnings = validate_quiz_data(quiz)
+    
+    return quiz, warnings
 
 
 # -----------------------
-# PDF generation
+# Enhanced PDF generation
 # -----------------------
-def generate_report_pdf(user_name: str, quiz_title: str, history: list, score: int, logo_path: Optional[str] = None) -> str:
+def generate_report_pdf(
+    user_name: str, 
+    quiz_title: str, 
+    history: List[Dict], 
+    score: int, 
+    logo_path: Optional[str] = None,
+    include_statistics: bool = True
+) -> str:
     """
-    Create a PDF report, store in a secure temporary file and return the path.
-    history: list of {"question","selected","answer","correct"}
+    Create an enhanced PDF report with statistics and better formatting.
     """
     ts = datetime.now().strftime("%Y%m%d_%H%M%S")
-    tmp = tempfile.NamedTemporaryFile(prefix=f"CCCPlus_Report_{ts}_", suffix=".pdf", delete=False)
+    tmp = tempfile.NamedTemporaryFile(
+        prefix=f"CCCPlus_Report_{ts}_", 
+        suffix=".pdf", 
+        delete=False
+    )
     tmp.close()
     filename = tmp.name
 
     c = canvas.Canvas(filename, pagesize=A4)
     width, height = A4
-    margin = 20 * mm
-    y = height - margin
+    y = height - PDF_MARGIN
 
-    # Optional logo
+    # Draw logo if available
     if logo_path and os.path.exists(logo_path):
         try:
             img_w = 30 * mm
             img = Image(logo_path, img_w, img_w)
-            img.drawOn(c, margin, y - img_w)
-            x_title = margin + img_w + 8
-        except Exception:
-            logger.exception("Failed to draw logo on PDF")
-            x_title = margin
+            img.drawOn(c, PDF_MARGIN, y - img_w)
+            x_title = PDF_MARGIN + img_w + 8
+        except Exception as e:
+            logger.warning(f"Failed to draw logo on PDF: {e}")
+            x_title = PDF_MARGIN
     else:
-        x_title = margin
+        x_title = PDF_MARGIN
 
     # Header
     c.setFont("Helvetica-Bold", 18)
     c.drawString(x_title, y - 8, quiz_title)
+    
     c.setFont("Helvetica", 10)
     c.drawString(x_title, y - 28, f"Candidate: {user_name}")
     c.drawString(x_title, y - 42, f"Date: {datetime.now().strftime('%d %b %Y %H:%M:%S')}")
     y -= 60
 
-    # Score
+    # Score and Statistics
     c.setFont("Helvetica-Bold", 14)
-    c.drawString(margin, y, f"Final Score: {score} / {len(history)}")
+    total_questions = len(history)
+    percentage = (score / total_questions * 100) if total_questions > 0 else 0
+    
+    c.drawString(PDF_MARGIN, y, f"Final Score: {score} / {total_questions} ({percentage:.1f}%)")
     y -= 22
 
-    # Table
+    if include_statistics and history:
+        # Add performance statistics
+        c.setFont("Helvetica", 10)
+        correct_count = sum(1 for h in history if h.get("correct", False))
+        incorrect_count = total_questions - correct_count
+        
+        c.drawString(PDF_MARGIN, y, f"Correct Answers: {correct_count}")
+        c.drawString(PDF_MARGIN + 100, y, f"Incorrect Answers: {incorrect_count}")
+        y -= 16
+
+    y -= 10
+
+    # Results table
     table_data = [["#", "Question", "Your Answer", "Correct Answer", "Result"]]
+    
     for i, h in enumerate(history, start=1):
-        result = "Correct" if h.get("correct") else "Incorrect"
-        # Protect excessively long text from breaking layout by truncating
-        qtext = (h.get("question") or "")[:300]
-        sel = (h.get("selected") or "")[:80]
-        ans = (h.get("answer") or "")[:80]
-        table_data.append([str(i), qtext, sel, ans, result])
-
+        result = "✓ Correct" if h.get("correct") else "✗ Incorrect"
+        
+        # Truncate long text to prevent layout issues
+        question_text = (h.get("question") or "")[:MAX_QUESTION_LENGTH]
+        selected_text = (h.get("selected") or "")[:MAX_OPTION_LENGTH]
+        answer_text = (h.get("answer") or "")[:MAX_OPTION_LENGTH]
+        
+        table_data.append([
+            str(i), 
+            question_text, 
+            selected_text, 
+            answer_text, 
+            result
+        ])
+
+    # Create and style table
     col_widths = [12 * mm, 90 * mm, 40 * mm, 40 * mm, 25 * mm]
     table = Table(table_data, colWidths=col_widths)
-    style = TableStyle(
-        [
-            ("GRID", (0, 0), (-1, -1), 0.25, colors.grey),
-            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#003366")),
-            ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
-            ("VALIGN", (0, 0), (-1, -1), "TOP"),
-            ("FONTSIZE", (0, 0), (-1, -1), 8),
-        ]
-    )
-    table.setStyle(style)
-
-    # Layout the table; if doesn't fit, create new page(s)
-    w, h_table = table.wrapOn(c, width - 2 * margin, y - margin)
-    if y - h_table < margin + 30:
+    
+    table_style = [
+        ("GRID", (0, 0), (-1, -1), 0.25, colors.grey),
+        ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#003366")),
+        ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+        ("VALIGN", (0, 0), (-1, -1), "TOP"),
+        ("FONTSIZE", (0, 0), (-1, -1), 8),
+        ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+    ]
+    
+    # Add alternating row colors
+    for i in range(1, len(table_data)):
+        if i % 2 == 0:
+            table_style.append(("BACKGROUND", (0, i), (-1, i), colors.HexColor("#f5f5f5")))
+    
+    table.setStyle(TableStyle(table_style))
+
+    # Layout table with page breaks if needed
+    w, h_table = table.wrapOn(c, width - 2 * PDF_MARGIN, y - PDF_MARGIN)
+    
+    if y - h_table < PDF_MARGIN + 30:
         c.showPage()
-        y = height - margin
-    table.drawOn(c, margin, y - h_table)
+        y = height - PDF_MARGIN
+    
+    table.drawOn(c, PDF_MARGIN, y - h_table)
     y = y - h_table - 30
 
     # Footer
     c.setFont("Helvetica", 8)
-    footer_text = f"NIELIT Chandigarh — © {datetime.now().year}"
+    footer_text = f"NIELIT Chandigarh — © {datetime.now().year} — Generated automatically"
     c.drawCentredString(width / 2, 12 * mm, footer_text)
 
     c.save()
-    logger.info("Generated PDF report at %s", filename)
+    logger.info(f"Generated enhanced PDF report: {filename}")
     return filename
 
 
 # -----------------------
-# Gradio app logic
+# Enhanced Quiz Logic
 # -----------------------
 def prepare_quiz(csv_file_text: str, csv_upload):
     """
-    Called to load questions from CSV and initialize state.
-    Returns:
-      - first question text (or empty string)
-      - options update
-      - visibility updates for controls
-      - message
-      - initialized state dict
+    Load questions from CSV with enhanced validation and feedback.
     """
-    # prefer uploaded file if present
     uploaded_path = extract_file_path(csv_upload)
-    path = uploaded_path or (csv_file_text if os.path.exists(csv_file_text) else None)
+    path = uploaded_path or (csv_file_text if csv_file_text and os.path.exists(csv_file_text) else None)
+    
     if not path:
-        msg = "No questions loaded. Upload a CSV or place quiz.csv in the app folder."
+        msg = "⚠️ No questions loaded. Upload a CSV file or ensure quiz.csv exists in the app folder."
         return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), msg, {}
 
     try:
-        quiz = load_quiz_from_path(path)
+        quiz, warnings = load_quiz_from_path(path)
     except Exception as e:
         logger.exception("Failed to load quiz CSV")
-        return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), f"Error loading CSV: {e}", {}
+        error_msg = f"❌ Error loading CSV: {str(e)}"
+        return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), error_msg, {}
 
     if not quiz:
-        return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), "No questions found in CSV.", {}
+        msg = "❌ No valid questions found in CSV file."
+        return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), msg, {}
 
-    store = {"quiz": quiz, "index": 0, "score": 0, "history": [], "started": False}
-    first = quiz[0]
-    msg = f"Loaded {len(quiz)} questions. Click Start to begin."
-    return first["question"], gr.update(choices=first["options"], value=None), gr.update(visible=True), gr.update(visible=False), msg, store
+    # Prepare state
+    state = {
+        "quiz": quiz, 
+        "index": 0, 
+        "score": 0, 
+        "history": [], 
+        "started": False,
+        "total_questions": len(quiz)
+    }
+    
+    first_question = quiz[0]
+    
+    # Create status message with warnings
+    msg_parts = [f"✅ Loaded {len(quiz)} questions successfully."]
+    
+    if warnings:
+        msg_parts.append(f"\n⚠️ {len(warnings)} validation warning(s):")
+        for warning in warnings[:3]:  # Show first 3 warnings
+            msg_parts.append(f"  • {warning}")
+        if len(warnings) > 3:
+            msg_parts.append(f"  • ... and {len(warnings) - 3} more warnings")
+    
+    msg_parts.append("\n🚀 Click 'Start Quiz' to begin!")
+    status_msg = "\n".join(msg_parts)
+    
+    return (
+        first_question["question"], 
+        gr.update(choices=first_question["options"], value=None), 
+        gr.update(visible=True), 
+        gr.update(visible=False), 
+        status_msg, 
+        state
+    )
 
 
+def get_enhanced_progress_html(state) -> str:
+    """
+    Enhanced progress display with better styling and information.
+    """
+    if not state or "quiz" not in state or not state["quiz"]:
+        return "<div style='text-align: center; color: #666;'>No quiz loaded</div>"
+    
+    total = len(state["quiz"])
+    current = min(state.get("index", 0), total)
+    score = state.get("score", 0)
+    
+    # Calculate percentage
+    progress_pct = int((current / total) * 100) if total > 0 else 0
+    score_pct = int((score / total) * 100) if total > 0 else 0
+    
+    # Determine progress color based on score percentage
+    if score_pct >= 80:
+        score_color = "#28a745"  # green
+    elif score_pct >= 60:
+        score_color = "#ffc107"  # yellow
+    else:
+        score_color = "#dc3545"  # red
+    
+    html = f"""
+    <div style='background: linear-gradient(135deg, #f8f9fa, #e9ecef); 
+                padding: 16px; border-radius: 12px; border: 1px solid #dee2e6;'>
+        <div style='display: flex; justify-content: space-between; align-items: center; margin-bottom: 10px;'>
+            <span style='font-weight: 600; color: #495057;'>Question {current} of {total}</span>
+            <span style='font-weight: 600; color: {score_color};'>Score: {score}/{total}</span>
+        </div>
+        
+        <div style='background: #e9ecef; border-radius: 10px; overflow: hidden; height: 20px; margin-bottom: 8px;'>
+            <div style='background: linear-gradient(90deg, #007bff, #0056b3); 
+                        height: 100%; width: {progress_pct}%; 
+                        transition: width 0.3s ease;'></div>
+        </div>
+        
+        <div style='display: flex; justify-content: space-between; font-size: 12px; color: #6c757d;'>
+            <span>Progress: {progress_pct}%</span>
+            <span>Accuracy: {score_pct}%</span>
+        </div>
+    </div>
+    """
+    
+    return html
+
+
+# -----------------------
+# Existing functions with minor enhancements
+# -----------------------
 def start_quiz(state):
+    """Start the quiz with enhanced state management."""
     if not state or "quiz" not in state or not state["quiz"]:
-        return "No quiz loaded. Load CSV first.", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
-    state["index"] = 0
-    state["score"] = 0
-    state["history"] = []
-    state["started"] = True
-    first = state["quiz"][0]
-    # show Submit, hide Next until submitted
-    return first["question"], gr.update(choices=first["options"], value=None), gr.update(visible=True), gr.update(visible=False), state
+        return "❌ No quiz loaded. Please load a CSV file first.", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
+    
+    # Reset quiz state
+    state.update({
+        "index": 0,
+        "score": 0,
+        "history": [],
+        "started": True,
+        "start_time": datetime.now()
+    })
+    
+    first_question = state["quiz"][0]
+    return (
+        first_question["question"], 
+        gr.update(choices=first_question["options"], value=None), 
+        gr.update(visible=True), 
+        gr.update(visible=False), 
+        state
+    )
 
 
 def submit_answer(state, selected):
+    """Submit answer with enhanced feedback."""
     if not state or "quiz" not in state:
-        return "No quiz loaded.", gr.update(visible=False), gr.update(visible=False), state
+        return "❌ No quiz loaded.", gr.update(visible=False), gr.update(visible=False), state
+    
     if not state.get("started"):
-        return "Quiz has not been started. Click Start.", gr.update(visible=False), gr.update(visible=False), state
-
-    idx = state["index"]
-    q = state["quiz"][idx]
-    selected_val = selected if selected is not None else ""
-    correct = (selected_val == q["answer"])
-    last = {"question": q["question"], "selected": selected_val, "answer": q["answer"], "correct": correct}
-    state["last"] = last
-    feedback = "✅ Correct!" if correct else f"❌ Incorrect. Correct answer: {q['answer']}"
-    # enable Next button after submit
+        return "❌ Quiz not started. Click 'Start Quiz' first.", gr.update(visible=False), gr.update(visible=False), state
+
+    current_idx = state["index"]
+    current_question = state["quiz"][current_idx]
+    selected_answer = selected if selected is not None else ""
+    
+    is_correct = (selected_answer == current_question["answer"])
+    
+    # Store the result temporarily
+    state["last_result"] = {
+        "question": current_question["question"],
+        "selected": selected_answer,
+        "answer": current_question["answer"],
+        "correct": is_correct
+    }
+    
+    # Enhanced feedback
+    if is_correct:
+        feedback = f"✅ <span style='color: #28a745; font-weight: 600;'>Correct!</span>"
+    else:
+        feedback = f"❌ <span style='color: #dc3545; font-weight: 600;'>Incorrect.</span> The correct answer is: <strong>{current_question['answer']}</strong>"
+    
     return feedback, gr.update(visible=True), gr.update(visible=True), state
 
 
-def next_q(state):
+def next_question(state):
+    """Move to next question with enhanced state management."""
     if not state or "quiz" not in state:
-        return "No quiz loaded.", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
-    last = state.get("last")
-    if last:
-        state["history"].append(last)
-        if last.get("correct"):
+        return "❌ No quiz loaded.", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
+    
+    # Process the last result if it exists
+    if "last_result" in state:
+        last_result = state.pop("last_result")
+        state["history"].append(last_result)
+        if last_result.get("correct"):
             state["score"] += 1
-    # move to next index
+    
+    # Move to next question
     state["index"] += 1
-    state.pop("last", None)
-
+    
+    # Check if quiz is complete
     if state["index"] >= len(state["quiz"]):
-        finished_msg = f"Quiz Completed! Final Score: {state['score']} / {len(state['quiz'])}"
         state["started"] = False
-        # hide question controls
-        return finished_msg, gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
-
-    q = state["quiz"][state["index"]]
-    return q["question"], gr.update(choices=q["options"], value=None), gr.update(visible=True), gr.update(visible=False), state
-
-
-def get_progress_html(state) -> str:
-    """
-    Returns an HTML string with a styled progress bar showing progress and score.
-    We'll use a simple <progress> element and a little text.
-    """
-    if not state or "quiz" not in state or not state["quiz"]:
-        return "<div>No quiz loaded.</div>"
-    total = len(state["quiz"])
-    # If quiz complete, progress equals total
-    idx = min(state.get("index", 0), total)
-    # when 'last' present but not yet saved, count current index as answered? Keep visual simple: show index+1 if not finished
-    pct_value = int((idx / total) * 100)
-    # Create a small HTML snippet
+        state["end_time"] = datetime.now()
+        
+        # Calculate completion time
+        if "start_time" in state:
+            duration = state["end_time"] - state["start_time"]
+            duration_str = f"Completed in {duration.seconds // 60}m {duration.seconds % 60}s"
+        else:
+            duration_str = ""
+        
+        completion_msg = f"""
+        🎉 <strong>Quiz Completed!</strong><br>
+        📊 Final Score: <strong>{state['score']} / {len(state['quiz'])} ({state['score']/len(state['quiz'])*100:.1f}%)</strong><br>
+        ⏱️ {duration_str}
+        """
+        
+        return completion_msg, gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), state
+    
+    # Show next question
+    next_q = state["quiz"][state["index"]]
     return (
-        f"<div style='font-size:14px;margin-bottom:6px;'>"
-        f"Question: {min(idx + 1, total)} of {total} &nbsp; — &nbsp; Score: {state.get('score',0)}</div>"
-        f"<progress value='{pct_value}' max='100' style='width:100%;height:14px;'></progress>"
+        next_q["question"], 
+        gr.update(choices=next_q["options"], value=None), 
+        gr.update(visible=True), 
+        gr.update(visible=False), 
+        state
     )
 
 
 def show_report(state, user_name: str, logo_file):
+    """Generate enhanced report with better formatting."""
     if not state or "history" not in state:
-        return "No results to show.", None
+        return "📝 No quiz results available. Complete a quiz first.", None
+    
     history = list(state["history"])
-    # include last if user submitted but didn't press next
-    if "last" in state:
-        history.append(state["last"])
-    md_lines = []
-    md_lines.append(f"## Report Card — {user_name or 'Candidate'}")
-    md_lines.append(f"**Date:** {datetime.now().strftime('%d %b %Y %H:%M:%S')}")
-    md_lines.append(f"**Score:** **{state['score']} / {len(state['quiz'])}**")
-    md_lines.append("")
-    md_lines.append("| # | Question | Your Answer | Correct Answer | Result |")
-    md_lines.append("|---:|---|---|---|---:|")
-    for i, h in enumerate(history, start=1):
-        res = "✅" if h["correct"] else "❌"
-        qtext = (h["question"] or "").replace("\n", " ")
-        md_lines.append(f"| {i} | {qtext[:120]} | {h['selected']} | {h['answer']} | {res} |")
-    md = "\n".join(md_lines)
-
-    # Resolve logo path (uploaded or local default)
-    logo_path = extract_file_path(logo_file) or ("nielit_logo.png" if os.path.exists("nielit_logo.png") else None)
-
+    
+    # Include the last result if it exists but wasn't processed yet
+    if "last_result" in state:
+        history.append(state["last_result"])
+    
+    if not history:
+        return "📝 No quiz results available. Complete a quiz first.", None
+    
+    # Generate markdown report
+    candidate_name = user_name.strip() if user_name else "Anonymous Candidate"
+    total_questions = len(history)
+    correct_answers = sum(1 for h in history if h.get("correct", False))
+    percentage = (correct_answers / total_questions * 100) if total_questions > 0 else 0
+    
+    # Determine performance level
+    if percentage >= 90:
+        performance = "🏆 Excellent"
+    elif percentage >= 80:
+        performance = "👍 Good"
+    elif percentage >= 60:
+        performance = "👌 Average"
+    else:
+        performance = "📚 Needs Improvement"
+    
+    md_lines = [
+        f"# 📋 Quiz Report Card",
+        f"**Candidate:** {candidate_name}",
+        f"**Date:** {datetime.now().strftime('%d %B %Y at %H:%M:%S')}",
+        f"**Final Score:** **{correct_answers} / {total_questions} ({percentage:.1f}%)**",
+        f"**Performance Level:** {performance}",
+        "",
+        "## 📊 Detailed Results",
+        "",
+        "| # | Question | Your Answer | Correct Answer | Result |",
+        "|---:|---|---|---|:---:|"
+    ]
+    
+    for i, result in enumerate(history, start=1):
+        status_icon = "✅" if result.get("correct") else "❌"
+        question_text = (result.get("question", "") or "").replace("\n", " ")[:120]
+        if len(question_text) > 117:
+            question_text += "..."
+        
+        md_lines.append(
+            f"| {i} | {question_text} | {result.get('selected', 'No answer')} | "
+            f"{result.get('answer', 'Unknown')} | {status_icon} |"
+        )
+    
+    report_md = "\n".join(md_lines)
+    
+    # Generate PDF
+    logo_path = extract_file_path(logo_file) or (
+        "nielit_logo.png" if os.path.exists("nielit_logo.png") else None
+    )
+    
     try:
-        pdf_path = generate_report_pdf(user_name or "Candidate", "CCC Plus - Computer Concepts Plus", history, state["score"], logo_path=logo_path)
+        pdf_path = generate_report_pdf(
+            candidate_name, 
+            "CCC Plus - Computer Concepts Plus", 
+            history, 
+            correct_answers, 
+            logo_path=logo_path,
+            include_statistics=True
+        )
+        return report_md, pdf_path
+        
     except Exception as e:
-        logger.exception("Failed to generate PDF")
-        return md + f"\n\n**PDF generation failed:** {e}", None
-
-    return md, pdf_path
+        logger.exception("Failed to generate PDF report")
+        error_report = report_md + f"\n\n**⚠️ PDF Generation Failed:** {str(e)}"
+        return error_report, None
 
 
 # -----------------------
-# Build Gradio interface
+# Enhanced Gradio Interface
 # -----------------------
 def build_app():
+    """Build the enhanced Gradio interface."""
     css = """
-    .header {display:flex; align-items:center; gap:12px;}
-    .logo-small {height:56px;}
-    .card {border-radius:12px; padding:14px; box-shadow: 0 6px 18px rgba(0,0,0,0.06);}
-    .muted {color: #666; font-size: 13px;}
-    .small {font-size:13px; color:#444;}
+    .header {
+        display: flex; 
+        align-items: center; 
+        gap: 12px;
+    }
+    .logo-small {
+        height: 56px;
+    }
+    .card {
+        border-radius: 12px; 
+        padding: 20px; 
+        box-shadow: 0 6px 18px rgba(0,0,0,0.08);
+        background: white;
+        border: 1px solid #e9ecef;
+    }
+    .muted {
+        color: #6c757d; 
+        font-size: 14px;
+    }
+    .small {
+        font-size: 13px; 
+        color: #495057;
+    }
+    .status-box {
+        background: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 8px;
+        padding: 12px;
+        font-family: monospace;
+        font-size: 13px;
+    }
     """
 
-    with gr.Blocks(title="CCC Plus Quiz App — NIELIT Style", css=css) as demo:
-        # Top row
+    with gr.Blocks(
+        title="CCC Plus Quiz App — NIELIT Chandigarh", 
+        css=css,
+        theme=gr.themes.Soft()
+    ) as demo:
+        
+        # Header section
         with gr.Row():
-            with gr.Column(scale=1):
-                logo_img = gr.Image(value="nielit_logo.png" if os.path.exists("nielit_logo.png") else None,
-                                    visible=True, elem_id="logo-img", interactive=False)
+            with gr.Column(scale=1, min_width=80):
+                logo_img = gr.Image(
+                    value="nielit_logo.png" if os.path.exists("nielit_logo.png") else None,
+                    visible=True, 
+                    interactive=False,
+                    height=80,
+                    show_label=False
+                )
+            
             with gr.Column(scale=6):
-                gr.Markdown("<div class='header'><h2 style='margin:0'>🖥️ CCC Plus — Computer Concepts Plus</h2></div>")
-                gr.Markdown("<div class='muted'>Interactive quiz for practice & assessment. Upload CSV or use default quiz.csv.</div>")
+                gr.Markdown("""
+                <div class='header'>
+                    <h1 style='margin:0; color: #003366;'>🖥️ CCC Plus — Computer Concepts Plus</h1>
+                </div>
+                <div class='muted' style='margin-top: 8px;'>
+                    Interactive quiz application for practice & assessment • Upload your CSV file or use the default quiz.csv
+                </div>
+                """)
 
         gr.Markdown("---")
 
+        # Main interface
         with gr.Row():
-            # LEFT: controls
+            # Left panel - Controls
             with gr.Column(scale=3):
-                gr.Markdown("### Load Questions")
-                csv_file_text = gr.Textbox(value="quiz.csv", label="Local CSV path (default)", interactive=True)
-                csv_upload = gr.File(label="Or upload CSV file", file_count="single", file_types=[".csv"])
-                load_btn = gr.Button("Load CSV")
-                load_msg = gr.Textbox(label="Status", interactive=False, lines=2, value="No quiz loaded.")
-
-                gr.Markdown("### Candidate Info")
-                user_name = gr.Textbox(label="Candidate Name (to appear on report)", placeholder="Your name here")
-
-                start_btn = gr.Button("Start Quiz", elem_id="start-btn")
-                restart_btn = gr.Button("Reset All", elem_id="reset-btn", visible=True)
-
-                gr.Markdown("### Controls")
-                submit_btn = gr.Button("Submit Answer", variant="primary", visible=False)
-                next_btn = gr.Button("Next Question ➡️", visible=False)
-                feedback = gr.Textbox(label="Feedback", interactive=False, visible=False, lines=2)
-
-                gr.Markdown("### Report")
-                show_report_btn = gr.Button("Generate / Refresh Report")
-                report_preview = gr.Markdown("No report yet.")
-                report_download = gr.File(label="Download PDF Report", visible=False)
-
-            # RIGHT: question and progress area
+                # Quiz loading section
+                with gr.Group():
+                    gr.Markdown("### 📁 Load Quiz Questions")
+                    csv_file_text = gr.Textbox(
+                        value=DEFAULT_CSV_PATH,
+                        label="Local CSV file path",
+                        placeholder="Enter path to CSV file...",
+                        interactive=True
+                    )
+                    csv_upload = gr.File(
+                        label="Or upload CSV file",
+                        file_count="single",
+                        file_types=[".csv"]
+                    )
+                    load_btn = gr.Button("🔄 Load Quiz", variant="primary")
+                    
+                    load_status = gr.HTML(
+                        value="<div class='status-box'>📄 No quiz loaded. Upload a CSV file to begin.</div>",
+                        label="Status"
+                    )
+
+                # Candidate information
+                with gr.Group():
+                    gr.Markdown("### 👤 Candidate Information")
+                    user_name = gr.Textbox(
+                        label="Full Name",
+                        placeholder="Enter your full name for the certificate...",
+                        value=""
+                    )
+
+                # Quiz controls
+                with gr.Group():
+                    gr.Markdown("### 🎯 Quiz Controls")
+                    start_btn = gr.Button("🚀 Start Quiz", variant="primary", size="lg")
+                    restart_btn = gr.Button("🔄 Reset All", variant="secondary")
+
+                # Question controls (hidden initially)
+                with gr.Group():
+                    gr.Markdown("### ✍️ Answer Controls")
+                    submit_btn = gr.Button("✅ Submit Answer", variant="primary", visible=False)
+                    next_btn = gr.Button("➡️ Next Question", visible=False)
+                    feedback_html = gr.HTML(visible=False)
+
+                # Report section
+                with gr.Group():
+                    gr.Markdown("### 📊 Generate Report")
+                    show_report_btn = gr.Button("📄 Generate Report")
+
+            # Right panel - Quiz area
             with gr.Column(scale=4):
+                # Progress and question area
                 with gr.Group(elem_classes="card"):
-                    question_txt = gr.Markdown("**Question will appear here after you start the quiz**")
-                    options = gr.Radio(choices=[], label="Choose one option", interactive=True)
-                    progress_html = gr.HTML("<div>No quiz loaded.</div>")
-                    score_display = gr.Textbox(label="Score", interactive=False, value="0 / 0")
-
-                gr.Markdown("### Upload Logo (optional - PNG/JPG)")
-                logo_upload = gr.File(label="Optional: Upload logo to appear on PDF", file_count="single", file_types=[".png", ".jpg", ".jpeg"])
-
-        # State store
-        state_store = gr.State({})
-
-        # Wiring: Load CSV
-        def on_load(csv_path_text, uploaded_file):
-            q_text, q_choices, show_submit, show_next, msg, store = prepare_quiz(csv_path_text, uploaded_file)
-            # initial progress & score
-            prog = "<div>No quiz loaded.</div>"
-            score = "0 / 0"
-            if store and "quiz" in store:
-                prog = get_progress_html(store)
-                score = f"{store.get('score',0)} / {len(store.get('quiz',[]))}"
-            return q_text, q_choices, show_submit, show_next, msg, store, prog, score
+                    progress_html = gr.HTML(
+                        value="<div style='text-align: center; color: #666;'>No quiz loaded</div>"
+                    )
+                    
+                    gr.Markdown("### Current Question")
+                    question_display = gr.Markdown(
+                        "**Your question will appear here after loading a quiz and clicking Start**"
+                    )
+                    
+                    options_radio = gr.Radio(
+                        choices=[], 
+                        label="Select your answer:",
+                        interactive=True
+                    )
+
+                # Logo upload
+                with gr.Group():
+                    gr.Markdown("### 🎨 Branding (Optional)")
+                    logo_upload = gr.File(
+                        label="Upload logo for PDF report (PNG/JPG)",
+                        file_count="single",
+                        file_types=[".png", ".jpg", ".jpeg"]
+                    )
+
+        # Report display area
+        gr.Markdown("---")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📋 Quiz Report")
+                report_preview = gr.Markdown("Complete a quiz to see your report here.")
+                report_download = gr.File(
+                    label="📥 Download PDF Report",
+                    visible=False
+                )
+
+        # State management
+        quiz_state = gr.State({})
+
+        # Event handlers
+        def handle_load_quiz(csv_path_text, uploaded_file):
+            q_text, q_choices, show_submit, show_next, status_msg, new_state = prepare_quiz(csv_path_text, uploaded_file)
+            
+            # Update progress display
+            progress = get_enhanced_progress_html(new_state)
+            
+            # Format status message for HTML display
+            status_html = f"<div class='status-box'>{status_msg.replace(chr(10), '<br>')}</div>"
+            
+            return (
+                q_text, q_choices, show_submit, show_next, 
+                status_html, new_state, progress
+            )
 
         load_btn.click(
-            fn=on_load,
+            fn=handle_load_quiz,
             inputs=[csv_file_text, csv_upload],
-            outputs=[question_txt, options, submit_btn, next_btn, load_msg, state_store, progress_html, score_display],
+            outputs=[
+                question_display, options_radio, submit_btn, next_btn, 
+                load_status, quiz_state, progress_html
+            ]
         )
 
-        # Start quiz
-        def on_start(state):
+        def handle_start_quiz(state):
             q_text, q_choices, show_submit, show_next, new_state = start_quiz(state)
-            prog = get_progress_html(new_state) if new_state else "<div>No quiz loaded.</div>"
-            score = f"{new_state.get('score',0)} / {len(new_state.get('quiz',[]))}" if new_state else "0 / 0"
-            # show submit button, hide next
-            return q_text, q_choices, gr.update(visible=True), gr.update(visible=False), new_state, prog, score
-
-        start_btn.click(fn=on_start, inputs=[state_store], outputs=[question_txt, options, submit_btn, next_btn, state_store, progress_html, score_display])
+            progress = get_enhanced_progress_html(new_state)
+            return q_text, q_choices, show_submit, show_next, new_state, progress
+
+        start_btn.click(
+            fn=handle_start_quiz,
+            inputs=[quiz_state],
+            outputs=[
+                question_display, options_radio, submit_btn, next_btn, 
+                quiz_state, progress_html
+            ]
+        )
 
-        # Submit answer
-        def on_submit(state, selected):
+        def handle_submit_answer(state, selected):
             feedback_text, show_feedback, show_next_btn, new_state = submit_answer(state, selected)
-            prog = get_progress_html(new_state) if new_state else "<div>No quiz loaded.</div>"
-            score = f"{new_state.get('score',0)} / {len(new_state.get('quiz',[]))}" if new_state else "0 / 0"
-            # show feedback area and enable Next button
-            return feedback_text, show_feedback, show_next_btn, new_state, prog, score
+            progress = get_enhanced_progress_html(new_state)
+            return feedback_text, show_feedback, show_next_btn, new_state, progress
 
         submit_btn.click(
-            fn=on_submit,
-            inputs=[state_store, options],
-            outputs=[feedback, feedback, next_btn, state_store, progress_html, score_display],
+            fn=handle_submit_answer,
+            inputs=[quiz_state, options_radio],
+            outputs=[feedback_html, feedback_html, next_btn, quiz_state, progress_html]
         )
 
-        # Next question
-        def on_next(state):
-            q_text, q_choices, show_submit, show_next, new_state = next_q(state)
-            prog = get_progress_html(new_state) if new_state else "<div>No quiz loaded.</div>"
-            score = f"{new_state.get('score',0)} / {len(new_state.get('quiz',[]))}" if new_state else "0 / 0"
-            md = ""
-            pdf_path = None
-            # If quiz just finished, prepare a quick report preview (without name/logo defaults)
+        def handle_next_question(state):
+            q_text, q_choices, show_submit, show_next, new_state = next_question(state)
+            progress = get_enhanced_progress_html(new_state)
+            
+            # Auto-generate report if quiz is complete
+            report_md = "Complete a quiz to see your report here."
+            pdf_file = gr.File.update(visible=False)
+            
             if new_state and new_state.get("index", 0) >= len(new_state.get("quiz", [])):
-                md, pdf_path = show_report(new_state, user_name.value if user_name.value else "Candidate", None)
-            # set visibility: if quiz finished, hide controls
-            return q_text, q_choices, show_submit, show_next, new_state, prog, score, md, (gr.File.update(value=pdf_path) if pdf_path else gr.File.update(visible=False))
+                try:
+                    report_md, pdf_path = show_report(new_state, user_name.value or "Anonymous", None)
+                    if pdf_path:
+                        pdf_file = gr.File.update(value=pdf_path, visible=True)
+                except Exception as e:
+                    logger.exception("Error generating auto-report")
+            
+            return (
+                q_text, q_choices, show_submit, show_next, new_state, 
+                progress, report_md, pdf_file
+            )
 
         next_btn.click(
-            fn=on_next,
-            inputs=[state_store],
-            outputs=[question_txt, options, submit_btn, next_btn, state_store, progress_html, score_display, report_preview, report_download],
+            fn=handle_next_question,
+            inputs=[quiz_state],
+            outputs=[
+                question_display, options_radio, submit_btn, next_btn, 
+                quiz_state, progress_html, report_preview, report_download
+            ]
         )
 
-        # Show/Refresh report button
-        def on_show_report(state, name, logo_file):
-            md, pdf_path = show_report(state, name, logo_file)
-            rfile = gr.File.update(value=pdf_path) if pdf_path else gr.File.update(visible=False)
-            return md, rfile
+        def handle_generate_report(state, name, logo_file):
+            report_md, pdf_path = show_report(state, name, logo_file)
+            pdf_file = gr.File.update(value=pdf_path, visible=True) if pdf_path else gr.File.update(visible=False)
+            return report_md, pdf_file
 
         show_report_btn.click(
-            fn=on_show_report,
-            inputs=[state_store, user_name, logo_upload],
-            outputs=[report_preview, report_download],
+            fn=handle_generate_report,
+            inputs=[quiz_state, user_name, logo_upload],
+            outputs=[report_preview, report_download]
         )
 
-        # Reset button
-        def on_reset():
-            # try to clean leftover PDF files (best-effort)
-            # NOTE: we don't remove uploaded files; they are managed by Gradio / platform
+        def handle_reset():
             return (
-                "**Reset** — no quiz loaded.",
+                "**Your question will appear here after loading a quiz and clicking Start**",
                 gr.update(choices=[]),
                 gr.update(visible=False),
                 gr.update(visible=False),
-                "No quiz loaded.",
+                gr.update(visible=False),
+                "<div class='status-box'>📄 Reset complete. Load a CSV file to begin.</div>",
                 {},
-                "<div>No quiz loaded.</div>",
-                "0 / 0",
-                "No report yet.",
-                gr.File.update(visible=False),
+                "<div style='text-align: center; color: #666;'>No quiz loaded</div>",
+                "Complete a quiz to see your report here.",
+                gr.File.update(visible=False)
             )
 
         restart_btn.click(
-            fn=on_reset,
+            fn=handle_reset,
             inputs=[],
-            outputs=[question_txt, options, submit_btn, next_btn, load_msg, state_store, progress_html, score_display, report_preview, report_download],
+            outputs=[
+                question_display, options_radio, submit_btn, next_btn, feedback_html,
+                load_status, quiz_state, progress_html, report_preview, report_download
+            ]
         )
 
-        # Live update progress when state changes
-        def on_state_change(state):
-            if not state or "quiz" not in state:
-                return "<div>No quiz loaded.</div>", "0 / 0"
-            return get_progress_html(state), f"{state.get('score',0)} / {len(state.get('quiz',[]))}"
+        # Auto-update progress when state changes
+        def update_progress_display(state):
+            return get_enhanced_progress_html(state)
 
-        state_store.change(fn=on_state_change, inputs=[state_store], outputs=[progress_html, score_display])
+        quiz_state.change(
+            fn=update_progress_display,
+            inputs=[quiz_state],
+            outputs=[progress_html]
+        )
 
-        gr.Markdown("---")
-        gr.Markdown("NIELIT Chandigarh — © " + str(datetime.now().year))
+        # Footer
+        gr.Markdown(f"""
+        ---
+        <div style='text-align: center; color: #6c757d; font-size: 12px; margin-top: 20px;'>
+            <strong>NIELIT Chandigarh</strong> — National Institute of Electronics & Information Technology<br>
+            © {datetime.now().year} • Enhanced Quiz Application • Version 2.0
+        </div>
+        """)
 
     return demo
 
 
 # -----------------------
-# CLI & server start
+# CLI & Application Entry Point
 # -----------------------
 def main():
-    parser = argparse.ArgumentParser(description="CCC Plus Quiz App — Gradio")
-    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to (default 127.0.0.1)")
-    parser.add_argument("--port", type=int, default=7860, help="Port to serve on (default 7860)")
-    parser.add_argument("--share", action="store_true", help="Expose a public share link via Gradio")
+    """Main entry point with enhanced CLI options."""
+    parser = argparse.ArgumentParser(
+        description="CCC Plus Quiz App — Enhanced Gradio Application",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --host 0.0.0.0 --port 8080          # Run on all interfaces, port 8080
+  %(prog)s --share                              # Create public share link
+  %(prog)s --debug                              # Enable debug logging
+        """
+    )
+    
+    parser.add_argument(
+        "--host", 
+        default="127.0.0.1", 
+        help="Host to bind to (default: 127.0.0.1, use 0.0.0.0 for all interfaces)"
+    )
+    parser.add_argument(
+        "--port", 
+        type=int, 
+        default=7860, 
+        help="Port to serve on (default: 7860)"
+    )
+    parser.add_argument(
+        "--share", 
+        action="store_true", 
+        help="Create a public share link via Gradio"
+    )
+    parser.add_argument(
+        "--debug", 
+        action="store_true", 
+        help="Enable debug logging"
+    )
+    
     args = parser.parse_args()
-
+    
+    # Configure logging level
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logger.debug("Debug logging enabled")
+    
+    # Build and launch application
     demo = build_app()
-    # Production-minded defaults: set server name if binding to all interfaces
-    server_kwargs = {"server_name": args.host, "server_port": args.port}
-    logger.info("Launching app on %s:%s (share=%s)", args.host, args.port, args.share)
-    demo.launch(**server_kwargs, share=args.share)
+    
+    logger.info(f"Starting CCC Plus Quiz App on {args.host}:{args.port}")
+    if args.share:
+        logger.info("Public share link will be created")
+    
+    try:
+        demo.launch(
+            server_name=args.host,
+            server_port=args.port,
+            share=args.share,
+            show_error=True,
+            quiet=False
+        )
+    except KeyboardInterrupt:
+        logger.info("Application stopped by user")
+    except Exception as e:
+        logger.exception(f"Failed to start application: {e}")
+        return 1
+    
+    return 0
 
 
 if __name__ == "__main__":
+    # For development/testing - always create public share
     demo = build_app()
-    demo.launch(share=True)  # always creates a public link
+    demo.launch(share=True, show_error=True)
+    
+    # For production use:
+    # exit(main())