Update app.py

app.py

@@ -12,6 +12,7 @@ import time
 import re
 from PIL import Image
 import io
+from collections import defaultdict
 
 # ---------- 1. Configure ALL AI Systems ----------
 # Gemini (Primary)
@@ -200,33 +201,6 @@ Return ONLY valid JSON:
     except:
         return {"subject": "Unknown", "year": "Unknown", "series": "Unknown", "variant": "Unknown", "paper_number": "Unknown", "syllabus_code": "Unknown"}
 
-def extract_questions_from_text(text, paper_id, paper_title, subject, paper_details):
-    if not text or len(text) < 100:
-        return []
-    
-    prompt = f"""Extract ALL questions from this IGCSE {subject} paper.
-
-Paper Text: {text[:8000]}
-
-Return JSON array:
-[{{"question_number": "1(a)", "question_text": "...", "marks": 2, "topic": "...", "requires_insert": false, "question_type": "..."}}]"""
-    
-    try:
-        response, _ = ask_ai(prompt, temperature=0.2)
-        clean_txt = response.replace("```json", "").replace("```", "").strip()
-        questions = json.loads(clean_txt)
-        
-        for q in questions:
-            q['paper_id'] = paper_id
-            q['paper_title'] = paper_title
-            q['subject'] = subject
-            q['year'] = paper_details.get('year', 'Unknown')
-            q['series'] = paper_details.get('series', 'Unknown')
-        
-        return questions
-    except:
-        return []
-
 def process_insert_file(insert_file):
     if insert_file is None:
         return None, None
@@ -243,7 +217,363 @@ def process_insert_file(insert_file):
     except:
         return None, None
 
-# ---------- 6. AI Tutor ----------
+# ---------- 6. Enhanced Question Extraction Functions ----------
+def extract_questions_comprehensive(text, paper_id, paper_title, subject, paper_details):
+    """
+    Multi-pass question extraction with validation and topic mapping
+    """
+    if not text or len(text) < 100:
+        return []
+    
+    # First pass: Extract questions with AI
+    questions = extract_questions_with_ai(text, paper_id, paper_title, subject, paper_details)
+    
+    # Second pass: Validate and enhance questions
+    validated_questions = validate_and_enhance_questions(questions, text, subject)
+    
+    # Third pass: Map to specific topics
+    questions_with_topics = map_questions_to_topics(validated_questions, subject)
+    
+    return questions_with_topics
+
+def extract_questions_with_ai(text, paper_id, paper_title, subject, paper_details):
+    """
+    Primary AI extraction with detailed prompting
+    """
+    # Split text into chunks if too long
+    max_chunk_size = 6000
+    text_chunks = [text[i:i+max_chunk_size] for i in range(0, len(text), max_chunk_size)]
+    
+    all_questions = []
+    
+    for chunk_idx, chunk in enumerate(text_chunks):
+        prompt = f"""Extract ALL questions from this IGCSE {subject} exam paper chunk.
+
+Paper: {paper_title}
+Text Chunk {chunk_idx + 1}:
+{chunk}
+
+For EACH question found, provide detailed JSON with:
+1. Question number (e.g., "1(a)", "2(b)(i)")
+2. Complete question text
+3. Marks allocated
+4. Main topic being tested
+5. Whether it requires reference to an insert/diagram
+6. Question type (knowledge, application, analysis, evaluation)
+7. Key concepts being tested
+8. Command words used (e.g., "explain", "describe", "evaluate")
+
+Return ONLY a valid JSON array:
+[
+  {{
+    "question_number": "1(a)",
+    "question_text": "Complete question text here...",
+    "marks": 2,
+    "topic": "Primary topic",
+    "subtopics": ["subtopic1", "subtopic2"],
+    "requires_insert": false,
+    "question_type": "application",
+    "key_concepts": ["concept1", "concept2"],
+    "command_words": ["explain"],
+    "difficulty": "medium"
+  }}
+]
+
+IMPORTANT: 
+- Include ALL questions, even multi-part ones
+- Preserve question numbering exactly as it appears
+- Mark questions requiring inserts/diagrams as "requires_insert": true
+- Be specific with topics (e.g., "RAM vs ROM" not just "Hardware")"""
+        
+        try:
+            response, _ = ask_ai(prompt, temperature=0.1)
+            clean_txt = response.replace("```json", "").replace("```", "").strip()
+            
+            # Handle multiple JSON objects or arrays
+            if clean_txt.startswith('['):
+                questions_chunk = json.loads(clean_txt)
+            else:
+                # Try to find JSON array in response
+                json_match = re.search(r'\[.*\]', clean_txt, re.DOTALL)
+                if json_match:
+                    questions_chunk = json.loads(json_match.group())
+                else:
+                    continue
+            
+            # Add metadata to each question
+            for q in questions_chunk:
+                q['paper_id'] = paper_id
+                q['paper_title'] = paper_title
+                q['subject'] = subject
+                q['year'] = paper_details.get('year', 'Unknown')
+                q['series'] = paper_details.get('series', 'Unknown')
+                q['paper_number'] = paper_details.get('paper_number', 'Unknown')
+                q['variant'] = paper_details.get('variant', 'Unknown')
+                q['chunk_index'] = chunk_idx
+            
+            all_questions.extend(questions_chunk)
+            
+        except Exception as e:
+            print(f"⚠ Error extracting from chunk {chunk_idx}: {e}")
+            continue
+    
+    return all_questions
+
+def validate_and_enhance_questions(questions, full_text, subject):
+    """
+    Validate extracted questions and fix common issues
+    """
+    validated = []
+    
+    for q in questions:
+        # Ensure required fields exist
+        if not q.get('question_text') or not q.get('question_number'):
+            continue
+        
+        # Clean question text
+        q['question_text'] = q['question_text'].strip()
+        
+        # Ensure marks is an integer
+        try:
+            q['marks'] = int(q.get('marks', 0))
+        except:
+            q['marks'] = 0
+        
+        # Set defaults for optional fields
+        q['topic'] = q.get('topic', 'General')
+        q['subtopics'] = q.get('subtopics', [])
+        q['requires_insert'] = q.get('requires_insert', False)
+        q['question_type'] = q.get('question_type', 'knowledge')
+        q['key_concepts'] = q.get('key_concepts', [])
+        q['command_words'] = q.get('command_words', [])
+        q['difficulty'] = q.get('difficulty', 'medium')
+        
+        # Auto-detect insert requirement if not specified
+        if not q['requires_insert']:
+            insert_keywords = ['diagram', 'figure', 'table', 'insert', 'image', 'screenshot', 'shown']
+            q['requires_insert'] = any(kw in q['question_text'].lower() for kw in insert_keywords)
+        
+        validated.append(q)
+    
+    return validated
+
+def map_questions_to_topics(questions, subject):
+    """
+    Map questions to specific curriculum topics
+    """
+    topic_lists = {
+        "ICT": ict_topics,
+        "Physical Education": pe_topics
+    }
+    
+    topics = topic_lists.get(subject, [])
+    
+    for q in questions:
+        # If topic is generic, try to find more specific match
+        if q['topic'] in ['General', 'Unknown', '']:
+            best_match = find_best_topic_match(q['question_text'], topics)
+            if best_match:
+                q['topic'] = best_match
+        
+        # Add searchable keywords
+        q['search_keywords'] = generate_search_keywords(q)
+    
+    return questions
+
+def find_best_topic_match(question_text, topic_list):
+    """
+    Find the most relevant topic for a question
+    """
+    question_lower = question_text.lower()
+    
+    # Direct keyword matching
+    for topic in topic_list:
+        topic_keywords = topic.lower().split()
+        if any(keyword in question_lower for keyword in topic_keywords if len(keyword) > 3):
+            return topic
+    
+    # Use AI for complex matching
+    prompt = f"""Which ONE topic from this list best matches the question?
+
+Topics: {', '.join(topic_list)}
+
+Question: {question_text[:300]}
+
+Return ONLY the exact topic name from the list, nothing else."""
+    
+    try:
+        response, _ = ask_ai(prompt, temperature=0.1)
+        matched_topic = response.strip()
+        if matched_topic in topic_list:
+            return matched_topic
+    except:
+        pass
+    
+    return "General"
+
+def generate_search_keywords(question):
+    """
+    Generate searchable keywords from question
+    """
+    keywords = set()
+    
+    # Add from question text
+    text_words = re.findall(r'\b\w{4,}\b', question['question_text'].lower())
+    keywords.update(text_words)
+    
+    # Add from metadata
+    keywords.add(question['topic'].lower())
+    keywords.update([st.lower() for st in question.get('subtopics', [])])
+    keywords.update([kc.lower() for kc in question.get('key_concepts', [])])
+    
+    # Remove common words
+    stop_words = {'what', 'which', 'when', 'where', 'explain', 'describe', 'give', 'state', 'name'}
+    keywords = keywords - stop_words
+    
+    return list(keywords)
+
+# ---------- 7. Enhanced Search Function ----------
+def search_questions_advanced(subject, search_term, filters=None):
+    """
+    Advanced question search with multiple filters
+    
+    filters = {
+        'year': '2023',
+        'series': 'June',
+        'marks_min': 2,
+        'marks_max': 8,
+        'question_type': 'application',
+        'difficulty': 'medium',
+        'requires_insert': False
+    }
+    """
+    if not questions_index:
+        return "📚 No questions yet. Admin needs to upload papers!"
+    
+    # Filter by subject
+    matching = [q for q in questions_index if q['subject'] == subject]
+    
+    # Filter by search term (topic, keywords, question text)
+    if search_term:
+        search_lower = search_term.lower()
+        matching = [q for q in matching if (
+            search_lower in q['topic'].lower() or
+            search_lower in q['question_text'].lower() or
+            any(search_lower in kw for kw in q.get('search_keywords', []))
+        )]
+    
+    # Apply additional filters
+    if filters:
+        if 'year' in filters and filters['year']:
+            matching = [q for q in matching if q.get('year') == filters['year']]
+        
+        if 'series' in filters and filters['series']:
+            matching = [q for q in matching if q.get('series') == filters['series']]
+        
+        if 'marks_min' in filters:
+            matching = [q for q in matching if q.get('marks', 0) >= filters['marks_min']]
+        
+        if 'marks_max' in filters:
+            matching = [q for q in matching if q.get('marks', 0) <= filters['marks_max']]
+        
+        if 'question_type' in filters and filters['question_type']:
+            matching = [q for q in matching if q.get('question_type') == filters['question_type']]
+        
+        if 'difficulty' in filters and filters['difficulty']:
+            matching = [q for q in matching if q.get('difficulty') == filters['difficulty']]
+        
+        if 'requires_insert' in filters:
+            matching = [q for q in matching if q.get('requires_insert') == filters['requires_insert']]
+    
+    if not matching:
+        return f"🔍 No questions found matching your criteria."
+    
+    # Group by paper
+    questions_by_paper = defaultdict(list)
+    for q in matching:
+        questions_by_paper[q['paper_title']].append(q)
+    
+    # Format results
+    result = f"### 🎯 Found {len(matching)} question(s) from {len(questions_by_paper)} paper(s)\n\n"
+    
+    for paper_title, questions in questions_by_paper.items():
+        result += f"#### 📄 {paper_title}\n\n"
+        
+        for q in questions:
+            insert_icon = "🖼️ " if q.get('requires_insert') else ""
+            difficulty_icon = {"easy": "✅", "medium": "⚡", "hard": "🔥"}.get(q.get('difficulty', 'medium'), "⚡")
+            
+            result += f"""**{q['question_number']}** | {insert_icon}{difficulty_icon} {q['marks']} marks | {q.get('question_type', 'knowledge').title()}
+📌 Topic: **{q['topic']}**
+{f"🔸 Subtopics: {', '.join(q.get('subtopics', []))}" if q.get('subtopics') else ""}
+
+{q['question_text']}
+
+{f"💡 Key concepts: {', '.join(q.get('key_concepts', []))}" if q.get('key_concepts') else ""}
+{f"📝 Command words: {', '.join(q.get('command_words', []))}" if q.get('command_words') else ""}
+
+{'─'*80}
+"""
+        
+        result += "\n"
+    
+    return result
+
+# ---------- 8. Question Analytics ----------
+def analyze_question_bank(subject=None):
+    """
+    Provide analytics on available questions
+    """
+    questions = questions_index if not subject else [q for q in questions_index if q['subject'] == subject]
+    
+    if not questions:
+        return "No questions available for analysis."
+    
+    # Topic distribution
+    topic_counts = defaultdict(int)
+    for q in questions:
+        topic_counts[q['topic']] += 1
+    
+    # Difficulty distribution
+    difficulty_counts = defaultdict(int)
+    for q in questions:
+        difficulty_counts[q.get('difficulty', 'medium')] += 1
+    
+    # Question type distribution
+    type_counts = defaultdict(int)
+    for q in questions:
+        type_counts[q.get('question_type', 'knowledge')] += 1
+    
+    # Year distribution
+    year_counts = defaultdict(int)
+    for q in questions:
+        year_counts[q.get('year', 'Unknown')] += 1
+    
+    result = f"""### 📊 Question Bank Analytics
+**Total Questions:** {len(questions)}
+**Subject:** {subject or 'All'}
+
+#### 📚 Topics Coverage
+"""
+    
+    for topic, count in sorted(topic_counts.items(), key=lambda x: x[1], reverse=True)[:10]:
+        result += f"- {topic}: {count} questions\n"
+    
+    result += f"\n#### 🎯 Difficulty Distribution\n"
+    for diff, count in difficulty_counts.items():
+        result += f"- {diff.title()}: {count} questions\n"
+    
+    result += f"\n#### 📝 Question Types\n"
+    for qtype, count in type_counts.items():
+        result += f"- {qtype.title()}: {count} questions\n"
+    
+    result += f"\n#### 📅 Year Coverage\n"
+    for year, count in sorted(year_counts.items(), reverse=True):
+        result += f"- {year}: {count} questions\n"
+    
+    return result
+
+# ---------- 9. AI Tutor ----------
 def ai_tutor_chat(message, history, subject, topic):
     if not message.strip():
         return history
@@ -283,7 +613,7 @@ Guide students to deep understanding through questioning and clear explanations.
 def clear_chat():
     return []
 
-# ---------- 7. Concept Explainer ----------
+# ---------- 10. Concept Explainer ----------
 def explain_concept(subject, concept):
     if not concept:
         return "Enter a concept to explain!"
@@ -308,7 +638,7 @@ Focus on understanding, not memorization."""
     
     return response
 
-# ---------- 8. Problem Solver ----------
+# ---------- 11. Problem Solver ----------
 def solve_problem(subject, problem, show_steps):
     if not problem.strip():
         return "Enter a problem!"
@@ -334,7 +664,7 @@ Use clear formatting and explain reasoning."""
     
     return response
 
-# ---------- 9. Scenario Analyzer ----------
+# ---------- 12. Scenario Analyzer ----------
 def analyze_scenario(subject, scenario_description, question):
     if not scenario_description.strip():
         return "Describe the scenario!"
@@ -364,7 +694,7 @@ Think critically and justify reasoning."""
     
     return response
 
-# ---------- 10. Practice Questions ----------
+# ---------- 13. Practice Questions ----------
 def generate_question(subject, topic, difficulty):
     if not topic:
         return "Select a topic!", "", ""
@@ -444,30 +774,10 @@ Return JSON:
     except:
         return response
 
-# ---------- 11. Past Papers Browser ----------
+# ---------- 14. Past Papers Browser ----------
 def search_questions_by_topic(subject, topic):
-    if not questions_index:
-        return " No questions yet. Admin needs to upload papers!"
-    
-    matching = [q for q in questions_index 
-                if q['subject'] == subject and 
-                (topic.lower() in q['topic'].lower() or topic.lower() in q['question_text'].lower())]
-    
-    if not matching:
-        return f" No questions found for {topic} in {subject}."
-    
-    result = f"###  Found {len(matching)} question(s) on '{topic}'\n\n"
-    
-    for i, q in enumerate(matching, 1):
-        insert_note = "  **[Requires Insert]**" if q.get('requires_insert') else ""
-        result += f"""**Question {i}** - {q['year']} {q['series']} Paper {q.get('paper_number', '?')}
- **{q['question_number']}** [{q['marks']} marks]{insert_note}
-{q['question_text']}
-
-{'─'*80}
-"""
-    
-    return result
+    """Simple wrapper for backward compatibility"""
+    return search_questions_advanced(subject, topic, filters=None)
 
 def view_papers_student(subject):
     filtered = [p for p in papers_storage if p["subject"] == subject]
@@ -493,15 +803,18 @@ def view_papers_student(subject):
     
     return result
 
-# ---------- 12. Admin Functions ----------
+# ---------- 15. Admin Functions ----------
 def verify_admin_password(password):
     if password == ADMIN_PASSWORD:
         return gr.update(visible=True), gr.update(visible=False), " Access granted!"
     return gr.update(visible=False), gr.update(visible=True), " Incorrect password!"
 
-def upload_paper(title, subject, content, pdf_file, insert_file):
+def upload_paper_enhanced(title, subject, content, pdf_file, insert_file):
+    """
+    Enhanced paper upload with comprehensive question extraction
+    """
     if not all([title, subject, content]):
-        return " Fill all fields!", get_papers_list(), " Waiting..."
+        return "⚠️ Fill all fields!", get_papers_list(), "📊 Waiting..."
     
     paper_id = len(papers_storage) + 1
     
@@ -512,7 +825,7 @@ def upload_paper(title, subject, content, pdf_file, insert_file):
         if pdf_text and not pdf_text.startswith("Error"):
             paper_details = identify_paper_details(pdf_text, pdf_file.name)
             pdf_content_storage[paper_id] = pdf_text
-            content += f"\n[ PDF: {len(pdf_text)} chars]"
+            content += f"\n[📄 PDF: {len(pdf_text)} chars]"
     
     insert_data = None
     insert_type = None
@@ -520,7 +833,7 @@ def upload_paper(title, subject, content, pdf_file, insert_file):
         insert_data, insert_type = process_insert_file(insert_file)
         if insert_data:
             insert_storage[paper_id] = (insert_data, insert_type)
-            content += f"\n[ Insert: {insert_type}]"
+            content += f"\n[🖼️ Insert: {insert_type}]"
     
     papers_storage.append({
         "id": paper_id,
@@ -533,14 +846,30 @@ def upload_paper(title, subject, content, pdf_file, insert_file):
         "uploaded_at": datetime.now().strftime("%Y-%m-%d %H:%M")
     })
     
-    status_msg = " Paper uploaded!"
+    status_msg = "✅ Paper uploaded!"
     if pdf_text and not pdf_text.startswith("Error"):
-        status_msg += "\n Extracting questions..."
-        questions = extract_questions_from_text(pdf_text, paper_id, title, subject, paper_details)
+        status_msg += "\n🔄 Extracting and analyzing questions..."
+        
+        # Use enhanced extraction
+        questions = extract_questions_comprehensive(pdf_text, paper_id, title, subject, paper_details)
         questions_index.extend(questions)
-        status_msg += f"\n Extracted {len(questions)} questions!"
+        
+        status_msg += f"\n✨ Extracted {len(questions)} questions!"
+        status_msg += f"\n📊 Questions analyzed and indexed for search"
+        
+        # Show topic breakdown
+        topic_counts = defaultdict(int)
+        for q in questions:
+            topic_counts[q['topic']] += 1
+        
+        if topic_counts:
+            status_msg += f"\n\n📚 Topics covered:"
+            for topic, count in sorted(topic_counts.items(), key=lambda x: x[1], reverse=True)[:5]:
+                status_msg += f"\n  • {topic}: {count} question(s)"
+    
+    stats = f"📊 Papers: {len(papers_storage)} | Questions: {len(questions_index)}"
     
-    return status_msg, get_papers_list(), f" Papers: {len(papers_storage)} | Questions: {len(questions_index)}"
+    return status_msg, get_papers_list(), stats
 
 def get_papers_list():
     if not papers_storage:
@@ -556,7 +885,7 @@ def get_papers_list():
     
     return "\n".join(result)
 
-# ---------- 13. Gradio UI ----------
+# ---------- 16. Gradio UI ----------
 with gr.Blocks(theme=gr.themes.Soft(), title="IGCSE ICT & PE Platform") as app:
     gr.Markdown("""
 #  IGCSE Learning Platform
@@ -620,24 +949,166 @@ _Deep Understanding Through AI-Powered Learning_
                     
                     gr.Button(" Analyze", variant="primary").click(analyze_scenario, [scen_subj, scen_desc, scen_q], scen_output)
 
-                with gr.Tab(" Past Papers"):
-                    gr.Markdown("### Search Questions by Topic")
+                with gr.Tab("📚 Past Papers"):
+                    gr.Markdown("### 🔍 Advanced Question Search")
+                    gr.Markdown("*Search through extracted questions by topic, year, difficulty, and more*")
                     
                     with gr.Row():
-                        pp_subject = gr.Radio(["ICT", "Physical Education"], label="Subject", value="ICT")
-                        pp_topic = gr.Dropdown(ict_topics, label="Topic")
+                        with gr.Column(scale=2):
+                            pp_subject = gr.Radio(
+                                ["ICT", "Physical Education"], 
+                                label="Subject", 
+                                value="ICT"
+                            )
+                            
+                            pp_search = gr.Textbox(
+                                label="🔎 Search Term",
+                                placeholder="Enter topic, keyword, or concept (e.g., 'RAM', 'aerobic system')",
+                                info="Search in topics, question text, and key concepts"
+                            )
+                        
+                        with gr.Column(scale=3):
+                            with gr.Row():
+                                pp_year = gr.Dropdown(
+                                    choices=["All"] + [str(y) for y in range(2015, 2026)],
+                                    label="📅 Year",
+                                    value="All"
+                                )
+                                pp_series = gr.Dropdown(
+                                    choices=["All", "June", "November", "March"],
+                                    label="📆 Series",
+                                    value="All"
+                                )
+                            
+                            with gr.Row():
+                                pp_difficulty = gr.Dropdown(
+                                    choices=["All", "easy", "medium", "hard"],
+                                    label="🎯 Difficulty",
+                                    value="All"
+                                )
+                                pp_type = gr.Dropdown(
+                                    choices=["All", "knowledge", "application", "analysis", "evaluation"],
+                                    label="📝 Question Type",
+                                    value="All"
+                                )
+                            
+                            with gr.Row():
+                                pp_marks_min = gr.Number(
+                                    label="Min Marks",
+                                    value=0,
+                                    precision=0
+                                )
+                                pp_marks_max = gr.Number(
+                                    label="Max Marks",
+                                    value=20,
+                                    precision=0
+                                )
+                                pp_insert = gr.Checkbox(
+                                    label="🖼️ Requires Insert Only",
+                                    value=False
+                                )
                     
-                    pp_subject.change(update_topics, pp_subject, pp_topic)
+                    with gr.Row():
+                        search_btn = gr.Button("🔍 Search Questions", variant="primary", size="lg")
+                        analytics_btn = gr.Button("📊 Show Analytics", variant="secondary")
                     
-                    search_btn = gr.Button(" Search", variant="primary")
-                    questions_output = gr.Markdown(value="Select a topic and click Search")
+                    questions_output = gr.Markdown(
+                        value="👆 Enter search criteria and click Search",
+                        label="Search Results"
+                    )
                     
-                    search_btn.click(search_questions_by_topic, [pp_subject, pp_topic], questions_output)
+                    # Search function wrapper
+                    def perform_search(subject, search_term, year, series, difficulty, qtype, marks_min, marks_max, requires_insert):
+                        filters = {}
+                        
+                        if year != "All":
+                            filters['year'] = year
+                        if series != "All":
+                            filters['series'] = series
+                        if difficulty != "All":
+                            filters['difficulty'] = difficulty
+                        if qtype != "All":
+                            filters['question_type'] = qtype
+                        if marks_min > 0:
+                            filters['marks_min'] = int(marks_min)
+                        if marks_max < 20:
+                            filters['marks_max'] = int(marks_max)
+                        if requires_insert:
+                            filters['requires_insert'] = True
+                        
+                        return search_questions_advanced(subject, search_term, filters)
+                    
+                    search_btn.click(
+                        perform_search,
+                        [pp_subject, pp_search, pp_year, pp_series, pp_difficulty, pp_type, pp_marks_min, pp_marks_max, pp_insert],
+                        questions_output
+                    )
                     
-                    gr.Markdown("---\n### Browse All Papers")
-                    browse_subject = gr.Radio(["ICT", "Physical Education"], label="Subject", value="ICT")
+                    analytics_btn.click(
+                        analyze_question_bank,
+                        pp_subject,
+                        questions_output
+                    )
+                    
+                    gr.Markdown("---")
+                    gr.Markdown("### 📖 Quick Topic Search")
+                    gr.Markdown("*Click a topic to see all related questions*")
+                    
+                    with gr.Row():
+                        quick_subject = gr.Radio(
+                            ["ICT", "Physical Education"],
+                            label="Subject",
+                            value="ICT"
+                        )
+                        quick_topic = gr.Dropdown(
+                            ict_topics,
+                            label="Topic"
+                        )
+                    
+                    quick_subject.change(
+                        lambda s: gr.Dropdown(choices=ict_topics if s == "ICT" else pe_topics, value=None),
+                        quick_subject,
+                        quick_topic
+                    )
+                    
+                    quick_search_btn = gr.Button("⚡ Quick Search", variant="primary")
+                    quick_output = gr.Markdown()
+                    
+                    def quick_topic_search(subject, topic):
+                        if not topic:
+                            return "⚠️ Please select a topic"
+                        return search_questions_advanced(subject, topic, None)
+                    
+                    quick_search_btn.click(
+                        quick_topic_search,
+                        [quick_subject, quick_topic],
+                        quick_output
+                    )
+                    
+                    gr.Markdown("---")
+                    gr.Markdown("### 📚 Browse All Papers")
+                    
+                    browse_subject = gr.Radio(
+                        ["ICT", "Physical Education"],
+                        label="Subject",
+                        value="ICT"
+                    )
                     papers_display = gr.Markdown()
-                    gr.Button(" Show Papers").click(view_papers_student, browse_subject, papers_display)
+                    
+                    gr.Button("📄 Show All Papers").click(
+                        view_papers_student,
+                        browse_subject,
+                        papers_display
+                    )
+                    
+                    gr.Markdown("""
+---
+**💡 Search Tips:**
+- Use specific keywords for better results (e.g., "binary conversion" instead of "numbers")
+- Filter by difficulty to find practice questions at your level
+- Use "Requires Insert" filter to find questions with diagrams
+- Check analytics to see topic coverage in your question bank
+""")
 
                 with gr.Tab(" Practice"):
                     gr.Markdown("### Generate & Practice Questions")
@@ -685,7 +1156,7 @@ _Deep Understanding Through AI-Powered Learning_
                         gr.Markdown("###  Uploaded Papers")
                         lst = gr.Textbox(lines=26, value=get_papers_list(), interactive=False)
                 
-                up.click(upload_paper, [t, s, c, pdf, insert], [st, lst, stats])
+                up.click(upload_paper_enhanced, [t, s, c, pdf, insert], [st, lst, stats])
             
             login_btn.click(verify_admin_password, [pwd], [admin_section, login_section, login_status])