Update app.py

app.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """
-CCC Plus Quiz App — Enhanced Production-ready Gradio app
+CCC Plus Quiz App - Completely Rewritten for Better UX
+A modern, intuitive quiz application with improved interface and functionality
 """
 
 import argparse
@@ -10,7 +11,7 @@ import tempfile
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Tuple, List, Dict
+from typing import Optional, Tuple, List, Dict, Any
 
 import gradio as gr
 import pandas as pd
@@ -18,948 +19,677 @@ from reportlab.lib import colors
 from reportlab.lib.pagesizes import A4
 from reportlab.lib.units import mm
 from reportlab.pdfgen import canvas
-from reportlab.platypus import Image, Table, TableStyle
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_LEFT
 
-# -----------------------
-# Configuration & Logging
-# -----------------------
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
+    format="%(asctime)s [%(levelname)s] %(message)s"
 )
 logger = logging.getLogger(__name__)
 
-# Configuration constants
+# Configuration
 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
 
-# -----------------------
-# Enhanced Utility helpers
-# -----------------------
-def extract_file_path(uploaded) -> Optional[str]:
-    """
-    Robustly extract a usable file-system path from Gradio's uploaded-file object.
-    """
-    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"):
-            p = uploaded.get(key)
-            if isinstance(p, str) and os.path.exists(p):
-                return p
-        # sometimes 'name' is only filename but 'tempfile' is full path
-        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)
-        if os.path.exists(s):
-            return s
-    except Exception:
-        pass
-    
-    return None
-
-
-def safe_read_csv(path: str) -> pd.DataFrame:
-    """
-    Read CSV with enhanced error handling and encoding detection.
-    """
-    if path is None:
-        raise FileNotFoundError("No CSV path provided.")
-    
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"File not found: {path}")
-    
-    # Try multiple encodings
-    encodings = ['utf-8', 'latin1', 'cp1252', 'iso-8859-1']
-    
-    for encoding in encodings:
+class QuizApp:
+    """Main Quiz Application Class"""
+    
+    def __init__(self):
+        self.reset_state()
+    
+    def reset_state(self):
+        """Reset all quiz state variables"""
+        self.quiz_data = []
+        self.current_index = 0
+        self.score = 0
+        self.user_answers = []
+        self.quiz_started = False
+        self.quiz_completed = False
+        self.start_time = None
+        self.end_time = None
+        self.user_name = ""
+    
+    def load_csv(self, file_path: str) -> Tuple[bool, str]:
+        """Load and validate CSV file"""
         try:
-            df = pd.read_csv(path, encoding=encoding)
-            logger.info(f"Successfully read CSV with {encoding} encoding")
-            return df
-        except UnicodeDecodeError:
-            continue
+            if not file_path or not os.path.exists(file_path):
+                return False, "❌ File not found. Please check the file path."
+            
+            # Try different encodings
+            df = None
+            for encoding in ['utf-8', 'latin1', 'cp1252', 'iso-8859-1']:
+                try:
+                    df = pd.read_csv(file_path, encoding=encoding)
+                    break
+                except UnicodeDecodeError:
+                    continue
+            
+            if df is None:
+                return False, "❌ Could not read the CSV file. Please check the file encoding."
+            
+            # Normalize column names
+            df.columns = df.columns.str.strip().str.lower()
+            
+            # Check required columns
+            missing_cols = REQUIRED_COLUMNS - set(df.columns)
+            if missing_cols:
+                return False, f"❌ Missing required columns: {', '.join(missing_cols)}"
+            
+            # Process questions
+            self.quiz_data = []
+            for idx, row in df.iterrows():
+                try:
+                    question = str(row['question']).strip()
+                    if not question or question.lower() in ['nan', 'none', '']:
+                        continue
+                    
+                    options = [
+                        str(row['option1']).strip(),
+                        str(row['option2']).strip(),
+                        str(row['option3']).strip(),
+                        str(row['option4']).strip()
+                    ]
+                    
+                    answer = str(row['answer']).strip()
+                    
+                    # Validate answer exists in options
+                    if answer not in options:
+                        logger.warning(f"Question {idx+1}: Answer '{answer}' not found in options")
+                        continue
+                    
+                    self.quiz_data.append({
+                        'question': question,
+                        'options': options,
+                        'answer': answer
+                    })
+                    
+                except Exception as e:
+                    logger.warning(f"Error processing row {idx+1}: {e}")
+                    continue
+            
+            if not self.quiz_data:
+                return False, "❌ No valid questions found in the CSV file."
+            
+            return True, f"✅ Successfully loaded {len(self.quiz_data)} questions!"
+            
         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 = []
+            logger.exception("Error loading CSV")
+            return False, f"❌ Error loading CSV: {str(e)}"
     
-    if not quiz:
-        warnings.append("No questions found in the quiz data")
-        return warnings
+    def start_quiz(self, name: str) -> Tuple[bool, str]:
+        """Start the quiz"""
+        if not self.quiz_data:
+            return False, "❌ No quiz loaded. Please load a CSV file first."
+        
+        self.user_name = name.strip() if name else "Anonymous"
+        self.current_index = 0
+        self.score = 0
+        self.user_answers = []
+        self.quiz_started = True
+        self.quiz_completed = False
+        self.start_time = datetime.now()
+        
+        return True, "🚀 Quiz started! Answer each question and click Next to proceed."
     
-    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")
+    def get_current_question(self) -> Dict[str, Any]:
+        """Get current question data"""
+        if not self.quiz_started or not self.quiz_data or self.current_index >= len(self.quiz_data):
+            return {}
         
-        # 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")
+        question_data = self.quiz_data[self.current_index]
+        return {
+            'question_num': self.current_index + 1,
+            'total_questions': len(self.quiz_data),
+            'question': question_data['question'],
+            'options': question_data['options'],
+            'progress': ((self.current_index) / len(self.quiz_data)) * 100
+        }
+    
+    def submit_answer(self, selected_answer: str) -> Tuple[bool, str, bool]:
+        """Submit answer and move to next question"""
+        if not self.quiz_started or not self.quiz_data:
+            return False, "❌ Quiz not started.", False
         
-        # 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")
+        if self.current_index >= len(self.quiz_data):
+            return False, "❌ Quiz already completed.", True
         
-        # 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
-
+        current_q = self.quiz_data[self.current_index]
+        is_correct = selected_answer == current_q['answer']
+        
+        # Store the answer
+        self.user_answers.append({
+            'question': current_q['question'],
+            'selected': selected_answer,
+            'correct_answer': current_q['answer'],
+            'is_correct': is_correct
+        })
+        
+        if is_correct:
+            self.score += 1
+        
+        # Move to next question
+        self.current_index += 1
+        
+        # Check if quiz is completed
+        if self.current_index >= len(self.quiz_data):
+            self.quiz_completed = True
+            self.end_time = datetime.now()
+            duration = self.end_time - self.start_time
+            duration_str = f"{duration.seconds // 60}m {duration.seconds % 60}s"
+            
+            percentage = (self.score / len(self.quiz_data)) * 100
+            
+            return True, f"""🎉 **Quiz Completed!**
+            
+**Final Score:** {self.score} out of {len(self.quiz_data)} ({percentage:.1f}%)
+**Time Taken:** {duration_str}
+**Performance:** {self.get_performance_level(percentage)}
 
-# -----------------------
-# Enhanced Quiz CSV loader
-# -----------------------
-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)
-    
-    # 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}")
+Click "Generate Report" to download your detailed results!""", True
+        
+        # Quiz continues
+        feedback = f"✅ Correct!" if is_correct else f"❌ Incorrect. The correct answer was: **{current_q['answer']}**"
+        return True, feedback, False
+    
+    def get_performance_level(self, percentage: float) -> str:
+        """Get performance level based on percentage"""
+        if percentage >= 90:
+            return "🏆 Excellent"
+        elif percentage >= 80:
+            return "👍 Good"
+        elif percentage >= 60:
+            return "👌 Average"
+        else:
+            return "📚 Needs Improvement"
     
-    # Process quiz data
-    quiz = []
-    for idx, row in df.iterrows():
+    def generate_pdf_report(self, logo_path: Optional[str] = None) -> Optional[str]:
+        """Generate PDF report"""
+        if not self.user_answers:
+            return None
+        
         try:
-            question = str(row["question"]).strip()
-            options = [
-                str(row["option1"]).strip(),
-                str(row["option2"]).strip(),
-                str(row["option3"]).strip(),
-                str(row["option4"]).strip(),
+            # Create temporary file
+            temp_file = tempfile.NamedTemporaryFile(
+                prefix="CCC_Quiz_Report_",
+                suffix=".pdf",
+                delete=False
+            )
+            temp_file.close()
+            
+            # Create PDF
+            doc = SimpleDocTemplate(temp_file.name, pagesize=A4)
+            styles = getSampleStyleSheet()
+            story = []
+            
+            # Custom styles
+            title_style = ParagraphStyle(
+                'CustomTitle',
+                parent=styles['Heading1'],
+                fontSize=18,
+                alignment=TA_CENTER,
+                textColor=colors.HexColor('#003366'),
+                spaceAfter=12
+            )
+            
+            subtitle_style = ParagraphStyle(
+                'CustomSubtitle',
+                parent=styles['Normal'],
+                fontSize=12,
+                alignment=TA_CENTER,
+                textColor=colors.HexColor('#666666'),
+                spaceAfter=20
+            )
+            
+            # Header
+            story.append(Paragraph("CCC Plus - Computer Concepts Plus", title_style))
+            story.append(Paragraph("Quiz Assessment Report", subtitle_style))
+            story.append(Spacer(1, 12))
+            
+            # Candidate info
+            info_data = [
+                ['Candidate:', self.user_name],
+                ['Date:', datetime.now().strftime('%d %B %Y at %H:%M:%S')],
+                ['Questions Attempted:', str(len(self.user_answers))],
+                ['Correct Answers:', str(self.score)],
+                ['Score Percentage:', f"{(self.score/len(self.user_answers)*100):.1f}%"],
+                ['Performance Level:', self.get_performance_level((self.score/len(self.user_answers)*100))]
             ]
-            answer = str(row["answer"]).strip()
             
-            # Skip empty questions
-            if not question or question.lower() in ['nan', 'none', '']:
-                continue
+            info_table = Table(info_data, colWidths=[120, 200])
+            info_table.setStyle(TableStyle([
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 10),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+            ]))
+            
+            story.append(info_table)
+            story.append(Spacer(1, 20))
+            
+            # Results table
+            story.append(Paragraph("Detailed Results", styles['Heading2']))
+            story.append(Spacer(1, 12))
+            
+            table_data = [['#', 'Question', 'Your Answer', 'Correct Answer', 'Result']]
+            
+            for i, answer in enumerate(self.user_answers, 1):
+                result_icon = '✓' if answer['is_correct'] else '✗'
+                question_text = answer['question'][:100] + ('...' if len(answer['question']) > 100 else '')
                 
-            quiz.append({
-                "question": question,
-                "options": options,
-                "answer": answer
-            })
+                table_data.append([
+                    str(i),
+                    question_text,
+                    answer['selected'],
+                    answer['correct_answer'],
+                    result_icon
+                ])
+            
+            results_table = Table(table_data, colWidths=[20, 200, 80, 80, 30])
+            results_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#003366')),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, -1), 8),
+                ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.HexColor('#f8f9fa')]),
+                ('GRID', (0, 0), (-1, -1), 1, colors.HexColor('#dee2e6')),
+                ('VALIGN', (0, 0), (-1, -1), 'TOP'),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 4),
+                ('TOPPADDING', (0, 0), (-1, -1), 4),
+            ]))
+            
+            story.append(results_table)
+            story.append(Spacer(1, 20))
+            
+            # Footer
+            footer_style = ParagraphStyle(
+                'Footer',
+                parent=styles['Normal'],
+                fontSize=8,
+                alignment=TA_CENTER,
+                textColor=colors.HexColor('#666666')
+            )
+            
+            story.append(Paragraph(
+                f"NIELIT Chandigarh — © {datetime.now().year} — Generated automatically",
+                footer_style
+            ))
+            
+            doc.build(story)
+            
+            logger.info(f"Generated PDF report: {temp_file.name}")
+            return temp_file.name
             
         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
-
-
-# -----------------------
-# Enhanced PDF generation
-# -----------------------
-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 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.close()
-    filename = tmp.name
-
-    c = canvas.Canvas(filename, pagesize=A4)
-    width, height = A4
-    y = height - PDF_MARGIN
-
-    # 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, 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 = PDF_MARGIN
+            logger.exception("Error generating PDF report")
+            return None
 
-    # 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
+# Global quiz app instance
+quiz_app = QuizApp()
 
-    # Score and Statistics
-    c.setFont("Helvetica-Bold", 14)
-    total_questions = len(history)
-    percentage = (score / total_questions * 100) if total_questions > 0 else 0
+def handle_load_quiz(csv_path: str, uploaded_file) -> Tuple[str, Any, Any, Any]:
+    """Handle quiz loading"""
+    # Extract file path
+    file_path = None
+    if uploaded_file is not None:
+        file_path = uploaded_file.name if hasattr(uploaded_file, 'name') else str(uploaded_file)
+    elif csv_path and csv_path.strip():
+        file_path = csv_path.strip()
     
-    c.drawString(PDF_MARGIN, y, f"Final Score: {score} / {total_questions} ({percentage:.1f}%)")
-    y -= 22
-
-    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"
-        
-        # 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)
-    
-    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")))
+    if not file_path:
+        return "❌ Please provide a CSV file path or upload a file.", gr.update(), gr.update(), gr.update(visible=False)
     
-    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 - PDF_MARGIN
+    # Reset quiz state
+    quiz_app.reset_state()
     
-    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} — Generated automatically"
-    c.drawCentredString(width / 2, 12 * mm, footer_text)
-
-    c.save()
-    logger.info(f"Generated enhanced PDF report: {filename}")
-    return filename
-
-
-# -----------------------
-# Enhanced Quiz Logic
-# -----------------------
-def prepare_quiz(csv_file_text: str, csv_upload):
-    """
-    Load questions from CSV with enhanced validation and feedback.
-    """
-    uploaded_path = extract_file_path(csv_upload)
-    path = uploaded_path or (csv_file_text if csv_file_text and os.path.exists(csv_file_text) else None)
+    # Load quiz
+    success, message = quiz_app.load_csv(file_path)
     
-    if not path:
-        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, warnings = load_quiz_from_path(path)
-    except Exception as e:
-        logger.exception("Failed to load quiz CSV")
-        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:
-        msg = "❌ No valid questions found in CSV file."
-        return "", gr.update(choices=[]), gr.update(visible=False), gr.update(visible=False), msg, {}
+    if success:
+        return message, gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
+    else:
+        return message, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
 
-    # 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."]
+def handle_start_quiz(name: str) -> Tuple[str, Any, Any, Any, Any, str, Any]:
+    """Handle quiz start"""
+    success, message = quiz_app.start_quiz(name)
     
-    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")
+    if not success:
+        return message, gr.update(), gr.update(), gr.update(), gr.update(), "", gr.update()
     
-    msg_parts.append("\n🚀 Click 'Start Quiz' to begin!")
-    status_msg = "\n".join(msg_parts)
+    # Get first question
+    q_data = quiz_app.get_current_question()
+    if not q_data:
+        return "❌ No questions available.", gr.update(), gr.update(), gr.update(), gr.update(), "", gr.update()
     
-    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>
+    question_html = f"""
+    <div style="background: linear-gradient(135deg, #f8f9fa, #e9ecef); padding: 20px; border-radius: 12px; margin-bottom: 20px;">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+            <span style="font-weight: 600; color: #495057;">Question {q_data['question_num']} of {q_data['total_questions']}</span>
+            <span style="font-weight: 600; color: #007bff;">Score: {quiz_app.score}/{q_data['question_num']-1 if q_data['question_num'] > 1 else 0}</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 style="background: #e9ecef; border-radius: 10px; overflow: hidden; height: 8px; margin-bottom: 15px;">
+            <div style="background: linear-gradient(90deg, #007bff, #0056b3); height: 100%; width: {q_data['progress']:.1f}%;"></div>
         </div>
+        <h3 style="color: #212529; margin: 0;">{q_data['question']}</h3>
     </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. 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
+        message,
+        gr.update(visible=True),
+        gr.update(visible=True),
+        gr.update(value=question_html, visible=True),
+        gr.update(choices=q_data['options'], value=None, visible=True),
+        "",
+        gr.update(visible=True)
     )
 
-
-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
+def handle_next_question(selected_answer: str) -> Tuple[str, Any, Any, str, Any]:
+    """Handle answer submission and move to next question"""
+    if not selected_answer:
+        return "⚠️ Please select an answer before proceeding.", gr.update(), gr.update(), "", gr.update()
     
-    if not state.get("started"):
-        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
-    }
+    success, feedback, is_completed = quiz_app.submit_answer(selected_answer)
     
-    # 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>"
+    if not success:
+        return feedback, gr.update(), gr.update(), feedback, gr.update()
     
-    return feedback, gr.update(visible=True), gr.update(visible=True), 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
-    
-    # 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 question
-    state["index"] += 1
-    
-    # Check if quiz is complete
-    if state["index"] >= len(state["quiz"]):
-        state["started"] = False
-        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
+    if is_completed:
+        # Quiz completed
+        return (
+            feedback,
+            gr.update(visible=False),
+            gr.update(visible=False),
+            feedback,
+            gr.update(visible=True)
+        )
+    
+    # Get next question
+    q_data = quiz_app.get_current_question()
+    if not q_data:
+        return "❌ Error getting next question.", gr.update(), gr.update(), feedback, gr.update()
+    
+    question_html = f"""
+    <div style="background: linear-gradient(135deg, #f8f9fa, #e9ecef); padding: 20px; border-radius: 12px; margin-bottom: 20px;">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+            <span style="font-weight: 600; color: #495057;">Question {q_data['question_num']} of {q_data['total_questions']}</span>
+            <span style="font-weight: 600; color: #007bff;">Score: {quiz_app.score}/{q_data['question_num']-1}</span>
+        </div>
+        <div style="background: #e9ecef; border-radius: 10px; overflow: hidden; height: 8px; margin-bottom: 15px;">
+            <div style="background: linear-gradient(90deg, #007bff, #0056b3); height: 100%; width: {q_data['progress']:.1f}%;"></div>
+        </div>
+        <h3 style="color: #212529; margin: 0;">{q_data['question']}</h3>
+    </div>
+    """
     
-    # Show next question
-    next_q = state["quiz"][state["index"]]
     return (
-        next_q["question"], 
-        gr.update(choices=next_q["options"], value=None), 
-        gr.update(visible=True), 
-        gr.update(visible=False), 
-        state
+        feedback,
+        gr.update(value=question_html, visible=True),
+        gr.update(choices=q_data['options'], value=None, visible=True),
+        feedback,
+        gr.update()
     )
 
-
-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 quiz results available. Complete a quiz first.", None
-    
-    history = list(state["history"])
-    
-    # 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
+def handle_generate_report(logo_file) -> Tuple[str, Any]:
+    """Handle report generation"""
+    if not quiz_app.user_answers:
+        return "❌ No quiz results available. Please complete a quiz first.", gr.update(visible=False)
     
     # 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}",
+    total_questions = len(quiz_app.user_answers)
+    correct_answers = quiz_app.score
+    percentage = (correct_answers / total_questions) * 100
+    
+    report_lines = [
+        f"# 📋 CCC Plus Quiz Report",
+        f"",
+        f"**Candidate:** {quiz_app.user_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 |",
-        "|---:|---|---|---|:---:|"
+        f"**Questions:** {total_questions}",
+        f"**Correct Answers:** {correct_answers}",
+        f"**Score:** {percentage:.1f}%",
+        f"**Performance:** {quiz_app.get_performance_level(percentage)}",
+        f"",
+        f"## 📊 Detailed Results",
+        f"",
+        f"| # | Question | Your Answer | Correct Answer | Result |",
+        f"|---|----------|-------------|----------------|--------|"
     ]
     
-    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} |"
+    for i, answer in enumerate(quiz_app.user_answers, 1):
+        status = "✅" if answer['is_correct'] else "❌"
+        question_short = answer['question'][:60] + "..." if len(answer['question']) > 60 else answer['question']
+        report_lines.append(
+            f"| {i} | {question_short} | {answer['selected']} | {answer['correct_answer']} | {status} |"
         )
     
-    report_md = "\n".join(md_lines)
+    report_md = "\n".join(report_lines)
     
     # Generate PDF
-    logo_path = extract_file_path(logo_file) or (
-        "nielit_logo.png" if os.path.exists("nielit_logo.png") else None
-    )
+    pdf_path = quiz_app.generate_pdf_report()
     
-    try:
-        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 report")
-        error_report = report_md + f"\n\n**⚠️ PDF Generation Failed:** {str(e)}"
-        return error_report, None
+    if pdf_path:
+        return report_md, gr.update(value=pdf_path, visible=True)
+    else:
+        return report_md + "\n\n⚠️ **PDF generation failed.**", gr.update(visible=False)
 
+def handle_reset() -> Tuple[str, Any, Any, Any, Any, str, Any, str, Any]:
+    """Handle complete reset"""
+    quiz_app.reset_state()
+    
+    return (
+        "🔄 Application reset successfully. Load a new quiz to begin.",
+        gr.update(visible=False),
+        gr.update(visible=False),
+        gr.update(visible=False, value=""),
+        gr.update(visible=False, choices=[], value=None),
+        "",
+        gr.update(visible=False),
+        "Complete a quiz to see your report here.",
+        gr.update(visible=False)
+    )
 
-# -----------------------
-# Enhanced Gradio Interface
-# -----------------------
-def build_app():
-    """Build the enhanced Gradio interface."""
-    css = """
-    .header {
-        display: flex; 
-        align-items: center; 
-        gap: 12px;
+def create_app():
+    """Create the Gradio interface"""
+    
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        max-width: 1200px !important;
+        margin: 0 auto;
     }
-    .logo-small {
-        height: 56px;
+    
+    .quiz-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 30px;
+        border-radius: 15px;
+        color: white;
+        margin-bottom: 30px;
+        text-align: center;
     }
-    .card {
-        border-radius: 12px; 
-        padding: 20px; 
-        box-shadow: 0 6px 18px rgba(0,0,0,0.08);
-        background: white;
+    
+    .control-panel {
+        background: #f8f9fa;
+        border-radius: 15px;
+        padding: 25px;
         border: 1px solid #e9ecef;
     }
-    .muted {
-        color: #6c757d; 
-        font-size: 14px;
-    }
-    .small {
-        font-size: 13px; 
-        color: #495057;
+    
+    .quiz-area {
+        background: white;
+        border-radius: 15px;
+        padding: 25px;
+        border: 1px solid #e9ecef;
+        min-height: 400px;
     }
-    .status-box {
+    
+    .report-section {
         background: #f8f9fa;
-        border: 1px solid #dee2e6;
-        border-radius: 8px;
-        padding: 12px;
-        font-family: monospace;
-        font-size: 13px;
+        border-radius: 15px;
+        padding: 25px;
+        border: 1px solid #e9ecef;
+        margin-top: 20px;
     }
     """
-
+    
     with gr.Blocks(
-        title="CCC Plus Quiz App — NIELIT Chandigarh", 
-        css=css,
+        title="CCC Plus Quiz App",
+        css=custom_css,
         theme=gr.themes.Soft()
-    ) as demo:
+    ) as app:
+        
+        # Header
+        gr.HTML("""
+            <div class="quiz-header">
+                <h1 style="margin: 0; font-size: 2.5em;">🖥️ CCC Plus Quiz App</h1>
+                <p style="margin: 10px 0 0 0; font-size: 1.2em; opacity: 0.9;">
+                    Computer Concepts Plus - Interactive Quiz Platform
+                </p>
+                <p style="margin: 5px 0 0 0; opacity: 0.8;">
+                    NIELIT Chandigarh • National Institute of Electronics & Information Technology
+                </p>
+            </div>
+        """)
         
-        # Header section
         with gr.Row():
-            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
+            # Left Panel - Controls
+            with gr.Column(scale=1, elem_classes="control-panel"):
+                gr.Markdown("### 📁 Load Quiz")
+                
+                csv_path = gr.Textbox(
+                    label="CSV File Path",
+                    placeholder="Enter path to your quiz CSV file...",
+                    value=DEFAULT_CSV_PATH
                 )
-            
-            with gr.Column(scale=6):
-                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 panel - Controls
-            with gr.Column(scale=3):
-                # 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"):
-                    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",
+                
+                csv_upload = gr.File(
+                    label="Or Upload CSV File",
+                    file_types=[".csv"],
+                    file_count="single"
+                )
+                
+                load_btn = gr.Button("📂 Load Quiz", variant="primary", size="lg")
+                load_status = gr.Markdown("📝 No quiz loaded. Please load a CSV file to begin.")
+                
+                gr.Markdown("---")
+                gr.Markdown("### 👤 Candidate Info")
+                
+                user_name = gr.Textbox(
+                    label="Your Full Name",
+                    placeholder="Enter your name for the certificate...",
                     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>"
+                
+                start_btn = gr.Button("🚀 Start Quiz", variant="primary", size="lg", visible=False)
+                
+                gr.Markdown("---")
+                gr.Markdown("### 📊 Actions")
+                
+                report_btn = gr.Button("📋 Generate Report", visible=False)
+                reset_btn = gr.Button("🔄 Reset All", variant="secondary")
+                
+                # Logo upload
+                gr.Markdown("---")
+                gr.Markdown("### 🎨 Branding (Optional)")
+                logo_upload = gr.File(
+                    label="Upload Logo for PDF",
+                    file_types=[".png", ".jpg", ".jpeg"]
+                )
             
-            return (
-                q_text, q_choices, show_submit, show_next, 
-                status_html, new_state, progress
-            )
-
+            # Right Panel - Quiz Area
+            with gr.Column(scale=2, elem_classes="quiz-area"):
+                
+                feedback_msg = gr.Markdown("Welcome! Load a quiz file and enter your name to begin.", visible=True)
+                
+                question_display = gr.HTML(visible=False)
+                
+                answer_options = gr.Radio(
+                    label="Select your answer:",
+                    choices=[],
+                    visible=False
+                )
+                
+                next_btn = gr.Button("➡️ Submit Answer & Next", variant="primary", size="lg", visible=False)
+        
+        # Report Section
+        with gr.Row():
+            with gr.Column(elem_classes="report-section"):
+                gr.Markdown("### 📋 Quiz Report")
+                report_display = gr.Markdown("Complete a quiz to see your report here.")
+                report_download = gr.File(label="📥 Download PDF Report", visible=False)
+        
+        # Event Handlers
         load_btn.click(
             fn=handle_load_quiz,
-            inputs=[csv_file_text, csv_upload],
-            outputs=[
-                question_display, options_radio, submit_btn, next_btn, 
-                load_status, quiz_state, progress_html
-            ]
+            inputs=[csv_path, csv_upload],
+            outputs=[load_status, user_name, start_btn, report_btn]
         )
-
-        def handle_start_quiz(state):
-            q_text, q_choices, show_submit, show_next, new_state = start_quiz(state)
-            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
-            ]
-        )
-
-        def handle_submit_answer(state, selected):
-            feedback_text, show_feedback, show_next_btn, new_state = submit_answer(state, selected)
-            progress = get_enhanced_progress_html(new_state)
-            return feedback_text, show_feedback, show_next_btn, new_state, progress
-
-        submit_btn.click(
-            fn=handle_submit_answer,
-            inputs=[quiz_state, options_radio],
-            outputs=[feedback_html, feedback_html, next_btn, quiz_state, progress_html]
+            inputs=[user_name],
+            outputs=[feedback_msg, start_btn, next_btn, question_display, answer_options, user_name, report_btn]
         )
-
-        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", [])):
-                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=handle_next_question,
-            inputs=[quiz_state],
-            outputs=[
-                question_display, options_radio, submit_btn, next_btn, 
-                quiz_state, progress_html, report_preview, report_download
-            ]
+            inputs=[answer_options],
+            outputs=[feedback_msg, question_display, answer_options, feedback_msg, report_btn]
         )
-
-        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(
+        
+        report_btn.click(
             fn=handle_generate_report,
-            inputs=[quiz_state, user_name, logo_upload],
-            outputs=[report_preview, report_download]
+            inputs=[logo_upload],
+            outputs=[report_display, report_download]
         )
-
-        def handle_reset():
-            return (
-                "**Your question will appear here after loading a quiz and clicking Start**",
-                gr.update(choices=[]),
-                gr.update(visible=False),
-                gr.update(visible=False),
-                gr.update(visible=False),
-                "<div class='status-box'>📄 Reset complete. Load a CSV file to begin.</div>",
-                {},
-                "<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(
+        
+        reset_btn.click(
             fn=handle_reset,
             inputs=[],
             outputs=[
-                question_display, options_radio, submit_btn, next_btn, feedback_html,
-                load_status, quiz_state, progress_html, report_preview, report_download
+                load_status, user_name, start_btn, question_display, 
+                answer_options, feedback_msg, report_btn, report_display, report_download
             ]
         )
-
-        # Auto-update progress when state changes
-        def update_progress_display(state):
-            return get_enhanced_progress_html(state)
-
-        quiz_state.change(
-            fn=update_progress_display,
-            inputs=[quiz_state],
-            outputs=[progress_html]
-        )
-
+        
         # 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>
+        gr.HTML(f"""
+            <div style="text-align: center; margin-top: 40px; padding: 20px; 
+                        background: #f8f9fa; border-radius: 10px; color: #6c757d;">
+                <p><strong>NIELIT Chandigarh</strong> • © {datetime.now().year} • Enhanced Quiz Application</p>
+                <p style="font-size: 0.9em;">Built with ❤️ using Gradio • Version 2.0</p>
+            </div>
         """)
+    
+    return app
 
-    return demo
-
-
-# -----------------------
-# CLI & Application Entry Point
-# -----------------------
 def main():
-    """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"
-    )
+    """Main entry point"""
+    parser = argparse.ArgumentParser(description="CCC Plus Quiz App")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=7860, help="Port to serve on")
+    parser.add_argument("--share", action="store_true", help="Create public share link")
+    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()
+    app = create_app()
     
     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(
+        app.launch(
             server_name=args.host,
             server_port=args.port,
             share=args.share,
-            show_error=True,
-            quiet=False
+            show_error=True
         )
     except KeyboardInterrupt:
         logger.info("Application stopped by user")
@@ -969,11 +699,10 @@ Examples:
     
     return 0
 
-
 if __name__ == "__main__":
-    # For development/testing - always create public share
-    demo = build_app()
-    demo.launch(share=True, show_error=True)
+    # For development - create public share
+    app = create_app()
+    app.launch(share=True, show_error=True)
     
     # For production use:
     # exit(main())