Update app.py

app.py

@@ -1,10 +1,16 @@
+# app.py - AI Study Tutor for SEA Exam Preparation
+# Enhanced with PDF upload and RAG capabilities
+
 import os
 import json
 import re
+import tempfile
 from typing import List, Dict, Any, Tuple
+from pathlib import Path
 
 import gradio as gr
 from groq import Groq
+import PyPDF2  # For PDF text extraction
 
 # -----------------------------
 # Configuration
@@ -12,122 +18,459 @@ from groq import Groq
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "").strip()
 client = Groq(api_key=GROQ_API_KEY)
 
-LANG_OPTIONS = [
-    "English",
-    "Urdu",
-    "Mandarin Chinease",
-    "Hindi",
-    "Spanish",
-    "Standard Arabic",
-    "French",
-    "Bengali",
-    "Protaguese",
-    "Russian",
-    "Indonasion",
+# SEA-specific configurations
+SEA_SUBJECTS = [
+    "Mathematics",
+    "English Language Arts"
+]
+
+SEA_MATH_TOPICS = [
+    "Number Theory (Fractions, Decimals, Percentages)",
+    "Measurement (Perimeter, Area, Volume)",
+    "Geometry",
+    "Algebra Basics",
+    "Word Problems",
+    "Data Interpretation"
+]
+
+SEA_ENGLISH_TOPICS = [
+    "Reading Comprehension",
+    "Grammar (Parts of Speech, Tenses)",
+    "Vocabulary (Synonyms, Antonyms)",
+    "Composition & Writing",
+    "Spelling & Punctuation",
+    "Listening Comprehension (simulated)"
 ]
 
+LANG_OPTIONS = ["English"]  # Primary language for SEA exam
 LEVEL_OPTIONS = ["Beginner", "Intermediate", "Advanced"]
 
+# Storage for uploaded documents
+UPLOADED_DOCS_FILE = "sea_exam_documents.json"
+
+# -----------------------------
+# Document Processing Functions
+# -----------------------------
+def extract_text_from_pdf(file_bytes: bytes, filename: str) -> str:
+    """Extract text from uploaded PDF files with SEA-specific formatting."""
+    try:
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp_file:
+            tmp_file.write(file_bytes)
+            tmp_file_path = tmp_file.name
+        
+        # Extract text using PyPDF2
+        full_text = ""
+        with open(tmp_file_path, 'rb') as pdf_file:
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                page_text = page.extract_text()
+                
+                # Add page marker for reference
+                full_text += f"\n--- SEA Paper Page {page_num+1} ---\n"
+                full_text += page_text + "\n"
+        
+        # Clean up temp file
+        os.unlink(tmp_file_path)
+        
+        # Post-process: Detect question patterns
+        processed_text = enhance_sea_text_extraction(full_text, filename)
+        
+        return processed_text
+        
+    except Exception as e:
+        return f"ERROR processing {filename}: {str(e)}"
+
+def enhance_sea_text_extraction(text: str, filename: str) -> str:
+    """Enhance extracted text with SEA-specific pattern recognition."""
+    enhancements = []
+    
+    # Detect common SEA question patterns
+    question_patterns = [
+        r"Question\s+\d+[:\.]\s*(.*?)(?=\nQuestion\s+\d+|$)",
+        r"\d+\.\s+(.*?)(?=\n\d+\.|\Z)",
+        r"Section\s+[A-Z][:\.]\s*(.*?)(?=\nSection\s+[A-Z]|\Z)"
+    ]
+    
+    for pattern in question_patterns:
+        matches = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
+        if matches:
+            enhancements.append(f"Detected {len(matches)} SEA-style questions")
+            break
+    
+    # Add metadata based on filename
+    year_match = re.search(r'(20\d{2}|19\d{2})', filename)
+    subject_match = re.search(r'(math|english|mathematics|language)', filename, re.IGNORECASE)
+    
+    metadata = f"\n[FILE METADATA]\nFilename: {filename}\n"
+    if year_match:
+        metadata += f"Year: {year_match.group(1)}\n"
+    if subject_match:
+        metadata += f"Subject: {subject_match.group(1).title()}\n"
+    
+    return metadata + "\n" + text + "\n" + "\n".join(enhancements)
+
+def process_uploaded_documents(files) -> str:
+    """Process all uploaded SEA exam documents and build searchable index."""
+    if not files:
+        return "⚠️ No files uploaded. Please upload SEA exam PDFs or text files."
+    
+    all_documents = []
+    processing_summary = []
+    
+    for file_info in files:
+        # Gradio provides (temp_path, original_filename) for each file
+        if isinstance(file_info, tuple) and len(file_info) >= 2:
+            file_path, filename = file_info[0], file_info[1]
+        else:
+            # Fallback for different Gradio versions
+            file_path = file_info
+            filename = os.path.basename(str(file_info))
+        
+        try:
+            # Read file content
+            with open(file_path, 'rb') as f:
+                file_bytes = f.read()
+            
+            # Extract text based on file type
+            if filename.lower().endswith('.pdf'):
+                text_content = extract_text_from_pdf(file_bytes, filename)
+                file_type = "PDF"
+            elif filename.lower().endswith(('.txt', '.md')):
+                text_content = file_bytes.decode('utf-8', errors='replace')
+                file_type = "Text"
+            else:
+                text_content = f"Unsupported file type: {filename}"
+                file_type = "Unknown"
+            
+            # Create structured document entry
+            doc_entry = {
+                "filename": filename,
+                "content": text_content[:10000] if len(text_content) > 10000 else text_content,  # Limit size
+                "type": file_type,
+                "subject": detect_subject_from_content(text_content),
+                "size_chars": len(text_content),
+                "upload_time": gr.utils.datetime.datetime.now().isoformat()
+            }
+            
+            all_documents.append(doc_entry)
+            processing_summary.append(f"✅ {filename} ({file_type}, {len(text_content)} chars)")
+            
+        except Exception as e:
+            error_msg = f"❌ Failed to process {filename}: {str(e)}"
+            processing_summary.append(error_msg)
+            print(error_msg)
+    
+    # Save documents to JSON file for persistence
+    try:
+        with open(UPLOADED_DOCS_FILE, 'w', encoding='utf-8') as f:
+            json.dump(all_documents, f, ensure_ascii=False, indent=2)
+        
+        # Create a quick-search index
+        create_search_index(all_documents)
+        
+        summary = f"📚 **Processing Complete**\n\n"
+        summary += f"**Processed {len(all_documents)} files:**\n"
+        summary += "\n".join(processing_summary)
+        summary += f"\n\n📁 Documents saved to: `{UPLOADED_DOCS_FILE}`"
+        summary += f"\n🔍 Index created for RAG queries."
+        
+        return summary
+        
+    except Exception as e:
+        return f"❌ Error saving documents: {str(e)}"
+
+def detect_subject_from_content(text: str) -> str:
+    """Auto-detect subject from document content."""
+    text_lower = text.lower()
+    
+    math_keywords = ['fraction', 'decimal', 'percentage', 'geometry', 'algebra', 'equation', 'calculate', 'sum']
+    english_keywords = ['comprehension', 'grammar', 'vocabulary', 'essay', 'reading', 'writing', 'passage']
+    
+    math_count = sum(1 for keyword in math_keywords if keyword in text_lower)
+    english_count = sum(1 for keyword in english_keywords if keyword in text_lower)
+    
+    if math_count > english_count:
+        return "Mathematics"
+    elif english_count > math_count:
+        return "English Language Arts"
+    else:
+        return "General SEA"
+
+def create_search_index(documents: List[Dict]):
+    """Create a simplified search index for quick lookups."""
+    index_entries = []
+    
+    for doc in documents:
+        # Extract first few lines as preview
+        preview_lines = doc['content'].split('\n')[:10]
+        preview = ' '.join([line.strip() for line in preview_lines if line.strip()])
+        
+        index_entry = {
+            "filename": doc['filename'],
+            "subject": doc['subject'],
+            "preview": preview[:200] + "..." if len(preview) > 200 else preview,
+            "size": doc['size_chars']
+        }
+        index_entries.append(index_entry)
+    
+    # Save index
+    with open("sea_document_index.json", 'w', encoding='utf-8') as f:
+        json.dump(index_entries, f, ensure_ascii=False, indent=2)
+
+def get_relevant_context(subject: str, topic: str, max_context: int = 1500) -> str:
+    """Retrieve relevant context from uploaded SEA papers."""
+    try:
+        if not os.path.exists(UPLOADED_DOCS_FILE):
+            return ""
+        
+        with open(UPLOADED_DOCS_FILE, 'r', encoding='utf-8') as f:
+            documents = json.load(f)
+        
+        relevant_parts = []
+        topic_lower = topic.lower()
+        subject_lower = subject.lower()
+        
+        for doc in documents:
+            doc_content = doc.get('content', '').lower()
+            doc_subject = doc.get('subject', '').lower()
+            
+            # Check relevance
+            relevance_score = 0
+            if topic_lower in doc_content:
+                relevance_score += 3
+            if subject_lower in doc_subject or subject_lower in doc_content:
+                relevance_score += 2
+            
+            if relevance_score > 0:
+                # Extract most relevant snippet
+                content = doc['content']
+                
+                # Try to find topic mention
+                if topic_lower in content.lower():
+                    idx = content.lower().find(topic_lower)
+                    start = max(0, idx - 200)
+                    end = min(len(content), idx + 500)
+                    snippet = content[start:end]
+                else:
+                    # Take beginning of document
+                    snippet = content[:500] + "..."
+                
+                relevant_parts.append(f"\n--- From: {doc['filename']} (Subject: {doc['subject']}) ---\n{snippet}\n")
+        
+        # Combine and limit total size
+        combined = "\n".join(relevant_parts)
+        if len(combined) > max_context:
+            combined = combined[:max_context] + "\n...[context truncated]..."
+        
+        return combined if combined else ""
+        
+    except Exception as e:
+        print(f"Context retrieval error: {e}")
+        return ""
+
+# -----------------------------
+# Enhanced Generation with RAG
+# -----------------------------
+def generate_with_context(prompt: str, subject: str, topic: str, language: str, level: str) -> str:
+    """Enhanced generator using uploaded SEA papers as context."""
+    # Retrieve relevant context from uploaded documents
+    context = get_relevant_context(subject, topic)
+    
+    context_header = ""
+    if context:
+        context_header = f"""
+IMPORTANT CONTEXT FROM UPLOADED SEA EXAM PAPERS:
+{context}
+
+BASED ON THE ABOVE SEA EXAM CONTEXT, please respond to the following request:
+"""
+    else:
+        context_header = """
+NOTE: No SEA exam papers uploaded yet. For more accurate SEA-aligned content, upload past papers using the document upload section.
+"""
+    
+    # Build enhanced prompt
+    enhanced_prompt = f"""
+SEA EXAM TUTOR MODE
+{context_header}
+---
+REQUEST DETAILS:
+Subject: {subject}
+Topic: {topic}
+Language: {language}
+Student Level: {level}
+
+TASK: {prompt}
+
+SPECIFIC SEA REQUIREMENTS:
+1. Align with Trinidad & Tobago SEA exam standards
+2. Use appropriate difficulty for {level} level
+3. Format similar to actual SEA past papers
+4. Include clear, step-by-step explanations where applicable
+5. Focus on conceptual understanding rather than rote memorization
+"""
+    
+    return generate_with_groq(enhanced_prompt)
 
 # -----------------------------
-# Helpers
+# Original Helper Functions (Updated to use RAG)
 # -----------------------------
 def generate_with_groq(prompt: str) -> str:
-    """
-    Call Groq chat completions with the specified model and return text content.
-    Includes basic error handling and a concise error message for the UI.
-    """
+    """Call Groq API with error handling."""
     if not GROQ_API_KEY:
         return "❌ Missing GROQ_API_KEY. Please set it as a secret/environment variable."
-
+    
     try:
         response = client.chat.completions.create(
             model="llama-3.1-8b-instant",
             messages=[{"role": "user", "content": prompt}],
             temperature=0.7,
-            max_tokens=500,
+            max_tokens=800,
         )
         return response.choices[0].message.content
     except Exception as e:
         return f"❌ API error: {e}"
 
-
 def build_system_context(subject: str, topic: str, language: str, level: str) -> str:
     return (
         f"Subject: {subject}\n"
         f"Topic: {topic}\n"
         f"Language: {language}\n"
         f"Student Level: {level}\n"
+        f"Exam: Trinidad & Tobago Secondary Entrance Assessment (SEA)\n"
     )
 
-
 def prompt_explanation(subject: str, topic: str, language: str, level: str) -> str:
     ctx = build_system_context(subject, topic, language, level)
     return (
         f"{ctx}\n"
-        "Task: Write a clear, friendly, step-by-step explanation of the topic."
-        " Use short paragraphs, numbered steps where helpful, and examples."
-        " Keep it concise but thorough. Reply in the specified language only."
+        "Task: Write a clear, friendly, step-by-step explanation of the topic suitable for SEA exam preparation. "
+        "Use examples similar to those found in SEA past papers. "
+        "Include common mistakes students make and how to avoid them. "
+        "Reply in English only."
     )
 
-
 def prompt_resources(subject: str, topic: str, language: str, level: str) -> str:
     ctx = build_system_context(subject, topic, language, level)
     return (
         f"{ctx}\n"
-        "Task: Recommend at least 3 quality learning resources (mix of articles, videos, documentation). "
-        "Return as a markdown bulleted list. Each item must include a title, the type (Article/Video/Docs), "
-        "a one-line why it's useful, and a URL. Reply in the specified language only."
+        "Task: Recommend SEA-specific learning resources. "
+        "Include official resources, practice papers, and study strategies. "
+        "Return as a markdown list with resource type, description, and why it's useful for SEA. "
+        "Reply in English only."
     )
 
-
 def prompt_roadmap(subject: str, topic: str, language: str, level: str) -> str:
     ctx = build_system_context(subject, topic, language, level)
     return (
         f"{ctx}\n"
-        "Task: Produce a structured learning roadmap for this topic and level. "
-        "Organize into stages with bullet points, estimated effort, and key outcomes. "
-        "Add a short list of common mistakes to avoid. Reply in the specified language only."
+        "Task: Create a 4-week study roadmap for this SEA topic. "
+        "Include weekly goals, practice activities, and checkpoints. "
+        "Add test-taking strategies specific to SEA exam format. "
+        "Reply in English only."
     )
 
-
 def prompt_quiz(subject: str, topic: str, language: str, level: str) -> str:
     ctx = build_system_context(subject, topic, language, level)
     return (
         f"{ctx}\n"
-        "Task: Create a short multiple-choice quiz with 3 to 5 questions. "
+        "Task: Create SEA-style multiple choice questions with 4 options each. "
         "Return STRICT JSON only with this schema:\n"
         "{\n"
         '  "questions": [\n'
         '    {\n'
         '      "question": "string",\n'
         '      "options": ["A", "B", "C", "D"],\n'
-        '      "answer_index": 0\n'
+        '      "answer_index": 0,\n'
+        '      "explanation": "string"\n'
         "    }\n"
         "  ]\n"
         "}\n"
         "Requirements:\n"
-        "- options length 3-5\n"
-        "- answer_index is an integer index into the options array\n"
-        "- No additional commentary or code fences\n"
-        f"- Write the question text and options in {language}."
+        "- Exactly 3-5 questions\n"
+        "- Options A-D only\n"
+        "- answer_index is 0-3\n"
+        "- Include explanation for answer\n"
+        "- Questions must be SEA exam appropriate\n"
     )
 
+def prompt_past_paper_question(subject: str, topic: str) -> str:
+    """Generate a new question in SEA exam format."""
+    return (
+        f"Subject: {subject}\n"
+        f"Topic: {topic}\n"
+        "Task: Create a NEW practice question in the exact format of Trinidad & Tobago SEA exam. "
+        "Include:\n"
+        "1. The question text\n"
+        "2. Multiple choice options (A-D) or structured answer format\n"
+        "3. Correct answer\n"
+        "4. Step-by-step solution\n"
+        "5. Marks allocation\n"
+        "6. Common errors to avoid\n"
+        "Make it original but consistent with SEA standards."
+    )
+
+# -----------------------------
+# Gradio Callbacks (Updated)
+# -----------------------------
+def on_generate_explanation(subject, topic, language, level):
+    base_prompt = prompt_explanation(subject, topic, language, level)
+    return generate_with_context(base_prompt, subject, topic, language, level)
+
+def on_generate_resources(subject, topic, language, level):
+    base_prompt = prompt_resources(subject, topic, language, level)
+    return generate_with_context(base_prompt, subject, topic, language, level)
+
+def on_generate_roadmap(subject, topic, language, level):
+    base_prompt = prompt_roadmap(subject, topic, language, level)
+    return generate_with_context(base_prompt, subject, topic, language, level)
 
+def on_generate_quiz(subject, topic, language, level):
+    base_prompt = prompt_quiz(subject, topic, language, level)
+    raw_json = generate_with_context(base_prompt, subject, topic, language, level)
+    
+    # Parse and normalize quiz
+    quiz = normalize_quiz(parse_quiz_json(raw_json))
+    
+    # Update UI components
+    vis = [False] * 5
+    labels = [("Question", ["Option 1", "Option 2", "Option 3", "Option 4"])] * 5
+    
+    for i, q in enumerate(quiz[:5]):  # Max 5 questions
+        vis[i] = True
+        labels[i] = (f"Q{i+1}. {q['question']}", q["options"])
+    
+    status = f"✅ Generated {len(quiz)} SEA-style questions." if quiz else "⚠️ No valid questions generated."
+    
+    return (
+        quiz,
+        gr.update(visible=vis[0], label=labels[0][0], choices=labels[0][1], value=None),
+        gr.update(visible=vis[1], label=labels[1][0], choices=labels[1][1], value=None),
+        gr.update(visible=vis[2], label=labels[2][0], choices=labels[2][1], value=None),
+        gr.update(visible=vis[3], label=labels[3][0], choices=labels[3][1], value=None),
+        gr.update(visible=vis[4], label=labels[4][0], choices=labels[4][1], value=None),
+        status
+    )
+
+def on_generate_past_paper_question(subject, topic):
+    prompt = prompt_past_paper_question(subject, topic)
+    return generate_with_context(prompt, subject, topic, "English", "Intermediate")
+
+# -----------------------------
+# Original Quiz Functions (Keep as is)
+# -----------------------------
 def parse_quiz_json(text: str) -> Dict[str, Any]:
-    """
-    Extract and parse the JSON quiz from model output.
-    Tries to locate the first JSON-looking block if the response isn't pure JSON.
-    """
-    # Try direct JSON first
+    """Extract and parse JSON quiz from model output."""
     try:
         parsed = json.loads(text)
         if "questions" in parsed:
             return parsed
     except Exception:
         pass
-
-    # Fallback: regex to find JSON block
+    
     match = re.search(r"\{(?:[^{}]|(?R))*\}", text, re.DOTALL)
     if match:
         try:
@@ -136,261 +479,393 @@ def parse_quiz_json(text: str) -> Dict[str, Any]:
                 return parsed
         except Exception:
             pass
-
-    # Final fallback
+    
     return {"questions": []}
 
-
 def normalize_quiz(quiz: Dict[str, Any]) -> List[Dict[str, Any]]:
-    """
-    Ensure each question has required fields. Drop invalid ones.
-    """
+    """Ensure each question has required fields."""
     cleaned = []
     for q in quiz.get("questions", []):
         question = q.get("question")
         options = q.get("options", [])
         answer_index = q.get("answer_index")
+        
         if (
             isinstance(question, str)
             and isinstance(options, list)
-            and 3 <= len(options) <= 5
+            and 2 <= len(options) <= 5
             and isinstance(answer_index, int)
             and 0 <= answer_index < len(options)
         ):
-            cleaned.append(
-                {
-                    "question": question.strip(),
-                    "options": [str(o).strip() for o in options],
-                    "answer_index": answer_index,
-                }
-            )
-    return cleaned[:5]  # at most 5
-
+            cleaned.append({
+                "question": question.strip(),
+                "options": [str(o).strip() for o in options],
+                "answer_index": answer_index,
+                "explanation": q.get("explanation", "No explanation provided.")
+            })
+    
+    return cleaned[:5]
 
 def evaluate_answers(
     user_choices: List[int], quiz_data: List[Dict[str, Any]]
 ) -> Tuple[str, str]:
-    """
-    Compute score and short feedback summary.
-    """
+    """Compute score and feedback."""
+    if not quiz_data:
+        return "No quiz available.", "Generate a quiz first."
+    
     correct = 0
     details = []
+    
     for i, q in enumerate(quiz_data):
         user_idx = user_choices[i] if i < len(user_choices) else None
         ans_idx = q["answer_index"]
         is_correct = (user_idx == ans_idx)
+        
         if is_correct:
             correct += 1
-        # Build per-question line
+        
         chosen = (
             f"{q['options'][user_idx]}"
             if isinstance(user_idx, int) and 0 <= user_idx < len(q["options"])
             else "No answer"
         )
+        
         details.append(
-            f"Q{i+1}: {'✅ Correct' if is_correct else '❌ Incorrect'} | "
-            f"Your answer: {chosen} | Correct: {q['options'][ans_idx]}"
+            f"**Q{i+1}:** {'✅ Correct' if is_correct else '❌ Incorrect'}\n"
+            f"Your answer: {chosen}\n"
+            f"Correct answer: {q['options'][ans_idx]}\n"
+            f"Explanation: {q.get('explanation', 'No explanation')}\n"
         )
-
+    
     total = len(quiz_data)
-    score_text = f"Score: {correct} / {total}"
-    if total == 0:
-        return "No quiz generated yet.", ""
-    # Brief feedback
-    if correct == total and total > 0:
-        feedback = "Great job. You’ve mastered this set."
-    elif correct >= (total * 0.6):
-        feedback = "Good work. Review the missed questions and try again."
+    score_text = f"## 📊 Score: {correct} / {total}"
+    
+    if correct == total:
+        feedback = "**Excellent!** You've mastered these SEA-style questions."
+    elif correct >= total * 0.7:
+        feedback = "**Good work!** Review the explanations for any mistakes."
     else:
-        feedback = "Keep practicing. Revisit the explanation and roadmap."
-
-    return score_text, feedback + "\n\n" + "\n".join(details)
-
-
-# -----------------------------
-# Gradio Callbacks
-# -----------------------------
-def on_generate_explanation(subject, topic, language, level):
-    prompt = prompt_explanation(subject, topic, language, level)
-    return generate_with_groq(prompt)
-
-
-def on_generate_resources(subject, topic, language, level):
-    prompt = prompt_resources(subject, topic, language, level)
-    return generate_with_groq(prompt)
-
-
-def on_generate_roadmap(subject, topic, language, level):
-    prompt = prompt_roadmap(subject, topic, language, level)
-    return generate_with_groq(prompt)
-
-
-def on_generate_quiz(subject, topic, language, level):
-    raw = generate_with_groq(prompt_quiz(subject, topic, language, level))
-    quiz = normalize_quiz(parse_quiz_json(raw))
-
-    # Build updates for up to 5 radios and their labels
-    vis = [False] * 5
-    labels = [("Question", ["Option 1", "Option 2", "Option 3"])] * 5
-
-    for i, q in enumerate(quiz):
-        vis[i] = True
-        labels[i] = (f"Q{i+1}. {q['question']}", q["options"])
-
-    return (
-        quiz,  # gr.State
-        gr.update(visible=vis[0], label=labels[0][0], choices=labels[0][1], value=None),
-        gr.update(visible=vis[1], label=labels[1][0], choices=labels[1][1], value=None),
-        gr.update(visible=vis[2], label=labels[2][0], choices=labels[2][1], value=None),
-        gr.update(visible=vis[3], label=labels[3][0], choices=labels[3][1], value=None),
-        gr.update(visible=vis[4], label=labels[4][0], choices=labels[4][1], value=None),
-        raw if not quiz else "Quiz generated. Select your answers below."
-    )
-
+        feedback = "**Keep practicing!** Review the topic and try again."
+    
+    feedback += "\n\n### Question Details:\n" + "\n".join(details)
+    return score_text, feedback
 
-def on_display_results(
-    quiz_state,
-    a1, a2, a3, a4, a5
-):
+def on_display_results(quiz_state, a1, a2, a3, a4, a5):
     quiz = quiz_state or []
-    # Map selected option text back to index
+    
+    # Map selected options to indices
     selections = []
+    chosen_texts = [a1, a2, a3, a4, a5]
+    
     for i, q in enumerate(quiz):
-        # chosen label may be None
-        chosen = [a1, a2, a3, a4, a5][i]
+        chosen = chosen_texts[i] if i < len(chosen_texts) else None
         if chosen is None:
             selections.append(None)
             continue
+        
         try:
             idx = q["options"].index(chosen)
+            selections.append(idx)
         except ValueError:
-            idx = None
-        selections.append(idx)
-
-    score_text, feedback = evaluate_answers(selections, quiz)
-    return score_text, feedback
-
+            selections.append(None)
+    
+    return evaluate_answers(selections, quiz)
 
 # -----------------------------
-# UI
+# Enhanced Gradio UI
 # -----------------------------
-# Custom blue theme + card-like styling
 CSS = """
 :root {
-  --brand-blue: #1e40af; /* indigo-800 */
-  --brand-blue-600: #2563eb;
-  --card-bg: #f8fafc;
-  --border: #cbd5e1;
+  --sea-blue: #1a5f7a;
+  --sea-light-blue: #57cc99;
+  --card-bg: #f8f9fa;
+  --border: #dee2e6;
 }
-
-.gradio-container {max-width: 1200px !important}
-#title h1 {color: var(--brand-blue); margin-bottom: 6px}
-#subtitle {color:#334155; margin-top:0}
-
+.gradio-container {max-width: 1200px !important; font-family: 'Segoe UI', sans-serif;}
+#title h1 {color: var(--sea-blue); margin-bottom: 6px; border-bottom: 3px solid var(--sea-light-blue); padding-bottom: 10px;}
+#subtitle {color: #495057; margin-top: 0; font-style: italic;}
 .card {
   background: var(--card-bg);
   border: 1px solid var(--border);
-  border-radius: 14px;
-  padding: 14px;
-  box-shadow: 0 2px 8px rgb(2 6 23 / 6%);
+  border-radius: 12px;
+  padding: 18px;
+  box-shadow: 0 4px 12px rgba(26, 95, 122, 0.08);
+  margin-bottom: 20px;
 }
-
 .btn-primary button {
-  background: var(--brand-blue-600) !important;
-  border-color: var(--brand-blue-600) !important;
+  background: linear-gradient(135deg, var(--sea-blue), #2a9d8f) !important;
+  border: none !important;
   color: white !important;
+  font-weight: 600 !important;
+  border-radius: 8px !important;
+  padding: 10px 24px !important;
+}
+.btn-primary button:hover {
+  background: linear-gradient(135deg, #2a9d8f, var(--sea-blue)) !important;
+  transform: translateY(-2px);
+  transition: all 0.3s ease;
 }
-
 .section-title {
-  font-weight: 700; color: var(--brand-blue);
-  margin-bottom: 6px; font-size: 16px;
+  font-weight: 700;
+  color: var(--sea-blue);
+  margin-bottom: 12px;
+  font-size: 18px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.section-title::before {
+  content: "📘";
+}
+.upload-section {
+  border: 2px dashed var(--sea-light-blue) !important;
+  background: rgba(87, 204, 153, 0.05) !important;
+}
+.sea-badge {
+  background: var(--sea-light-blue);
+  color: white;
+  padding: 2px 8px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: 600;
+  margin-left: 8px;
 }
 """
 
 with gr.Blocks(css=CSS, theme=gr.themes.Soft(primary_hue="blue")) as demo:
-    gr.Markdown("<div id='title'><h1>AI Study Tutor</h1><p id='subtitle'>Powered by Groq + Gradio</p></div>")
-
+    gr.Markdown(
+        """
+        <div id='title'>
+            <h1>🇹🇹 AI SEA Exam Tutor - Trinidad & Tobago</h1>
+            <p id='subtitle'>Secondary Entrance Assessment Preparation Assistant</p>
+        </div>
+        """
+    )
+    
     with gr.Row():
         with gr.Column(scale=1):
             with gr.Group(elem_classes="card"):
-                gr.Markdown("### Inputs")
-                subject = gr.Textbox(label="Subject", placeholder="e.g., Mathematics")
-                topic = gr.Textbox(label="Topic", placeholder="e.g., Derivatives of Trigonometric Functions")
-                language = gr.Dropdown(LANG_OPTIONS, value="English", label="Language")
-                level = gr.Radio(LEVEL_OPTIONS, value="Beginner", label="Level")
-
+                gr.Markdown("### 📝 SEA Study Parameters")
+                
+                subject = gr.Dropdown(
+                    choices=SEA_SUBJECTS,
+                    value="Mathematics",
+                    label="SEA Subject",
+                    info="Select subject area"
+                )
+                
+                # Dynamic topic based on subject
+                def update_topics(subject):
+                    if subject == "Mathematics":
+                        return gr.Dropdown(choices=SEA_MATH_TOPICS, value=SEA_MATH_TOPICS[0])
+                    else:
+                        return gr.Dropdown(choices=SEA_ENGLISH_TOPICS, value=SEA_ENGLISH_TOPICS[0])
+                
+                topic = gr.Dropdown(
+                    choices=SEA_MATH_TOPICS,
+                    value=SEA_MATH_TOPICS[0],
+                    label="Topic Area"
+                )
+                
+                subject.change(update_topics, inputs=[subject], outputs=[topic])
+                
+                language = gr.Dropdown(
+                    choices=LANG_OPTIONS,
+                    value="English",
+                    label="Language",
+                    interactive=False  # SEA is primarily English
+                )
+                
+                level = gr.Radio(
+                    choices=LEVEL_OPTIONS,
+                    value="Intermediate",
+                    label="Student Level"
+                )
+        
         with gr.Column(scale=2):
-            # Explanation
+            # Document Upload Section
+            with gr.Group(elem_classes="card upload-section"):
+                gr.Markdown("### 📤 Upload SEA Exam Papers")
+                gr.Markdown("Upload past papers, answer sheets, or study materials. The AI will use these to generate accurate SEA-style content.")
+                
+                uploaded_files = gr.Files(
+                    label="Upload Files (PDF, TXT)",
+                    file_types=[".pdf", ".txt"],
+                    file_count="multiple",
+                    interactive=True
+                )
+                
+                with gr.Row():
+                    process_btn = gr.Button(
+                        "Process Uploaded Documents",
+                        variant="primary",
+                        scale=2
+                    )
+                    clear_btn = gr.Button("Clear Files", variant="secondary", scale=1)
+                
+                upload_status = gr.Markdown(
+                    "**Status:** No documents uploaded yet. Upload SEA papers for enhanced accuracy.",
+                    elem_classes="status-text"
+                )
+                
+                # Processing events
+                process_btn.click(
+                    fn=process_uploaded_documents,
+                    inputs=[uploaded_files],
+                    outputs=[upload_status]
+                )
+                
+                clear_btn.click(
+                    fn=lambda: (None, "✅ Files cleared. Upload new documents."),
+                    inputs=[],
+                    outputs=[uploaded_files, upload_status]
+                )
+    
+    # Main Features in Tabs
+    with gr.Tabs():
+        with gr.TabItem("📚 Explanation & Resources"):
+            with gr.Column():
+                with gr.Group(elem_classes="card"):
+                    gr.Markdown("<div class='section-title'>Generate SEA-Aligned Explanation</div>")
+                    btn_explain = gr.Button("Generate Explanation", variant="primary")
+                    explanation = gr.Markdown(
+                        label="SEA-Focused Explanation",
+                        value="Click 'Generate Explanation' for a topic-specific guide.",
+                        elem_classes="output-area"
+                    )
+                
+                with gr.Group(elem_classes="card"):
+                    gr.Markdown("<div class='section-title'>Generate Study Resources</div>")
+                    btn_resources = gr.Button("Generate Resources", variant="primary")
+                    resources = gr.Markdown(
+                        label="Recommended Resources",
+                        value="Resources will appear here.",
+                        elem_classes="output-area"
+                    )
+        
+        with gr.TabItem("🗺️ Study Roadmap"):
+            with gr.Column():
+                with gr.Group(elem_classes="card"):
+                    gr.Markdown("<div class='section-title'>Generate 4-Week Study Roadmap</div>")
+                    btn_roadmap = gr.Button("Generate Roadmap", variant="primary")
+                    roadmap = gr.Markdown(
+                        label="Study Roadmap",
+                        value="Your personalized roadmap will appear here.",
+                        elem_classes="output-area"
+                    )
+        
+        with gr.TabItem("📝 Quiz & Assessment"):
+            with gr.Column():
+                with gr.Group(elem_classes="card"):
+                    gr.Markdown("<div class='section-title'>Generate SEA-Style Quiz</div>")
+                    
+                    with gr.Row():
+                        btn_quiz = gr.Button("Generate New Quiz", variant="primary", scale=2)
+                        btn_past_paper = gr.Button("Generate Past Paper Question", variant="secondary", scale=1)
+                    
+                    quiz_info = gr.Markdown("Click 'Generate New Quiz' to create SEA-style questions.")
+                    
+                    # Past paper question output
+                    past_paper_output = gr.Markdown(visible=False)
+                    
+                    # Quiz state and questions
+                    quiz_state = gr.State([])
+                    
+                    # Question containers (up to 5)
+                    with gr.Column(visible=False) as quiz_container:
+                        q1 = gr.Radio(label="Question 1", choices=[], visible=False, interactive=True)
+                        q2 = gr.Radio(label="Question 2", choices=[], visible=False, interactive=True)
+                        q3 = gr.Radio(label="Question 3", choices=[], visible=False, interactive=True)
+                        q4 = gr.Radio(label="Question 4", choices=[], visible=False, interactive=True)
+                        q5 = gr.Radio(label="Question 5", choices=[], visible=False, interactive=True)
+                
+                with gr.Group(elem_classes="card"):
+                    gr.Markdown("<div class='section-title'>Evaluate Your Answers</div>")
+                    btn_results = gr.Button("Check Answers", variant="primary")
+                    
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            score = gr.Markdown("**Score:** Not assessed yet.")
+                        with gr.Column(scale=3):
+                            feedback = gr.Markdown("**Feedback:** Submit quiz answers for evaluation.")
+        
+        with gr.TabItem("ℹ️ System Info"):
             with gr.Group(elem_classes="card"):
-                gr.Markdown("<div class='section-title'>Generate Explanation</div>")
-                btn_explain = gr.Button("Generate Explanation", elem_classes="btn-primary")
-                explanation = gr.Markdown(label="Explanation", value="")
-
-            # Resources
-            with gr.Group(elem_classes="card"):
-                gr.Markdown("<div class='section-title'>Generate Resources</div>")
-                btn_resources = gr.Button("Generate Resources", elem_classes="btn-primary")
-                resources = gr.Markdown(label="Resources", value="")
-
-    with gr.Row():
-        with gr.Column():
-            with gr.Group(elem_classes="card"):
-                gr.Markdown("<div class='section-title'>Generate Roadmap</div>")
-                btn_roadmap = gr.Button("Generate Roadmap", elem_classes="btn-primary")
-                roadmap = gr.Markdown(label="Roadmap", value="")
-
-    with gr.Row():
-        with gr.Column():
-            with gr.Group(elem_classes="card"):
-                gr.Markdown("<div class='section-title'>Generate Quiz</div>")
-                btn_quiz = gr.Button("Generate Quiz", elem_classes="btn-primary")
-                quiz_info = gr.Markdown("Click the button to create a quiz.")
-                # Quiz state and up to 5 radios
-                quiz_state = gr.State([])
-                q1 = gr.Radio(label="Question 1", choices=[], visible=False, interactive=True)
-                q2 = gr.Radio(label="Question 2", choices=[], visible=False, interactive=True)
-                q3 = gr.Radio(label="Question 3", choices=[], visible=False, interactive=True)
-                q4 = gr.Radio(label="Question 4", choices=[], visible=False, interactive=True)
-                q5 = gr.Radio(label="Question 5", choices=[], visible=False, interactive=True)
-
-    with gr.Row():
-        with gr.Column():
-            with gr.Group(elem_classes="card"):
-                gr.Markdown("<div class='section-title'>Display Results</div>")
-                btn_results = gr.Button("Evaluate Answers", elem_classes="btn-primary")
-                score = gr.Markdown("Score will appear here.")
-                feedback = gr.Markdown("Feedback will appear here.")
-
-    # Events
+                gr.Markdown("### System Information")
+                gr.Markdown(f"""
+                **Current Configuration:**
+                - Model: Llama 3.1 8B Instant (via Groq)
+                - RAG Enabled: {'Yes' if os.path.exists(UPLOADED_DOCS_FILE) else 'No'}
+                - Documents Loaded: {len(json.load(open(UPLOADED_DOCS_FILE))) if os.path.exists(UPLOADED_DOCS_FILE) else 0}
+                - Subjects Configured: {len(SEA_SUBJECTS)}
+                
+                **How to use:**
+                1. Upload SEA past papers (PDF format)
+                2. Select subject and topic
+                3. Generate explanations, resources, or quizzes
+                4. The AI will reference uploaded papers for accuracy
+                
+                **Note:** All content is generated based on SEA exam standards and any uploaded materials.
+                """)
+    
+    # Event Handlers
     btn_explain.click(
         fn=on_generate_explanation,
         inputs=[subject, topic, language, level],
-        outputs=[explanation],
+        outputs=[explanation]
     )
-
+    
     btn_resources.click(
         fn=on_generate_resources,
         inputs=[subject, topic, language, level],
-        outputs=[resources],
+        outputs=[resources]
     )
-
+    
     btn_roadmap.click(
         fn=on_generate_roadmap,
         inputs=[subject, topic, language, level],
-        outputs=[roadmap],
+        outputs=[roadmap]
     )
-
+    
     btn_quiz.click(
         fn=on_generate_quiz,
         inputs=[subject, topic, language, level],
-        outputs=[quiz_state, q1, q2, q3, q4, q5, quiz_info],
+        outputs=[quiz_state, q1, q2, q3, q4, q5, quiz_info]
+    ).then(
+        fn=lambda: gr.update(visible=True),
+        inputs=[],
+        outputs=[quiz_container]
     )
-
+    
+    btn_past_paper.click(
+        fn=on_generate_past_paper_question,
+        inputs=[subject, topic],
+        outputs=[past_paper_output]
+    ).then(
+        fn=lambda: gr.update(visible=True),
+        inputs=[],
+        outputs=[past_paper_output]
+    )
+    
     btn_results.click(
         fn=on_display_results,
         inputs=[quiz_state, q1, q2, q3, q4, q5],
-        outputs=[score, feedback],
+        outputs=[score, feedback]
     )
 
+# -----------------------------
+# Launch Application
+# -----------------------------
 if __name__ == "__main__":
-    demo.launch()
+    # Create necessary directories
+    os.makedirs("uploads", exist_ok=True)
+    os.makedirs("data", exist_ok=True)
+    
+    # Launch with file upload support
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        max_file_size="20mb",  # Limit file size for safety
+        show_error=True
+    )