new features

app.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import json
 from flask import Flask
 from flask_cors import CORS
 from flask_socketio import SocketIO
@@ -41,6 +42,7 @@ def create_app():
     # Register custom Jinja2 filter
     app.jinja_env.filters['humanize'] = humanize_datetime
     app.jinja_env.filters['chr'] = chr
+    app.jinja_env.filters['from_json'] = lambda x: json.loads(x) if x else []
 
     # Configuration
     app.config['SECRET_KEY'] = os.urandom(24)

dashboard.py

@@ -132,18 +132,63 @@ def format_file_size(size_bytes):
 def dashboard():
     # Check if size parameter is passed
     show_size = request.args.get('size', type=int)
+    # Check filter parameter
+    filter_type = request.args.get('filter', 'all')  # 'all', 'standard', 'collections'
 
     conn = get_db_connection()
-    sessions_rows = conn.execute("""
-        SELECT s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type,
-               COUNT(CASE WHEN i.image_type = 'original' THEN 1 END) as page_count,
-               COUNT(CASE WHEN i.image_type = 'cropped' THEN 1 END) as question_count
-        FROM sessions s
-        LEFT JOIN images i ON s.id = i.session_id
-        WHERE s.user_id = ? AND (s.session_type IS NULL OR s.session_type != 'final_pdf')
-        GROUP BY s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type
-        ORDER BY s.created_at DESC
-    """, (current_user.id,)).fetchall()
+
+    # Build the base query
+    if filter_type == 'collections':
+        # Only show neetprep collections
+        sessions_rows = conn.execute("""
+            SELECT s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type,
+                   0 as page_count,
+                   COUNT(nb.id) as question_count
+            FROM sessions s
+            LEFT JOIN neetprep_bookmarks nb ON s.id = nb.session_id
+            WHERE s.user_id = ? AND s.session_type = 'neetprep_collection'
+            GROUP BY s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type
+            ORDER BY s.created_at DESC
+        """, (current_user.id,)).fetchall()
+    elif filter_type == 'standard':
+        # Only show standard sessions (exclude collections and final_pdf)
+        sessions_rows = conn.execute("""
+            SELECT s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type,
+                   COUNT(CASE WHEN i.image_type = 'original' THEN 1 END) as page_count,
+                   COUNT(CASE WHEN i.image_type = 'cropped' THEN 1 END) as question_count
+            FROM sessions s
+            LEFT JOIN images i ON s.id = i.session_id
+            WHERE s.user_id = ? AND (s.session_type IS NULL OR s.session_type NOT IN ('final_pdf', 'neetprep_collection'))
+            GROUP BY s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type
+            ORDER BY s.created_at DESC
+        """, (current_user.id,)).fetchall()
+    else:
+        # Show all (both standard and collections, but not final_pdf)
+        # First get standard sessions
+        standard_sessions = conn.execute("""
+            SELECT s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type,
+                   COUNT(CASE WHEN i.image_type = 'original' THEN 1 END) as page_count,
+                   COUNT(CASE WHEN i.image_type = 'cropped' THEN 1 END) as question_count
+            FROM sessions s
+            LEFT JOIN images i ON s.id = i.session_id
+            WHERE s.user_id = ? AND (s.session_type IS NULL OR s.session_type NOT IN ('final_pdf', 'neetprep_collection'))
+            GROUP BY s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type
+        """, (current_user.id,)).fetchall()
+
+        # Then get neetprep collections
+        collection_sessions = conn.execute("""
+            SELECT s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type,
+                   0 as page_count,
+                   COUNT(nb.id) as question_count
+            FROM sessions s
+            LEFT JOIN neetprep_bookmarks nb ON s.id = nb.session_id
+            WHERE s.user_id = ? AND s.session_type = 'neetprep_collection'
+            GROUP BY s.id, s.created_at, s.original_filename, s.persist, s.name, s.session_type
+        """, (current_user.id,)).fetchall()
+
+        # Combine and sort by created_at
+        all_sessions = list(standard_sessions) + list(collection_sessions)
+        sessions_rows = sorted(all_sessions, key=lambda x: x['created_at'], reverse=True)
 
     sessions = []
     for session in sessions_rows:
@@ -159,7 +204,7 @@ def dashboard():
 
     conn.close()
 
-    return render_template('dashboard.html', sessions=sessions, show_size=bool(show_size))
+    return render_template('dashboard.html', sessions=sessions, show_size=bool(show_size), filter_type=filter_type)
 
 @dashboard_bp.route('/sessions/batch_delete', methods=['POST'])
 @login_required
@@ -174,13 +219,19 @@ def batch_delete_sessions():
         conn = get_db_connection()
         for session_id in session_ids:
             # Security Check: Ensure the session belongs to the current user
-            session_owner = conn.execute('SELECT user_id FROM sessions WHERE id = ?', (session_id,)).fetchone()
-            if not session_owner or session_owner['user_id'] != current_user.id:
+            session_info = conn.execute('SELECT user_id, session_type FROM sessions WHERE id = ?', (session_id,)).fetchone()
+            if not session_info or session_info['user_id'] != current_user.id:
                 # Silently skip or log an error, but don't delete
                 current_app.logger.warning(f"User {current_user.id} attempted to delete unauthorized session {session_id}.")
                 continue
 
-            # Delete associated files
+            # For bookmark collections, only delete bookmarks (not original images)
+            if session_info['session_type'] == 'neetprep_collection':
+                conn.execute('DELETE FROM neetprep_bookmarks WHERE session_id = ? AND user_id = ?', (session_id, current_user.id))
+                conn.execute('DELETE FROM sessions WHERE id = ?', (session_id,))
+                continue
+
+            # For regular sessions, delete associated files
             images_to_delete = conn.execute('SELECT filename, processed_filename FROM images WHERE session_id = ?', (session_id,)).fetchall()
             for img in images_to_delete:
                 if img['filename']:

database.py

@@ -117,6 +117,21 @@ def setup_database():
     );
     """)
 
+    # Create neetprep_bookmarks table for saving questions to collections
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS neetprep_bookmarks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        user_id INTEGER NOT NULL,
+        neetprep_question_id TEXT NOT NULL,
+        session_id TEXT,
+        question_type TEXT DEFAULT 'neetprep',
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (user_id) REFERENCES users (id),
+        FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE,
+        UNIQUE(user_id, neetprep_question_id, session_id, question_type)
+    );
+    """)
+
     # Create subjective_folders table
     cursor.execute("""
     CREATE TABLE IF NOT EXISTS subjective_folders (
@@ -349,6 +364,11 @@ def setup_database():
     except sqlite3.OperationalError:
         cursor.execute("ALTER TABLE users ADD COLUMN classifier_model TEXT DEFAULT 'gemini'")
 
+    try:
+        cursor.execute("SELECT question_type FROM neetprep_bookmarks LIMIT 1")
+    except sqlite3.OperationalError:
+        cursor.execute("ALTER TABLE neetprep_bookmarks ADD COLUMN question_type TEXT DEFAULT 'neetprep'")
+
     conn.commit()
     conn.close()
 

neetprep.py

@@ -308,51 +308,50 @@ def generate_neetprep_pdf():
         data = request.json
     else:
         data = request.form
-    
+
     pdf_type = data.get('type')
     topics_str = data.get('topics')
     topics = json.loads(topics_str) if topics_str and topics_str != '[]' else []
+    source_filter = data.get('source', 'all')  # 'all', 'neetprep', or 'classified'
 
     conn = get_db_connection()
     all_questions = []
-    
-    # Only fetch NeetPrep questions if the feature is enabled for the user
-    if current_user.neetprep_enabled:
+
+    include_neetprep = source_filter in ['all', 'neetprep'] and current_user.neetprep_enabled
+    include_classified = source_filter in ['all', 'classified']
+
+    # Fetch NeetPrep questions if enabled and filter allows
+    if include_neetprep:
         if pdf_type == 'quiz' and topics:
             placeholders = ', '.join('?' for _ in topics)
             neetprep_questions_from_db = conn.execute(f"SELECT * FROM neetprep_questions WHERE topic IN ({placeholders})", topics).fetchall()
             for q in neetprep_questions_from_db:
                 try:
                     html_content = f"""<html><head><meta charset="utf-8"></head><body>{q['question_text']}</body></html>"""
-                    img_path = os.path.join(current_app.config['TEMP_FOLDER'], f"neetprep_{q['id']}.jpg")
+                    img_filename = f"neetprep_{q['id']}.jpg"
+                    img_path = os.path.join(current_app.config['TEMP_FOLDER'], img_filename)
                     imgkit.from_string(html_content, img_path, options={'width': 800})
                     all_questions.append({
-                        'image_path': img_path,
+                        'image_path': f"/tmp/{img_filename}",
                         'details': {'id': q['id'], 'options': json.loads(q['options']), 'correct_answer_index': q['correct_answer_index'], 'user_answer_index': None, 'source': 'neetprep', 'topic': q['topic'], 'subject': q['subject']}
                     })
                 except Exception as e:
                     current_app.logger.error(f"Failed to convert NeetPrep question {q['id']} to image: {e}")
-        
+
         elif pdf_type == 'all':
             neetprep_questions_from_db = conn.execute("SELECT * FROM neetprep_questions").fetchall()
             for q in neetprep_questions_from_db:
                 all_questions.append({"id": q['id'], "question_text": q['question_text'], "options": json.loads(q['options']), "correct_answer_index": q['correct_answer_index'], "user_answer_index": None, "status": "wrong", "source": "neetprep", "custom_fields": {"difficulty": q['level'], "topic": q['topic'], "subject": q['subject']}})
-        
+
         elif pdf_type == 'selected' and topics:
             placeholders = ', '.join('?' for _ in topics)
             neetprep_questions_from_db = conn.execute(f"SELECT * FROM neetprep_questions WHERE topic IN ({placeholders})", topics).fetchall()
             for q in neetprep_questions_from_db:
                 all_questions.append({"id": q['id'], "question_text": q['question_text'], "options": json.loads(q['options']), "correct_answer_index": q['correct_answer_index'], "user_answer_index": None, "status": "wrong", "source": "neetprep", "custom_fields": {"difficulty": q['level'], "topic": q['topic'], "subject": q['subject']}})
 
-    # Always fetch the user's own classified questions if topics are selected or if it's a quiz
-    if topics or pdf_type == 'quiz':
-        # If no topics are selected for a quiz/selection, this should not run or fetch all
-        if not topics:
-             # For a quiz, topics are mandatory. For 'selected', topics are mandatory.
-            if pdf_type in ['quiz', 'selected']:
-                conn.close()
-                return jsonify({'error': 'No topics selected.'}), 400
-        else:
+    # Fetch classified questions if filter allows
+    if include_classified:
+        if topics and pdf_type in ['quiz', 'selected']:
             placeholders = ', '.join('?' for _ in topics)
             classified_questions_from_db = conn.execute(f"""
                 SELECT q.* FROM questions q JOIN sessions s ON q.session_id = s.id
@@ -362,23 +361,29 @@ def generate_neetprep_pdf():
                 image_info = conn.execute("SELECT processed_filename FROM images WHERE id = ?", (q['image_id'],)).fetchone()
                 if image_info and image_info['processed_filename']:
                     if pdf_type == 'quiz':
-                        all_questions.append({'image_path': os.path.join(current_app.config['PROCESSED_FOLDER'], image_info['processed_filename']),'details': {'id': q['id'], 'options': [], 'correct_answer_index': q['actual_solution'], 'user_answer_index': q['marked_solution'], 'source': 'classified', 'topic': q['chapter'], 'subject': q['subject']}})
+                        all_questions.append({
+                            'image_path': f"/processed/{image_info['processed_filename']}",
+                            'details': {'id': q['id'], 'options': [], 'correct_answer_index': q['actual_solution'], 'user_answer_index': q['marked_solution'], 'source': 'classified', 'topic': q['chapter'], 'subject': q['subject']}
+                        })
                     else:
                         all_questions.append({"id": q['id'], "question_text": f"<img src=\"{os.path.join(current_app.config['PROCESSED_FOLDER'], image_info['processed_filename'])}\" />", "options": [], "correct_answer_index": q['actual_solution'], "user_answer_index": q['marked_solution'], "status": q['status'], "source": "classified", "custom_fields": {"subject": q['subject'], "chapter": q['chapter'], "question_number": q['question_number']}})
-    
-    # For 'all' type, also include user's classified questions
-    if pdf_type == 'all':
-        classified_questions_from_db = conn.execute("""
-            SELECT q.* FROM questions q JOIN sessions s ON q.session_id = s.id
-            WHERE s.user_id = ? AND q.subject IS NOT NULL AND q.chapter IS NOT NULL
-        """, (current_user.id,)).fetchall()
-        for q in classified_questions_from_db:
-            image_info = conn.execute("SELECT processed_filename FROM images WHERE id = ?", (q['image_id'],)).fetchone()
-            if image_info and image_info['processed_filename']:
-                all_questions.append({"id": q['id'], "question_text": f"<img src=\"{os.path.join(current_app.config['PROCESSED_FOLDER'], image_info['processed_filename'])}\" />", "options": [], "correct_answer_index": q['actual_solution'], "user_answer_index": q['marked_solution'], "status": q['status'], "source": "classified", "custom_fields": {"subject": q['subject'], "chapter": q['chapter'], "question_number": q['question_number']}})
+
+        elif pdf_type == 'all':
+            classified_questions_from_db = conn.execute("""
+                SELECT q.* FROM questions q JOIN sessions s ON q.session_id = s.id
+                WHERE s.user_id = ? AND q.subject IS NOT NULL AND q.chapter IS NOT NULL
+            """, (current_user.id,)).fetchall()
+            for q in classified_questions_from_db:
+                image_info = conn.execute("SELECT processed_filename FROM images WHERE id = ?", (q['image_id'],)).fetchone()
+                if image_info and image_info['processed_filename']:
+                    all_questions.append({"id": q['id'], "question_text": f"<img src=\"{os.path.join(current_app.config['PROCESSED_FOLDER'], image_info['processed_filename'])}\" />", "options": [], "correct_answer_index": q['actual_solution'], "user_answer_index": q['marked_solution'], "status": q['status'], "source": "classified", "custom_fields": {"subject": q['subject'], "chapter": q['chapter'], "question_number": q['question_number']}})
 
     conn.close()
 
+    # Check if topics are required but not provided
+    if pdf_type in ['quiz', 'selected'] and not topics:
+        return jsonify({'error': 'No topics selected.'}), 400
+
     if not all_questions:
         return jsonify({'error': 'No questions found for the selected criteria.'}), 404
 
@@ -454,6 +459,826 @@ def update_neetprep_question(question_id):
         current_app.logger.error(f"Error updating question {question_id}: {repr(e)}")
         return jsonify({'error': str(e)}), 500
 
+@neetprep_bp.route('/neetprep/get_suggestions/<question_id>', methods=['POST'])
+@login_required
+def get_neetprep_suggestions(question_id):
+    """Get AI classification suggestions for a NeetPrep question using NVIDIA NIM."""
+    import os
+    from nvidia_prompts import BIOLOGY_PROMPT_TEMPLATE, CHEMISTRY_PROMPT_TEMPLATE, PHYSICS_PROMPT_TEMPLATE, MATHEMATICS_PROMPT_TEMPLATE, GENERAL_CLASSIFICATION_PROMPT
+
+    data = request.json or {}
+    subject = data.get('subject')  # Can be None for auto-detection
+
+    conn = get_db_connection()
+    question = conn.execute('SELECT question_text FROM neetprep_questions WHERE id = ?', (question_id,)).fetchone()
+    conn.close()
+
+    if not question:
+        return jsonify({'success': True, 'suggestions': ['Unclassified'], 'subject': 'Biology', 'warning': 'Question not found'})
+
+    # Strip HTML from question text for classification
+    question_text = question['question_text'] or ''
+    if not question_text:
+        return jsonify({'success': True, 'suggestions': ['Unclassified'], 'subject': 'Biology', 'warning': 'No question text'})
+
+    soup = BeautifulSoup(question_text, 'html.parser')
+    plain_text = soup.get_text(strip=True)
+
+    if not plain_text:
+        return jsonify({'success': True, 'suggestions': ['Unclassified'], 'subject': 'Biology', 'warning': 'Empty question text'})
+
+    NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
+    if not NVIDIA_API_KEY:
+        return jsonify({'error': 'NVIDIA_API_KEY not set', 'suggestions': ['Unclassified'], 'subject': 'Biology'}), 200
+
+    # Get the appropriate prompt template
+    def get_nvidia_prompt(subj, input_questions):
+        if not subj or subj.lower() == 'auto':
+            return GENERAL_CLASSIFICATION_PROMPT.format(input_questions=input_questions)
+        if subj.lower() == 'biology': return BIOLOGY_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'chemistry': return CHEMISTRY_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'physics': return PHYSICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'mathematics': return MATHEMATICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        return GENERAL_CLASSIFICATION_PROMPT.format(input_questions=input_questions)
+
+    prompt_content = get_nvidia_prompt(subject, f"1. {plain_text[:500]}")  # Limit text length
+
+    try:
+        res = requests.post(
+            'https://integrate.api.nvidia.com/v1/chat/completions',
+            headers={'Authorization': f'Bearer {NVIDIA_API_KEY}', 'Accept': 'application/json', 'Content-Type': 'application/json'},
+            json={"model": "nvidia/nemotron-3-nano-30b-a3b", "messages": [{"content": prompt_content, "role": "user"}], "temperature": 0.2, "top_p": 1, "max_tokens": 1024, "stream": False},
+            timeout=30
+        )
+        res.raise_for_status()
+        content = res.json()['choices'][0]['message']['content']
+
+        # Parse JSON from response
+        if "```json" in content: content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content: content = content.split("```")[1].split("```")[0].strip()
+
+        result_data = json.loads(content)
+        suggestions = []
+        detected_subject = subject or 'Biology'  # Default
+        other_subjects = []
+
+        if result_data.get('data'):
+            item = result_data['data'][0]
+            # Extract detected subject from AI response
+            detected_subject = item.get('subject', subject) or 'Biology'
+            # Extract other possible subjects
+            other_subjects = item.get('other_possible_subjects', [])
+            if isinstance(other_subjects, str):
+                other_subjects = [other_subjects]
+
+            primary = item.get('chapter_title')
+            if primary and primary != 'Unclassified':
+                suggestions.append(primary)
+            others = item.get('other_possible_chapters', [])
+            if isinstance(others, list):
+                suggestions.extend([c for c in others if c and c != 'Unclassified'])
+
+        # Always return at least one suggestion
+        if not suggestions:
+            suggestions = ['Unclassified']
+
+        return jsonify({
+            'success': True,
+            'suggestions': suggestions[:5],
+            'subject': detected_subject,
+            'other_possible_subjects': other_subjects
+        })
+
+    except Exception as e:
+        current_app.logger.error(f"Error getting suggestions for {question_id}: {repr(e)}")
+        return jsonify({
+            'success': True,
+            'suggestions': ['Unclassified'],
+            'subject': subject or 'Biology',
+            'warning': str(e)
+        })
+
+@neetprep_bp.route('/neetprep/get_suggestions_batch', methods=['POST'])
+@login_required
+def get_neetprep_suggestions_batch():
+    """Batch endpoint for getting topic suggestions for multiple NeetPrep questions at once.
+    Requires a subject to be specified. Processes up to 8 questions in a single API call."""
+    import os
+    from nvidia_prompts import BIOLOGY_PROMPT_TEMPLATE, CHEMISTRY_PROMPT_TEMPLATE, PHYSICS_PROMPT_TEMPLATE, MATHEMATICS_PROMPT_TEMPLATE
+
+    data = request.json
+    question_ids = data.get('question_ids', [])
+    subject = data.get('subject')
+
+    current_app.logger.info(f"[BATCH-NEETPREP] Received request for {len(question_ids)} questions, subject={subject}")
+
+    if not question_ids:
+        return jsonify({'error': 'No question_ids provided'}), 400
+    if not subject or subject.lower() == 'auto':
+        return jsonify({'error': 'Subject must be specified for batch requests'}), 400
+    if len(question_ids) > 8:
+        return jsonify({'error': 'Maximum 8 questions per batch'}), 400
+
+    NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
+    if not NVIDIA_API_KEY:
+        return jsonify({'error': 'NVIDIA_API_KEY not set'}), 500
+
+    def get_nvidia_prompt(subj, input_questions):
+        if subj.lower() == 'biology': return BIOLOGY_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'chemistry': return CHEMISTRY_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'physics': return PHYSICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        if subj.lower() == 'mathematics': return MATHEMATICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
+        return BIOLOGY_PROMPT_TEMPLATE.format(input_questions=input_questions)
+
+    try:
+        conn = get_db_connection()
+        questions_data = []
+
+        for idx, qid in enumerate(question_ids):
+            question = conn.execute('SELECT question_text FROM neetprep_questions WHERE id = ?', (qid,)).fetchone()
+            if question and question['question_text']:
+                soup = BeautifulSoup(question['question_text'], 'html.parser')
+                plain_text = soup.get_text(strip=True)
+                if plain_text:
+                    questions_data.append({'id': qid, 'index': idx + 1, 'text': plain_text[:500]})
+                    current_app.logger.debug(f"[BATCH-NEETPREP] Question {qid}: got text ({len(plain_text)} chars)")
+                else:
+                    current_app.logger.warning(f"[BATCH-NEETPREP] Question {qid}: empty plain text after HTML strip")
+            else:
+                current_app.logger.warning(f"[BATCH-NEETPREP] Question {qid}: not found or no question_text")
+
+        conn.close()
+
+        current_app.logger.info(f"[BATCH-NEETPREP] Got question text for {len(questions_data)}/{len(question_ids)} questions")
+
+        if not questions_data:
+            return jsonify({'error': 'Could not obtain question text for any questions'}), 400
+
+        # Build multi-question prompt
+        input_questions = "\n".join(f"{q['index']}. {q['text']}" for q in questions_data)
+        prompt_content = get_nvidia_prompt(subject, input_questions)
+
+        current_app.logger.info(f"[BATCH-NEETPREP] Sending {len(questions_data)} questions to NVIDIA API")
+        current_app.logger.debug(f"[BATCH-NEETPREP] Prompt preview: {input_questions[:500]}...")
+
+        # Make single API call for all questions
+        res = requests.post(
+            'https://integrate.api.nvidia.com/v1/chat/completions',
+            headers={'Authorization': f'Bearer {NVIDIA_API_KEY}', 'Accept': 'application/json', 'Content-Type': 'application/json'},
+            json={"model": "nvidia/nemotron-3-nano-30b-a3b", "messages": [{"content": prompt_content, "role": "user"}], "temperature": 0.2, "top_p": 1, "max_tokens": 4096, "stream": False},
+            timeout=60
+        )
+        res.raise_for_status()
+        content = res.json()['choices'][0]['message']['content']
+
+        current_app.logger.info(f"[BATCH-NEETPREP] NVIDIA API response length: {len(content)} chars")
+        current_app.logger.debug(f"[BATCH-NEETPREP] Raw response: {content[:1000]}...")
+
+        # Parse JSON from response
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].split("```")[0].strip()
+        parsed_data = json.loads(content)
+
+        current_app.logger.info(f"[BATCH-NEETPREP] Parsed data has {len(parsed_data.get('data', []))} items")
+
+        # Build results for each question
+        results = {}
+        fallback_topics = {
+            'biology': ['Cell: The Unit of Life', 'Biomolecules', 'Human Reproduction'],
+            'chemistry': ['Organic Chemistry – Some Basic Principles and Techniques (GOC)', 'Chemical Bonding and Molecular Structure'],
+            'physics': ['Laws of Motion', 'Work, Energy and Power', 'Current Electricity'],
+            'mathematics': ['Calculus', 'Algebra', 'Coordinate Geometry']
+        }
+
+        if parsed_data.get('data'):
+            data_items = parsed_data['data']
+            current_app.logger.info(f"[BATCH-NEETPREP] AI returned {len(data_items)} items, we have {len(questions_data)} questions")
+
+            # Helper to extract suggestions from item (handles both old and new format)
+            def extract_suggestions(item):
+                suggestions = []
+                # Try new compact format first, then old format
+                primary = item.get('ch') or item.get('chapter_title')
+                if primary and primary != 'Unclassified':
+                    suggestions.append(primary)
+                # Handle alternatives - new format uses 'alt' (string), old uses 'other_possible_chapters' (list)
+                alt = item.get('alt')
+                if alt and alt != 'Unclassified' and alt != 'null':
+                    suggestions.append(alt)
+                others = item.get('other_possible_chapters')
+                if isinstance(others, list):
+                    suggestions.extend([c for c in others if c and c != 'Unclassified'])
+                return suggestions
+
+            # Helper to get index from item
+            def get_item_index(item):
+                return item.get('i') or item.get('index') or 0
+
+            # Try to match by index first, then fall back to order-based matching
+            matched_by_index = 0
+            for item in data_items:
+                item_index = get_item_index(item)
+                current_app.logger.debug(f"[BATCH-NEETPREP] Processing item with index={item_index}: {item}")
+                matching_q = next((q for q in questions_data if q['index'] == item_index), None)
+                if matching_q:
+                    matched_by_index += 1
+                    suggestions = extract_suggestions(item)
+
+                    if not suggestions:
+                        suggestions = fallback_topics.get(subject.lower(), ['Unclassified'])
+
+                    results[matching_q['id']] = {
+                        'success': True,
+                        'suggestions': suggestions[:5],
+                        'subject': subject,
+                        'other_possible_subjects': []
+                    }
+                    current_app.logger.info(f"[BATCH-NEETPREP] Question {matching_q['id']}: matched by index, suggestions={suggestions[:3]}")
+
+            # If index matching failed, try order-based matching
+            if matched_by_index == 0 and len(data_items) > 0:
+                current_app.logger.warning(f"[BATCH-NEETPREP] Index matching failed, trying order-based matching")
+                for i, item in enumerate(data_items):
+                    if i < len(questions_data):
+                        q = questions_data[i]
+                        if q['id'] not in results:
+                            suggestions = extract_suggestions(item)
+
+                            if not suggestions:
+                                suggestions = fallback_topics.get(subject.lower(), ['Unclassified'])
+
+                            results[q['id']] = {
+                                'success': True,
+                                'suggestions': suggestions[:5],
+                                'subject': subject,
+                                'other_possible_subjects': []
+                            }
+                            current_app.logger.info(f"[BATCH-NEETPREP] Question {q['id']}: matched by order, suggestions={suggestions[:3]}")
+
+        # Fill in any missing results
+        for q in questions_data:
+            if q['id'] not in results:
+                current_app.logger.warning(f"[BATCH-NEETPREP] Question {q['id']}: using fallback (no match in API response)")
+                results[q['id']] = {
+                    'success': True,
+                    'suggestions': fallback_topics.get(subject.lower(), ['Unclassified']),
+                    'subject': subject,
+                    'other_possible_subjects': []
+                }
+
+        current_app.logger.info(f"[BATCH-NEETPREP] Returning results for {len(results)} questions")
+        return jsonify({'success': True, 'results': results})
+
+    except Exception as e:
+        current_app.logger.error(f"Error in batch suggestions: {repr(e)}")
+        fallback_result = {
+            'success': True,
+            'suggestions': ['Unclassified'],
+            'subject': subject,
+            'other_possible_subjects': []
+        }
+        return jsonify({
+            'success': False,
+            'error': str(e),
+            'results': {qid: fallback_result for qid in question_ids}
+        })
+
+# ============== BOOKMARK FEATURE ==============
+
+@neetprep_bp.route('/neetprep/collections')
+@login_required
+def get_bookmark_collections():
+    """Get all bookmark collections (sessions of type neetprep_collection) for the user."""
+    conn = get_db_connection()
+    collections = conn.execute("""
+        SELECT s.id, s.name, s.subject, s.tags, s.notes, s.created_at,
+               COUNT(b.id) as question_count
+        FROM sessions s
+        LEFT JOIN neetprep_bookmarks b ON s.id = b.session_id AND b.user_id = ?
+        WHERE s.user_id = ? AND s.session_type = 'neetprep_collection'
+        GROUP BY s.id
+        ORDER BY s.created_at DESC
+    """, (current_user.id, current_user.id)).fetchall()
+    conn.close()
+    return jsonify({'success': True, 'collections': [dict(c) for c in collections]})
+
+@neetprep_bp.route('/neetprep/collections/create', methods=['POST'])
+@login_required
+def create_bookmark_collection():
+    """Create a new bookmark collection (session)."""
+    import uuid
+    data = request.json
+    name = data.get('name', 'New Collection')
+    subject = data.get('subject', '')
+    tags = data.get('tags', '')
+    notes = data.get('notes', '')
+
+    session_id = str(uuid.uuid4())
+    conn = get_db_connection()
+    conn.execute("""
+        INSERT INTO sessions (id, name, subject, tags, notes, user_id, session_type, persist)
+        VALUES (?, ?, ?, ?, ?, ?, 'neetprep_collection', 1)
+    """, (session_id, name, subject, tags, notes, current_user.id))
+    conn.commit()
+    conn.close()
+
+    return jsonify({'success': True, 'session_id': session_id, 'name': name})
+
+@neetprep_bp.route('/neetprep/collections/<session_id>', methods=['DELETE'])
+@login_required
+def delete_bookmark_collection(session_id):
+    """Delete a bookmark collection and all its bookmarks."""
+    conn = get_db_connection()
+    # Verify ownership
+    session = conn.execute('SELECT id FROM sessions WHERE id = ? AND user_id = ?', (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    conn.execute('DELETE FROM neetprep_bookmarks WHERE session_id = ? AND user_id = ?', (session_id, current_user.id))
+    conn.execute('DELETE FROM sessions WHERE id = ?', (session_id,))
+    conn.commit()
+    conn.close()
+
+    return jsonify({'success': True})
+
+@neetprep_bp.route('/neetprep/collections/<session_id>/update', methods=['POST'])
+@login_required
+def update_bookmark_collection(session_id):
+    """Update collection metadata."""
+    data = request.json
+    conn = get_db_connection()
+
+    # Verify ownership
+    session = conn.execute('SELECT id FROM sessions WHERE id = ? AND user_id = ?', (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    updates = []
+    params = []
+    if 'name' in data:
+        updates.append('name = ?')
+        params.append(data['name'])
+    if 'subject' in data:
+        updates.append('subject = ?')
+        params.append(data['subject'])
+    if 'tags' in data:
+        updates.append('tags = ?')
+        params.append(data['tags'])
+    if 'notes' in data:
+        updates.append('notes = ?')
+        params.append(data['notes'])
+
+    if updates:
+        params.append(session_id)
+        conn.execute(f"UPDATE sessions SET {', '.join(updates)} WHERE id = ?", params)
+        conn.commit()
+
+    conn.close()
+    return jsonify({'success': True})
+
+@neetprep_bp.route('/neetprep/bookmark', methods=['POST'])
+@login_required
+def add_bookmark():
+    """Add a question to a collection."""
+    data = request.json
+    question_id = data.get('question_id')
+    session_id = data.get('session_id')
+    question_type = data.get('question_type', 'neetprep')  # 'neetprep' or 'classified'
+
+    if not question_id or not session_id:
+        return jsonify({'error': 'question_id and session_id are required'}), 400
+
+    conn = get_db_connection()
+
+    # Verify session ownership
+    session = conn.execute('SELECT id FROM sessions WHERE id = ? AND user_id = ?', (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    # Check if already bookmarked
+    existing = conn.execute(
+        'SELECT id FROM neetprep_bookmarks WHERE user_id = ? AND neetprep_question_id = ? AND session_id = ? AND question_type = ?',
+        (current_user.id, str(question_id), session_id, question_type)
+    ).fetchone()
+
+    if existing:
+        conn.close()
+        return jsonify({'success': True, 'message': 'Already bookmarked'})
+
+    conn.execute(
+        'INSERT INTO neetprep_bookmarks (user_id, neetprep_question_id, session_id, question_type) VALUES (?, ?, ?, ?)',
+        (current_user.id, str(question_id), session_id, question_type)
+    )
+    conn.commit()
+    conn.close()
+
+    return jsonify({'success': True})
+
+@neetprep_bp.route('/neetprep/bookmark', methods=['DELETE'])
+@login_required
+def remove_bookmark():
+    """Remove a question from a collection."""
+    data = request.json
+    question_id = data.get('question_id')
+    session_id = data.get('session_id')
+    question_type = data.get('question_type', 'neetprep')
+
+    if not question_id or not session_id:
+        return jsonify({'error': 'question_id and session_id are required'}), 400
+
+    conn = get_db_connection()
+
+    # Verify session ownership
+    session = conn.execute('SELECT id FROM sessions WHERE id = ? AND user_id = ?', (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    conn.execute(
+        'DELETE FROM neetprep_bookmarks WHERE user_id = ? AND neetprep_question_id = ? AND session_id = ? AND question_type = ?',
+        (current_user.id, str(question_id), session_id, question_type)
+    )
+    conn.commit()
+    conn.close()
+
+    return jsonify({'success': True})
+
+@neetprep_bp.route('/neetprep/bookmark/bulk', methods=['POST'])
+@login_required
+def bulk_bookmark():
+    """Add multiple neetprep questions to a collection at once."""
+    data = request.json
+    question_ids = data.get('question_ids', [])
+    session_id = data.get('session_id')
+
+    if not question_ids or not session_id:
+        return jsonify({'error': 'question_ids and session_id are required'}), 400
+
+    conn = get_db_connection()
+
+    # Verify session ownership
+    session = conn.execute('SELECT id FROM sessions WHERE id = ? AND user_id = ?', (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    added_count = 0
+    for qid in question_ids:
+        existing = conn.execute(
+            'SELECT id FROM neetprep_bookmarks WHERE user_id = ? AND neetprep_question_id = ? AND session_id = ?',
+            (current_user.id, qid, session_id)
+        ).fetchone()
+
+        if not existing:
+            conn.execute(
+                'INSERT INTO neetprep_bookmarks (user_id, neetprep_question_id, session_id) VALUES (?, ?, ?)',
+                (current_user.id, qid, session_id)
+            )
+            added_count += 1
+
+    conn.commit()
+    conn.close()
+
+    return jsonify({'success': True, 'added_count': added_count})
+
+@neetprep_bp.route('/neetprep/collections/<session_id>/questions')
+@login_required
+def get_collection_questions(session_id):
+    """Get all questions in a bookmark collection."""
+    conn = get_db_connection()
+
+    # Verify ownership
+    session = conn.execute('SELECT id, name, subject, tags, notes FROM sessions WHERE id = ? AND user_id = ?',
+                          (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    questions = conn.execute("""
+        SELECT nq.id, nq.question_text, nq.options, nq.correct_answer_index,
+               nq.level, nq.topic, nq.subject, b.created_at as bookmarked_at
+        FROM neetprep_bookmarks b
+        JOIN neetprep_questions nq ON b.neetprep_question_id = nq.id
+        WHERE b.session_id = ? AND b.user_id = ?
+        ORDER BY b.created_at DESC
+    """, (session_id, current_user.id)).fetchall()
+
+    conn.close()
+
+    return jsonify({
+        'success': True,
+        'collection': dict(session),
+        'questions': [dict(q) for q in questions]
+    })
+
+@neetprep_bp.route('/neetprep/collections/<session_id>/view')
+@login_required
+def view_collection(session_id):
+    """View a bookmark collection with its questions."""
+    conn = get_db_connection()
+
+    # Verify ownership
+    session = conn.execute('SELECT id, name, subject, tags, notes, created_at FROM sessions WHERE id = ? AND user_id = ?',
+                          (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        from flask import redirect, flash
+        flash('Collection not found', 'danger')
+        return redirect(url_for('dashboard.dashboard', filter='collections'))
+
+    # Fetch neetprep questions
+    neetprep_questions = conn.execute("""
+        SELECT nq.id, nq.question_text, nq.options, nq.correct_answer_index,
+               nq.level, nq.topic, nq.subject, b.created_at as bookmarked_at, 'neetprep' as question_type
+        FROM neetprep_bookmarks b
+        JOIN neetprep_questions nq ON b.neetprep_question_id = nq.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'neetprep'
+        ORDER BY nq.topic, b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    # Fetch classified questions
+    classified_questions = conn.execute("""
+        SELECT q.id, q.question_text, NULL as options, q.actual_solution as correct_answer_index,
+               NULL as level, q.chapter as topic, q.subject, b.created_at as bookmarked_at, 'classified' as question_type,
+               i.processed_filename as image_filename, q.question_number
+        FROM neetprep_bookmarks b
+        JOIN questions q ON CAST(b.neetprep_question_id AS INTEGER) = q.id
+        LEFT JOIN images i ON q.image_id = i.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'classified'
+        ORDER BY q.chapter, b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    conn.close()
+
+    # Combine all questions
+    all_questions = []
+    for q in neetprep_questions:
+        qd = dict(q)
+        qd['image_filename'] = None
+        all_questions.append(qd)
+    for q in classified_questions:
+        all_questions.append(dict(q))
+
+    # Group questions by topic
+    topics = {}
+    for q in all_questions:
+        topic = q['topic'] or 'Unclassified'
+        if topic not in topics:
+            topics[topic] = []
+        topics[topic].append(q)
+
+    return render_template('collection_view.html',
+                          collection=dict(session),
+                          questions=all_questions,
+                          topics=topics,
+                          question_count=len(all_questions))
+
+@neetprep_bp.route('/neetprep/question/<question_id>/collections')
+@login_required
+def get_question_collections(question_id):
+    """Get which collections a question is bookmarked in."""
+    conn = get_db_connection()
+
+    collections = conn.execute("""
+        SELECT s.id, s.name
+        FROM neetprep_bookmarks b
+        JOIN sessions s ON b.session_id = s.id
+        WHERE b.neetprep_question_id = ? AND b.user_id = ?
+    """, (question_id, current_user.id)).fetchall()
+
+    conn.close()
+
+    return jsonify({
+        'success': True,
+        'collections': [dict(c) for c in collections]
+    })
+
+@neetprep_bp.route('/neetprep/bookmarks/batch', methods=['POST'])
+@login_required
+def get_batch_bookmark_statuses():
+    """Get bookmark statuses for multiple questions at once."""
+    data = request.get_json()
+    question_ids = data.get('question_ids', [])
+
+    if not question_ids:
+        return jsonify({'success': True, 'bookmarks': {}})
+
+    conn = get_db_connection()
+
+    # Build query for all question IDs
+    placeholders = ','.join(['?' for _ in question_ids])
+    query = f"""
+        SELECT neetprep_question_id, session_id
+        FROM neetprep_bookmarks
+        WHERE neetprep_question_id IN ({placeholders}) AND user_id = ?
+    """
+
+    bookmarks = conn.execute(query, question_ids + [current_user.id]).fetchall()
+    conn.close()
+
+    # Group by question_id
+    result = {}
+    for b in bookmarks:
+        qid = str(b['neetprep_question_id'])
+        if qid not in result:
+            result[qid] = []
+        result[qid].append(b['session_id'])
+
+    return jsonify({
+        'success': True,
+        'bookmarks': result
+    })
+
+@neetprep_bp.route('/neetprep/collections/<session_id>/quiz')
+@login_required
+def collection_quiz(session_id):
+    """Start a quiz from a bookmark collection."""
+    conn = get_db_connection()
+
+    # Verify ownership
+    session = conn.execute('SELECT id, name FROM sessions WHERE id = ? AND user_id = ?',
+                          (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        from flask import redirect, flash
+        flash('Collection not found', 'danger')
+        return redirect(url_for('dashboard.dashboard', filter='collections'))
+
+    all_questions = []
+
+    # Get neetprep bookmarked questions
+    neetprep_questions = conn.execute("""
+        SELECT nq.id, nq.question_text, nq.options, nq.correct_answer_index,
+               nq.level, nq.topic, nq.subject
+        FROM neetprep_bookmarks b
+        JOIN neetprep_questions nq ON b.neetprep_question_id = nq.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'neetprep'
+        ORDER BY b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    for q in neetprep_questions:
+        try:
+            html_content = f"""<html><head><meta charset="utf-8"></head><body>{q['question_text']}</body></html>"""
+            img_filename = f"neetprep_{q['id']}.jpg"
+            img_path = os.path.join(current_app.config['TEMP_FOLDER'], img_filename)
+            imgkit.from_string(html_content, img_path, options={'width': 800})
+            all_questions.append({
+                'image_path': f"/tmp/{img_filename}",
+                'details': {
+                    'id': q['id'],
+                    'options': json.loads(q['options']) if q['options'] else [],
+                    'correct_answer_index': q['correct_answer_index'],
+                    'user_answer_index': None,
+                    'source': 'neetprep',
+                    'topic': q['topic'],
+                    'subject': q['subject']
+                }
+            })
+        except Exception as e:
+            current_app.logger.error(f"Failed to convert question {q['id']} to image: {e}")
+
+    # Get classified bookmarked questions
+    classified_questions = conn.execute("""
+        SELECT q.id, q.actual_solution as correct_answer_index, q.marked_solution as user_answer_index,
+               q.chapter as topic, q.subject, i.processed_filename
+        FROM neetprep_bookmarks b
+        JOIN questions q ON CAST(b.neetprep_question_id AS INTEGER) = q.id
+        LEFT JOIN images i ON q.image_id = i.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'classified'
+        ORDER BY b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    for q in classified_questions:
+        if q['processed_filename']:
+            all_questions.append({
+                'image_path': f"/processed/{q['processed_filename']}",
+                'details': {
+                    'id': q['id'],
+                    'options': [],
+                    'correct_answer_index': q['correct_answer_index'],
+                    'user_answer_index': q['user_answer_index'],
+                    'source': 'classified',
+                    'topic': q['topic'],
+                    'subject': q['subject']
+                }
+            })
+
+    conn.close()
+
+    if not all_questions:
+        from flask import redirect, flash
+        flash('No questions in this collection', 'warning')
+        return redirect(url_for('neetprep_bp.view_collection', session_id=session_id))
+
+    return render_template('quiz_v2.html', questions=all_questions)
+
+@neetprep_bp.route('/neetprep/collections/<session_id>/generate', methods=['POST'])
+@login_required
+def generate_collection_pdf(session_id):
+    """Generate a PDF from a bookmark collection."""
+    conn = get_db_connection()
+
+    # Verify ownership
+    session = conn.execute('SELECT id, name, subject FROM sessions WHERE id = ? AND user_id = ?',
+                          (session_id, current_user.id)).fetchone()
+    if not session:
+        conn.close()
+        return jsonify({'error': 'Collection not found'}), 404
+
+    # Get neetprep bookmarked questions
+    neetprep_questions = conn.execute("""
+        SELECT nq.id, nq.question_text, nq.options, nq.correct_answer_index,
+               nq.level, nq.topic, nq.subject
+        FROM neetprep_bookmarks b
+        JOIN neetprep_questions nq ON b.neetprep_question_id = nq.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'neetprep'
+        ORDER BY nq.topic, b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    # Get classified bookmarked questions
+    classified_questions = conn.execute("""
+        SELECT q.id, q.question_text, q.actual_solution as correct_answer_index,
+               q.chapter as topic, q.subject, i.processed_filename
+        FROM neetprep_bookmarks b
+        JOIN questions q ON CAST(b.neetprep_question_id AS INTEGER) = q.id
+        LEFT JOIN images i ON q.image_id = i.id
+        WHERE b.session_id = ? AND b.user_id = ? AND b.question_type = 'classified'
+        ORDER BY q.chapter, b.created_at
+    """, (session_id, current_user.id)).fetchall()
+
+    conn.close()
+
+    if not neetprep_questions and not classified_questions:
+        return jsonify({'error': 'No questions in this collection'}), 400
+
+    data = request.json or {}
+    all_questions = []
+
+    for q in neetprep_questions:
+        all_questions.append({
+            "id": q['id'],
+            "question_text": q['question_text'],
+            "options": json.loads(q['options']) if q['options'] else [],
+            "correct_answer_index": q['correct_answer_index'],
+            "user_answer_index": None,
+            "status": "wrong",
+            "source": "neetprep",
+            "custom_fields": {
+                "difficulty": q['level'],
+                "topic": q['topic'],
+                "subject": q['subject']
+            }
+        })
+
+    for q in classified_questions:
+        if q['processed_filename']:
+            # Use absolute path for PDF generation
+            abs_img_path = os.path.abspath(os.path.join(current_app.config['PROCESSED_FOLDER'], q['processed_filename']))
+            all_questions.append({
+                "id": q['id'],
+                "question_text": f"<img src=\"{abs_img_path}\" style=\"max-width:100%;\" />",
+                "options": [],
+                "correct_answer_index": q['correct_answer_index'],
+                "user_answer_index": None,
+                "status": "wrong",
+                "source": "classified",
+                "custom_fields": {
+                    "topic": q['topic'],
+                    "subject": q['subject']
+                }
+            })
+
+    topics = list(set(q['custom_fields']['topic'] for q in all_questions if q['custom_fields'].get('topic')))
+
+    final_json_output = {
+        "version": "2.1",
+        "test_name": session['name'] or "Bookmark Collection",
+        "config": {"font_size": 22, "auto_generate_pdf": False, "layout": data.get('layout', {})},
+        "metadata": {"source_book": "NeetPrep Collection", "tags": ", ".join(topics)},
+        "questions": all_questions,
+        "view": True
+    }
+
+    try:
+        result, status_code = _process_json_and_generate_pdf(final_json_output, current_user.id)
+        if status_code != 200:
+            return jsonify(result), status_code
+
+        if result.get('success'):
+            return jsonify({'success': True, 'pdf_url': result.get('view_url')})
+        else:
+            return jsonify({'error': result.get('error', 'Failed to generate PDF')}), 500
+    except Exception as e:
+        current_app.logger.error(f"Failed to generate collection PDF: {repr(e)}")
+        return jsonify({'error': str(e)}), 500
+
+# ============== END BOOKMARK FEATURE ==============
+
 def run_hardcoded_query(query_template, **kwargs):
     """Helper function to run a GraphQL query."""
     final_query = query_template.format(**kwargs)

nvidia_prompts.py

@@ -43,8 +43,34 @@ BIOLOGY_PROMPT_TEMPLATE = """**System Role:** You are a specialized Biology ques
 
 1. **Scope**: Analyze the input question. If the question is NOT related to Biology, mark the chapter as 'Unclassified'.
 2. **Mapping**: Identify the single most relevant chapter from the list above.
-3. **Ambiguity**: If other chapters are also plausible, list up to 2 alternatives in 'other_possible_chapters'.
-4. **Multi-Chapter**: If a question explicitly spans 2 distinct chapters, include the primary one in 'chapter_title' and the secondary in 'other_possible_chapters'.
+3. **Ambiguity**: If another chapter is also plausible, include it in 'alt' (max 1 alternative).
+
+**Output JSON Schema (keep response compact):**
+
+```json
+{{"data": [{{"i": <question number>, "ch": "<chapter title>", "alt": "<alternative or null>", "c": <0.0-1.0>}}]}}
+```
+
+**Input Questions:**
+{input_questions}
+"""
+
+# General prompt that detects subject AND chapter
+GENERAL_CLASSIFICATION_PROMPT = """**System Role:** You are an expert question classifier for NEET/JEE exams. Your task is to:
+1. First identify the SUBJECT (Biology, Chemistry, Physics, or Mathematics)
+2. Then map the question to its corresponding NCERT chapter
+
+**Subject Detection:**
+- Biology: Questions about living organisms, cells, genetics, ecology, human body systems, plants, animals, evolution, biotechnology
+- Chemistry: Questions about atoms, molecules, chemical reactions, organic/inorganic compounds, thermodynamics, electrochemistry, periodic table
+- Physics: Questions about motion, forces, energy, waves, electricity, magnetism, optics, modern physics, thermodynamics
+- Mathematics: Questions about algebra, calculus, geometry, trigonometry, probability, statistics, matrices, vectors
+
+**Classification Guidelines:**
+1. First determine the subject based on the question content
+2. Then identify the most relevant NCERT chapter for that subject
+3. If ambiguous, list alternatives in 'other_possible_chapters'
+4. Include 'other_possible_subjects' if the question could belong to multiple subjects
 
 **Output JSON Schema:**
 
@@ -52,17 +78,16 @@ BIOLOGY_PROMPT_TEMPLATE = """**System Role:** You are a specialized Biology ques
 {{
   "data": [
     {{
-      "index": <integer matching question number>,
-      "subject": "Biology",
-      "chapter_index": <chapter number or 0>,
-      "chapter_title": "<exact chapter title from list or 'Unclassified'>",
+      "index": 1,
+      "subject": "<Biology|Chemistry|Physics|Mathematics>",
+      "other_possible_subjects": ["<alternative subject if applicable>"],
+      "chapter_title": "<most relevant chapter title>",
       "other_possible_chapters": ["<alternative chapter 1>", "<alternative chapter 2>"],
       "confidence": <0.0 to 1.0>
     }}
   ],
   "success": [true]
 }}
-
 ```
 
 **Input Questions:**
@@ -114,26 +139,12 @@ syllabus.
 
 1. **Scope**: Analyze the input question. If the question is NOT related to Chemistry, mark the chapter as 'Unclassified'.
 2. **Mapping**: Identify the single most relevant chapter from the list above.
-3. **Ambiguity**: If other chapters are also plausible, list up to 2 alternatives in 'other_possible_chapters'.
-4. **Multi-Chapter**: If a question explicitly spans 2 distinct chapters, include the primary one in 'chapter_title' and the secondary in 'other_possible_chapters'.
+3. **Ambiguity**: If another chapter is also plausible, include it in 'alt' (max 1 alternative).
 
-**Output JSON Schema:**
+**Output JSON Schema (keep response compact):**
 
 ```json
-{{
-  "data": [
-    {{
-      "index": <integer matching question number>,
-      "subject": "Chemistry",
-      "chapter_index": <chapter number or 0>,
-      "chapter_title": "<exact chapter title from list or 'Unclassified'>",
-      "other_possible_chapters": ["<alternative chapter 1>", "<alternative chapter 2>"],
-      "confidence": <0.0 to 1.0>
-    }}
-  ],
-  "success": [true]
-}}
-
+{{"data": [{{"i": <question number>, "ch": "<chapter title>", "alt": "<alternative or null>", "c": <0.0-1.0>}}]}}
 ```
 
 **Input Questions:**
@@ -183,26 +194,12 @@ PHYSICS_PROMPT_TEMPLATE = """**System Role:** You are a specialized Physics ques
 
 1. **Scope**: Analyze the input question. If the question is NOT related to Physics, mark the chapter as 'Unclassified'.
 2. **Mapping**: Identify the single most relevant chapter from the list above.
-3. **Ambiguity**: If other chapters are also plausible, list up to 2 alternatives in 'other_possible_chapters'.
-4. **Multi-Chapter**: If a question explicitly spans 2 distinct chapters, include the primary one in 'chapter_title' and the secondary in 'other_possible_chapters'.
+3. **Ambiguity**: If another chapter is also plausible, include it in 'alt' (max 1 alternative).
 
-**Output JSON Schema:**
+**Output JSON Schema (keep response compact):**
 
 ```json
-{{
-  "data": [
-    {{
-      "index": <integer matching question number>,
-      "subject": "Physics",
-      "chapter_index": <chapter number or 0>,
-      "chapter_title": "<exact chapter title from list or 'Unclassified'>",
-      "other_possible_chapters": ["<alternative chapter 1>", "<alternative chapter 2>"],
-      "confidence": <0.0 to 1.0>
-    }}
-  ],
-  "success": [true]
-}}
-
+{{"data": [{{"i": <question number>, "ch": "<chapter title>", "alt": "<alternative or null>", "c": <0.0-1.0>}}]}}
 ```
 
 **Input Questions:**
@@ -253,26 +250,12 @@ syllabus.
 
 1. **Scope**: Analyze the input question. If the question is NOT related to Mathematics, mark the chapter as 'Unclassified'.
 2. **Mapping**: Identify the single most relevant chapter from the list above.
-3. **Ambiguity**: If other chapters are also plausible, list up to 2 alternatives in 'other_possible_chapters'.
-4. **Multi-Chapter**: If a question explicitly spans 2 distinct chapters, include the primary one in 'chapter_title' and the secondary in 'other_possible_chapters'.
+3. **Ambiguity**: If another chapter is also plausible, include it in 'alt' (max 1 alternative).
 
-**Output JSON Schema:**
+**Output JSON Schema (keep response compact):**
 
 ```json
-{{
-  "data": [
-    {{
-      "index": <integer matching question number>,
-      "subject": "Mathematics",
-      "chapter_index": <chapter number or 0>,
-      "chapter_title": "<exact chapter title from list or 'Unclassified'>",
-      "other_possible_chapters": ["<alternative chapter 1>", "<alternative chapter 2>"],
-      "confidence": <0.0 to 1.0>
-    }}
-  ],
-  "success": [true]
-}}
-
+{{"data": [{{"i": <question number>, "ch": "<chapter title>", "alt": "<alternative or null>", "c": <0.0-1.0>}}]}}
 ```
 
 **Input Questions:**

routes/library.py

@@ -56,9 +56,13 @@ def pdf_manager(folder_path=''):
 @login_required
 def get_pdf_details(pdf_id):
     conn = get_db_connection()
+    current_app.logger.info(f"Fetching details for PDF {pdf_id} for User {current_user.id}")
     pdf = conn.execute('SELECT * FROM generated_pdfs WHERE id = ? AND user_id = ?', (pdf_id, current_user.id)).fetchone()
     conn.close()
-    return jsonify(dict(pdf)) if pdf else jsonify({'error': 'PDF not found'}), 404
+    if pdf:
+        return jsonify(dict(pdf))
+    current_app.logger.warning(f"PDF {pdf_id} not found for User {current_user.id}")
+    return jsonify({'error': 'PDF not found'}), 404
 
 @main_bp.route('/update_pdf_details/<int:pdf_id>', methods=[METHOD_POST])
 @login_required

routes/pdf_ops.py

@@ -65,7 +65,7 @@ def generate_preview():
         ipp, orientation = int(data.get('images_per_page', 4)), data.get('orientation', 'portrait')
         rows = int(data['grid_rows']) if data.get('grid_rows') else None
         cols = int(data['grid_cols']) if data.get('grid_cols') else None
-    pdf_bytes = create_a4_pdf_from_images(filtered[:ipp], current_app.config['PROCESSED_FOLDER'], images_per_page=ipp, orientation=orientation, grid_rows=rows, grid_cols=cols, practice_mode=practice_mode, return_bytes=True, font_size_scale=float(data.get('font_size_scale', 1.0)))
+    pdf_bytes = create_a4_pdf_from_images(filtered[:ipp], current_app.config['PROCESSED_FOLDER'], None, ipp, output_folder=None, orientation=orientation, grid_rows=rows, grid_cols=cols, practice_mode=practice_mode, return_bytes=True, font_size_scale=float(data.get('font_size_scale', 1.0)))
     if pdf_bytes:
         try:
             doc = fitz.open(stream=pdf_bytes, filetype="pdf")

routes/questions.py

@@ -5,57 +5,302 @@ from processing import resize_image_if_needed, call_nim_ocr_api, extract_questio
 from strings import ROUTE_SAVE_QUESTIONS, ROUTE_EXTRACT_QUESTION_NUMBER, ROUTE_EXTRACT_ALL_QUESTION_NUMBERS, METHOD_POST
 import requests
 import json
-from nvidia_prompts import BIOLOGY_PROMPT_TEMPLATE, CHEMISTRY_PROMPT_TEMPLATE, PHYSICS_PROMPT_TEMPLATE, MATHEMATICS_PROMPT_TEMPLATE
+from nvidia_prompts import BIOLOGY_PROMPT_TEMPLATE, CHEMISTRY_PROMPT_TEMPLATE, PHYSICS_PROMPT_TEMPLATE, MATHEMATICS_PROMPT_TEMPLATE, GENERAL_CLASSIFICATION_PROMPT
 
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
 NVIDIA_NIM_AVAILABLE = bool(NVIDIA_API_KEY)
 
 def get_nvidia_prompt(subject, input_questions):
+    if not subject or subject.lower() == 'auto':
+        return GENERAL_CLASSIFICATION_PROMPT.format(input_questions=input_questions)
     if subject.lower() == 'biology': return BIOLOGY_PROMPT_TEMPLATE.format(input_questions=input_questions)
     if subject.lower() == 'chemistry': return CHEMISTRY_PROMPT_TEMPLATE.format(input_questions=input_questions)
     if subject.lower() == 'physics': return PHYSICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
     if subject.lower() == 'mathematics': return MATHEMATICS_PROMPT_TEMPLATE.format(input_questions=input_questions)
-    return None
+    # Default to general prompt for unknown subjects
+    return GENERAL_CLASSIFICATION_PROMPT.format(input_questions=input_questions)
 
 @main_bp.route('/get_topic_suggestions', methods=['POST'])
 @login_required
 def get_topic_suggestions():
     data = request.json
     question_text, image_id, subject = data.get('question_text'), data.get('image_id'), data.get('subject')
-    if not subject: return jsonify({'error': 'Subject is required'}), 400
+    # Subject is now optional - will use general prompt if not provided
     if not question_text and image_id:
         try:
             conn = get_db_connection()
-            row = conn.execute('SELECT question_text, processed_filename, i.session_id FROM questions q JOIN images i ON q.image_id = i.id WHERE i.id = ?', (image_id,)).fetchone()
-            if row:
-                if row['question_text']: question_text = row['question_text']
-                else:
-                    image_path = os.path.join(current_app.config['PROCESSED_FOLDER'], row['processed_filename'])
+            # First check if we already have question_text cached
+            q_row = conn.execute('SELECT question_text FROM questions WHERE image_id = ?', (image_id,)).fetchone()
+            if q_row and q_row['question_text']:
+                question_text = q_row['question_text']
+            else:
+                # Get image directly (works even if questions not saved yet)
+                img_row = conn.execute('SELECT processed_filename, session_id FROM images WHERE id = ?', (image_id,)).fetchone()
+                if img_row and img_row['processed_filename']:
+                    image_path = os.path.join(current_app.config['PROCESSED_FOLDER'], img_row['processed_filename'])
                     if os.path.exists(image_path):
                         question_text = " ".join(item['text_prediction']['text'] for item in call_nim_ocr_api(resize_image_if_needed(image_path))['data'][0]['text_detections'])
-                        conn.execute('UPDATE questions SET question_text = ? WHERE image_id = ?', (question_text, image_id))
-                        conn.commit()
+                        # Cache the OCR result if question record exists
+                        if q_row:
+                            conn.execute('UPDATE questions SET question_text = ? WHERE image_id = ?', (question_text, image_id))
+                            conn.commit()
             conn.close()
         except Exception as e: return jsonify({'error': f"OCR failed: {str(e)}"}), 500
     if not question_text: return jsonify({'error': 'Could not obtain question text.'}), 400
+
     prompt_content = get_nvidia_prompt(subject, f"1. {question_text}")
-    if not prompt_content: return jsonify({'error': f'Unsupported subject: {subject}'}), 400
     if not NVIDIA_API_KEY: return jsonify({'error': 'NVIDIA_API_KEY not set'}), 500
+
     try:
         res = requests.post('https://integrate.api.nvidia.com/v1/chat/completions', headers={'Authorization': f'Bearer {NVIDIA_API_KEY}', 'Accept': 'application/json', 'Content-Type': 'application/json'}, json={"model": "nvidia/nemotron-3-nano-30b-a3b", "messages": [{"content": prompt_content, "role": "user"}], "temperature": 0.2, "top_p": 1, "max_tokens": 1024, "stream": False}, timeout=30)
         res.raise_for_status()
         content = res.json()['choices'][0]['message']['content']
         if "```json" in content: content = content.split("```json")[1].split("```")[0].strip()
         elif "```" in content: content = content.split("```")[1].split("```")[0].strip()
-        data = json.loads(content)
+        parsed_data = json.loads(content)
+
         suggestions = []
-        if data.get('data'):
-            suggestions.append(data['data'][0].get('chapter_title', 'Unclassified'))
-            if 'other_possible_chapters' in data['data'][0]:
-                others = data['data'][0]['other_possible_chapters']
-                if isinstance(others, list): suggestions.extend(others)
-        return jsonify({'success': True, 'suggestions': suggestions, 'full_response': data})
-    except Exception as e: return jsonify({'error': str(e)}), 500
+        detected_subject = subject  # Default to input subject
+        other_subjects = []
+
+        if parsed_data.get('data'):
+            item = parsed_data['data'][0]
+            # Extract detected subject from AI response
+            detected_subject = item.get('subject', subject) or subject
+            # Extract other possible subjects
+            other_subjects = item.get('other_possible_subjects', [])
+            if isinstance(other_subjects, str):
+                other_subjects = [other_subjects]
+
+            primary = item.get('chapter_title')
+            if primary and primary != 'Unclassified':
+                suggestions.append(primary)
+            if 'other_possible_chapters' in item:
+                others = item['other_possible_chapters']
+                if isinstance(others, list): suggestions.extend([c for c in others if c and c != 'Unclassified'])
+
+        # Always return at least one suggestion with fallback
+        if not suggestions:
+            fallback_topics = {
+                'biology': ['Cell: The Unit of Life', 'Biomolecules', 'Human Reproduction', 'Molecular Basis of Inheritance', 'Ecology'],
+                'chemistry': ['Organic Chemistry – Some Basic Principles and Techniques (GOC)', 'Chemical Bonding and Molecular Structure', 'Thermodynamics', 'Electrochemistry'],
+                'physics': ['Laws of Motion', 'Work, Energy and Power', 'Current Electricity', 'Electromagnetic Induction'],
+                'mathematics': ['Calculus', 'Algebra', 'Coordinate Geometry', 'Probability']
+            }
+            subj_key = (detected_subject or 'biology').lower()
+            suggestions = fallback_topics.get(subj_key, ['Unclassified'])
+
+        return jsonify({
+            'success': True,
+            'suggestions': suggestions[:5],
+            'subject': detected_subject,
+            'other_possible_subjects': other_subjects,
+            'full_response': parsed_data
+        })
+    except Exception as e:
+        return jsonify({
+            'success': True,
+            'suggestions': ['Unclassified'],
+            'subject': subject or 'Biology',
+            'other_possible_subjects': [],
+            'error': str(e)
+        })
+
+@main_bp.route('/get_topic_suggestions_batch', methods=['POST'])
+@login_required
+def get_topic_suggestions_batch():
+    """Batch endpoint for getting topic suggestions for multiple images at once.
+    Requires a subject to be specified. Processes up to 8 questions in a single API call."""
+    data = request.json
+    image_ids = data.get('image_ids', [])
+    subject = data.get('subject')
+
+    current_app.logger.info(f"[BATCH] Received request for {len(image_ids)} images, subject={subject}")
+
+    if not image_ids:
+        return jsonify({'error': 'No image_ids provided'}), 400
+    if not subject or subject.lower() == 'auto':
+        return jsonify({'error': 'Subject must be specified for batch requests'}), 400
+    if len(image_ids) > 8:
+        return jsonify({'error': 'Maximum 8 images per batch'}), 400
+
+    if not NVIDIA_API_KEY:
+        return jsonify({'error': 'NVIDIA_API_KEY not set'}), 500
+
+    try:
+        conn = get_db_connection()
+        questions_data = []  # List of {image_id, index, question_text}
+
+        for idx, image_id in enumerate(image_ids):
+            # Verify ownership
+            owner = conn.execute("SELECT s.user_id FROM images i JOIN sessions s ON i.session_id = s.id WHERE i.id = ?", (image_id,)).fetchone()
+            if not owner or owner['user_id'] != current_user.id:
+                current_app.logger.warning(f"[BATCH] Skipping image {image_id}: unauthorized")
+                continue  # Skip unauthorized images
+
+            question_text = None
+            # First check if we already have question_text cached
+            q_row = conn.execute('SELECT question_text FROM questions WHERE image_id = ?', (image_id,)).fetchone()
+            if q_row and q_row['question_text']:
+                question_text = q_row['question_text']
+                current_app.logger.debug(f"[BATCH] Image {image_id}: using cached question_text")
+            else:
+                # Get image directly
+                img_row = conn.execute('SELECT processed_filename FROM images WHERE id = ?', (image_id,)).fetchone()
+                if img_row and img_row['processed_filename']:
+                    image_path = os.path.join(current_app.config['PROCESSED_FOLDER'], img_row['processed_filename'])
+                    if os.path.exists(image_path):
+                        try:
+                            current_app.logger.info(f"[BATCH] Image {image_id}: running OCR on {img_row['processed_filename']}")
+                            question_text = " ".join(item['text_prediction']['text'] for item in call_nim_ocr_api(resize_image_if_needed(image_path))['data'][0]['text_detections'])
+                            # Cache the OCR result if question record exists
+                            if q_row:
+                                conn.execute('UPDATE questions SET question_text = ? WHERE image_id = ?', (question_text, image_id))
+                                conn.commit()
+                        except Exception as ocr_err:
+                            current_app.logger.error(f"[BATCH] Image {image_id}: OCR failed - {ocr_err}")
+                    else:
+                        current_app.logger.warning(f"[BATCH] Image {image_id}: file not found at {image_path}")
+                else:
+                    current_app.logger.warning(f"[BATCH] Image {image_id}: no processed_filename in DB")
+
+            if question_text:
+                questions_data.append({'image_id': image_id, 'index': idx + 1, 'question_text': question_text})
+            else:
+                current_app.logger.warning(f"[BATCH] Image {image_id}: no question_text obtained")
+
+        conn.close()
+
+        current_app.logger.info(f"[BATCH] Got question text for {len(questions_data)}/{len(image_ids)} images")
+
+        if not questions_data:
+            return jsonify({'error': 'Could not obtain question text for any images'}), 400
+
+        # Build multi-question prompt
+        input_questions = "\n".join(f"{q['index']}. {q['question_text']}" for q in questions_data)
+        prompt_content = get_nvidia_prompt(subject, input_questions)
+
+        current_app.logger.info(f"[BATCH] Sending {len(questions_data)} questions to NVIDIA API")
+        current_app.logger.debug(f"[BATCH] Prompt preview: {input_questions[:500]}...")
+
+        # Make single API call for all questions
+        res = requests.post(
+            'https://integrate.api.nvidia.com/v1/chat/completions',
+            headers={'Authorization': f'Bearer {NVIDIA_API_KEY}', 'Accept': 'application/json', 'Content-Type': 'application/json'},
+            json={"model": "nvidia/nemotron-3-nano-30b-a3b", "messages": [{"content": prompt_content, "role": "user"}], "temperature": 0.2, "top_p": 1, "max_tokens": 2048, "stream": False},
+            timeout=60
+        )
+        res.raise_for_status()
+        content = res.json()['choices'][0]['message']['content']
+
+        current_app.logger.info(f"[BATCH] NVIDIA API response length: {len(content)} chars")
+        current_app.logger.debug(f"[BATCH] Raw response: {content[:1000]}...")
+
+        # Parse JSON from response
+        if "```json" in content:
+            content = content.split("```json")[1].split("```")[0].strip()
+        elif "```" in content:
+            content = content.split("```")[1].split("```")[0].strip()
+        parsed_data = json.loads(content)
+
+        current_app.logger.info(f"[BATCH] Parsed data has {len(parsed_data.get('data', []))} items")
+
+        # Build results for each image
+        results = {}
+        fallback_topics = {
+            'biology': ['Cell: The Unit of Life', 'Biomolecules', 'Human Reproduction'],
+            'chemistry': ['Organic Chemistry – Some Basic Principles and Techniques (GOC)', 'Chemical Bonding and Molecular Structure'],
+            'physics': ['Laws of Motion', 'Work, Energy and Power', 'Current Electricity'],
+            'mathematics': ['Calculus', 'Algebra', 'Coordinate Geometry']
+        }
+
+        if parsed_data.get('data'):
+            data_items = parsed_data['data']
+            current_app.logger.info(f"[BATCH] AI returned {len(data_items)} items, we have {len(questions_data)} questions")
+
+            # Try to match by index first, then fall back to order-based matching
+            matched_by_index = 0
+            for item in data_items:
+                item_index = item.get('index', 0)
+                current_app.logger.debug(f"[BATCH] Processing item with index={item_index}: {item}")
+                # Find the matching question by our sequential index
+                matching_q = next((q for q in questions_data if q['index'] == item_index), None)
+                if matching_q:
+                    matched_by_index += 1
+                    suggestions = []
+                    primary = item.get('chapter_title')
+                    if primary and primary != 'Unclassified':
+                        suggestions.append(primary)
+                    if 'other_possible_chapters' in item:
+                        others = item['other_possible_chapters']
+                        if isinstance(others, list):
+                            suggestions.extend([c for c in others if c and c != 'Unclassified'])
+
+                    if not suggestions:
+                        suggestions = fallback_topics.get(subject.lower(), ['Unclassified'])
+
+                    results[matching_q['image_id']] = {
+                        'success': True,
+                        'suggestions': suggestions[:5],
+                        'subject': subject,
+                        'other_possible_subjects': []
+                    }
+                    current_app.logger.info(f"[BATCH] Image {matching_q['image_id']}: matched by index, suggestions={suggestions[:3]}")
+
+            # If index matching failed, try order-based matching
+            if matched_by_index == 0 and len(data_items) > 0:
+                current_app.logger.warning(f"[BATCH] Index matching failed, trying order-based matching")
+                for i, item in enumerate(data_items):
+                    if i < len(questions_data):
+                        q = questions_data[i]
+                        if q['image_id'] not in results:
+                            suggestions = []
+                            primary = item.get('chapter_title')
+                            if primary and primary != 'Unclassified':
+                                suggestions.append(primary)
+                            if 'other_possible_chapters' in item:
+                                others = item['other_possible_chapters']
+                                if isinstance(others, list):
+                                    suggestions.extend([c for c in others if c and c != 'Unclassified'])
+
+                            if not suggestions:
+                                suggestions = fallback_topics.get(subject.lower(), ['Unclassified'])
+
+                            results[q['image_id']] = {
+                                'success': True,
+                                'suggestions': suggestions[:5],
+                                'subject': subject,
+                                'other_possible_subjects': []
+                            }
+                            current_app.logger.info(f"[BATCH] Image {q['image_id']}: matched by order, suggestions={suggestions[:3]}")
+
+        # Fill in any missing results
+        for q in questions_data:
+            if q['image_id'] not in results:
+                current_app.logger.warning(f"[BATCH] Image {q['image_id']}: using fallback (no match in API response)")
+                results[q['image_id']] = {
+                    'success': True,
+                    'suggestions': fallback_topics.get(subject.lower(), ['Unclassified']),
+                    'subject': subject,
+                    'other_possible_subjects': []
+                }
+
+        return jsonify({'success': True, 'results': results})
+
+    except Exception as e:
+        # Return error but with fallback results for each image
+        fallback_result = {
+            'success': True,
+            'suggestions': ['Unclassified'],
+            'subject': subject,
+            'other_possible_subjects': [],
+            'error': str(e)
+        }
+        return jsonify({
+            'success': False,
+            'error': str(e),
+            'results': {img_id: fallback_result for img_id in image_ids}
+        })
 
 @main_bp.route('/classified/update_single', methods=['POST'])
 @login_required

templates/collection_view.html

@@ -0,0 +1,310 @@
+{% extends "base.html" %}
+
+{% block title %}{{ collection.name or 'Collection' }}{% endblock %}
+
+{% block head %}
+<style>
+    body, html {
+        background-color: #212529;
+    }
+    .collection-header {
+        background-color: #2b3035;
+        border-radius: 8px;
+        padding: 20px;
+        margin-bottom: 20px;
+    }
+    .topic-section {
+        background-color: #2b3035;
+        border-radius: 8px;
+        margin-bottom: 15px;
+    }
+    .topic-header {
+        background-color: #343a40;
+        padding: 12px 15px;
+        border-radius: 8px 8px 0 0;
+        cursor: pointer;
+    }
+    .topic-header:hover {
+        background-color: #3d444b;
+    }
+    .topic-body {
+        padding: 15px;
+    }
+    .question-card {
+        background-color: #343a40;
+        border-radius: 6px;
+        padding: 15px;
+        margin-bottom: 10px;
+        position: relative;
+    }
+    .question-card:last-child {
+        margin-bottom: 0;
+    }
+    .question-text {
+        font-size: 0.95rem;
+        color: #e9ecef;
+        margin-bottom: 10px;
+    }
+    .option-list {
+        list-style-type: upper-alpha;
+        padding-left: 25px;
+        margin-bottom: 10px;
+    }
+    .option-list li {
+        padding: 4px 0;
+        color: #adb5bd;
+    }
+    .option-list li.correct {
+        color: #28a745;
+        font-weight: 600;
+    }
+    .question-meta {
+        font-size: 0.8rem;
+        color: #6c757d;
+    }
+    .remove-btn {
+        position: absolute;
+        top: 10px;
+        right: 10px;
+        opacity: 0.5;
+    }
+    .remove-btn:hover {
+        opacity: 1;
+    }
+    .empty-state {
+        text-align: center;
+        padding: 60px 20px;
+        color: #6c757d;
+    }
+    .empty-state i {
+        font-size: 4rem;
+        margin-bottom: 20px;
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container-fluid mt-4" style="width: 90%; margin: auto;">
+    <!-- Header -->
+    <div class="collection-header">
+        <div class="d-flex justify-content-between align-items-start flex-wrap gap-2">
+            <div>
+                <h2 class="mb-2">
+                    <i class="bi bi-bookmark-fill text-warning me-2"></i>
+                    <span id="collection-name">{{ collection.name or 'Untitled Collection' }}</span>
+                    <button class="btn btn-link text-secondary btn-sm" id="edit-name-btn" title="Edit name">
+                        <i class="bi bi-pencil"></i>
+                    </button>
+                </h2>
+                <p class="text-muted mb-0">
+                    <span class="badge bg-secondary">{{ question_count }} questions</span>
+                    {% if collection.subject %}
+                    <span class="badge bg-info">{{ collection.subject }}</span>
+                    {% endif %}
+                    {% if collection.tags %}
+                    <span class="badge bg-primary">{{ collection.tags }}</span>
+                    {% endif %}
+                </p>
+            </div>
+            <div class="d-flex gap-2">
+                {% if question_count > 0 %}
+                <button class="btn btn-primary" id="start-quiz-btn">
+                    <i class="bi bi-play-fill me-1"></i>Start Quiz
+                </button>
+                {% endif %}
+                <button class="btn btn-success" id="generate-pdf-btn">
+                    <i class="bi bi-file-pdf me-1"></i>Generate PDF
+                </button>
+                <a href="{{ url_for('dashboard.dashboard', filter='collections') }}" class="btn btn-outline-secondary">
+                    <i class="bi bi-arrow-left me-1"></i>Back
+                </a>
+            </div>
+        </div>
+    </div>
+
+    <!-- Questions by Topic -->
+    {% if topics %}
+    {% for topic, questions_list in topics.items() %}
+    <div class="topic-section">
+        <div class="topic-header d-flex justify-content-between align-items-center" data-bs-toggle="collapse" data-bs-target="#topic-{{ loop.index }}">
+            <div>
+                <i class="bi bi-folder-fill text-warning me-2"></i>
+                <strong>{{ topic }}</strong>
+                <span class="badge bg-secondary ms-2">{{ questions_list|length }}</span>
+            </div>
+            <i class="bi bi-chevron-down"></i>
+        </div>
+        <div class="collapse show topic-body" id="topic-{{ loop.index }}">
+            {% for q in questions_list %}
+            <div class="question-card" data-question-id="{{ q.id }}" data-question-type="{{ q.question_type }}">
+                <button class="btn btn-outline-danger btn-sm remove-btn" title="Remove from collection">
+                    <i class="bi bi-x-lg"></i>
+                </button>
+
+                <!-- Question Number Badge -->
+                <div class="d-flex justify-content-between align-items-start mb-2">
+                    <span class="badge bg-dark">#{{ loop.index }}</span>
+                    {% if q.correct_answer_index is not none %}
+                    <span class="badge bg-success">Answer: {{ 'ABCDEFGH'[q.correct_answer_index|int] if q.correct_answer_index|int < 8 else q.correct_answer_index }}</span>
+                    {% endif %}
+                </div>
+
+                {% if q.image_filename %}
+                <div class="question-image-container mb-2">
+                    <img src="/processed/{{ q.image_filename }}" class="img-fluid rounded" alt="Question" style="max-height: 300px;">
+                </div>
+                {% else %}
+                <div class="question-text">{{ q.question_text or 'No question text available' }}</div>
+                {% endif %}
+                {% if q.options %}
+                <ol class="option-list">
+                    {% for opt in q.options|from_json %}
+                    <li class="{{ 'correct' if loop.index0 == q.correct_answer_index else '' }}">{{ opt }}</li>
+                    {% endfor %}
+                </ol>
+                {% endif %}
+                <div class="question-meta d-flex flex-wrap gap-2 align-items-center">
+                    {% if q.level %}
+                    <span><i class="bi bi-speedometer2 me-1"></i>{{ q.level }}</span>
+                    {% endif %}
+                    <span><i class="bi bi-book me-1"></i>{{ q.subject or 'Unknown' }}</span>
+                    <span class="badge {{ 'bg-info' if q.question_type == 'neetprep' else 'bg-success' }}">{{ q.question_type }}</span>
+                    {% if q.question_number %}
+                    <span><i class="bi bi-hash me-1"></i>Q{{ q.question_number }}</span>
+                    {% endif %}
+                </div>
+            </div>
+            {% endfor %}
+        </div>
+    </div>
+    {% endfor %}
+    {% else %}
+    <div class="empty-state">
+        <i class="bi bi-bookmark"></i>
+        <h4>No Questions Yet</h4>
+        <p>Questions you bookmark during quizzes will appear here.</p>
+        <a href="{{ url_for('neetprep_bp.index') }}" class="btn btn-primary">
+            <i class="bi bi-play-fill me-1"></i>Start a Quiz
+        </a>
+    </div>
+    {% endif %}
+</div>
+
+<!-- Edit Name Modal -->
+<div class="modal fade" id="editNameModal" tabindex="-1">
+    <div class="modal-dialog modal-dialog-centered">
+        <div class="modal-content bg-dark text-white">
+            <div class="modal-header border-secondary">
+                <h5 class="modal-title">Edit Collection Name</h5>
+                <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
+            </div>
+            <div class="modal-body">
+                <input type="text" id="new-name-input" class="form-control bg-secondary text-white border-secondary"
+                       value="{{ collection.name or '' }}" placeholder="Collection name...">
+            </div>
+            <div class="modal-footer border-secondary">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
+                <button type="button" class="btn btn-primary" id="save-name-btn">Save</button>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+const sessionId = '{{ collection.id }}';
+
+// Edit name
+document.getElementById('edit-name-btn').onclick = () => {
+    new bootstrap.Modal(document.getElementById('editNameModal')).show();
+};
+
+document.getElementById('save-name-btn').onclick = async () => {
+    const newName = document.getElementById('new-name-input').value.trim();
+    if (!newName) return;
+
+    try {
+        const res = await fetch(`/neetprep/collections/${sessionId}/update`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: newName })
+        });
+        const data = await res.json();
+        if (data.success) {
+            document.getElementById('collection-name').textContent = newName;
+            bootstrap.Modal.getInstance(document.getElementById('editNameModal')).hide();
+        }
+    } catch(e) {
+        alert('Error updating name');
+    }
+};
+
+// Generate PDF
+document.getElementById('generate-pdf-btn').onclick = async function() {
+    const btn = this;
+    btn.disabled = true;
+    btn.innerHTML = '<span class="spinner-border spinner-border-sm me-1"></span>Generating...';
+
+    try {
+        const res = await fetch(`/neetprep/collections/${sessionId}/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({})
+        });
+        const data = await res.json();
+        btn.disabled = false;
+        btn.innerHTML = '<i class="bi bi-file-pdf me-1"></i>Generate PDF';
+
+        if (data.success && data.pdf_url) {
+            window.open(data.pdf_url, '_blank');
+        } else {
+            alert('Error: ' + (data.error || 'Failed to generate PDF'));
+        }
+    } catch(e) {
+        btn.disabled = false;
+        btn.innerHTML = '<i class="bi bi-file-pdf me-1"></i>Generate PDF';
+        alert('Error generating PDF');
+    }
+};
+
+// Start Quiz
+const quizBtn = document.getElementById('start-quiz-btn');
+if (quizBtn) {
+    quizBtn.onclick = function() {
+        window.location.href = `/neetprep/collections/${sessionId}/quiz`;
+    };
+}
+
+// Remove from collection
+document.querySelectorAll('.remove-btn').forEach(btn => {
+    btn.onclick = async function() {
+        const card = this.closest('.question-card');
+        const questionId = card.dataset.questionId;
+        const questionType = card.dataset.questionType;
+
+        if (!confirm('Remove this question from the collection?')) return;
+
+        try {
+            const res = await fetch('/neetprep/bookmark', {
+                method: 'DELETE',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ question_id: questionId, session_id: sessionId, question_type: questionType })
+            });
+            const data = await res.json();
+            if (data.success) {
+                card.remove();
+                // Update count in header
+                const countBadge = document.querySelector('.collection-header .badge.bg-secondary');
+                if (countBadge) {
+                    const currentCount = parseInt(countBadge.textContent);
+                    countBadge.textContent = `${currentCount - 1} questions`;
+                }
+            }
+        } catch(e) {
+            alert('Error removing question');
+        }
+    };
+});
+</script>
+{% endblock %}

templates/dashboard.html

@@ -109,6 +109,22 @@
         font-weight: 600;
         color: #4db8ff;
     }
+
+    /* Filter tabs styling */
+    .nav-pills .nav-link {
+        color: #adb5bd;
+        background-color: transparent;
+        border: 1px solid #495057;
+    }
+    .nav-pills .nav-link:hover {
+        color: #fff;
+        background-color: #343a40;
+    }
+    .nav-pills .nav-link.active {
+        color: #fff !important;
+        background-color: #0d6efd !important;
+        border-color: #0d6efd;
+    }
 </style>
 {% endblock %}
 
@@ -119,6 +135,21 @@
         <button id="delete-selected-btn" class="btn btn-danger" style="display: none;">Delete Selected</button>
     </div>
 
+    <!-- Filter tabs -->
+    <ul class="nav nav-pills mb-3">
+        <li class="nav-item">
+            <a class="nav-link {{ 'active' if filter_type == 'all' else '' }}" href="{{ url_for('dashboard.dashboard') }}{% if show_size %}?size=1{% endif %}">All</a>
+        </li>
+        <li class="nav-item">
+            <a class="nav-link {{ 'active' if filter_type == 'standard' else '' }}" href="{{ url_for('dashboard.dashboard', filter='standard') }}{% if show_size %}&size=1{% endif %}">Standard Sessions</a>
+        </li>
+        <li class="nav-item">
+            <a class="nav-link {{ 'active' if filter_type == 'collections' else '' }}" href="{{ url_for('dashboard.dashboard', filter='collections') }}{% if show_size %}&size=1{% endif %}">
+                <i class="bi bi-bookmark-fill me-1"></i>NEETprep Collections
+            </a>
+        </li>
+    </ul>
+
     <div class="table-responsive">
         <table class="table table-hover table-striped">
             <thead>
@@ -128,7 +159,7 @@
                     <th scope="col" class="name-column">Name</th>
                     <th scope="col">Created At</th>
                     <th scope="col">Pages</th>
-                    <th scope="col">Questions</th>
+                    <th scope="col">{{ 'Bookmarks' if filter_type == 'collections' else 'Questions' }}</th>
                     {% if show_size %}
                     <th scope="col">Size</th>
                     {% endif %}
@@ -161,7 +192,11 @@
                     </td>
                     <td>
                         <div class="btn-group" role="group">
-                            {% if session.session_type == 'color_rm' %}
+                            {% if session.session_type == 'neetprep_collection' %}
+                                <a href="{{ url_for('neetprep_bp.view_collection', session_id=session.id) }}" class="btn btn-sm btn-warning text-dark"><i class="bi bi-bookmark-fill me-1"></i>View</a>
+                                <button class="btn btn-sm btn-success generate-collection-pdf-btn" data-session-id="{{ session.id }}"><i class="bi bi-file-pdf me-1"></i>PDF</button>
+                                <button class="btn btn-sm btn-info toggle-persist-btn">Toggle Persist</button>
+                            {% elif session.session_type == 'color_rm' %}
                                 <a href="{{ url_for('main.color_rm_interface', session_id=session.id, image_index=0) }}" class="btn btn-sm btn-warning text-dark">Color RM</a>
                                 <button class="btn btn-sm btn-info toggle-persist-btn">Toggle Persist</button>
                                 {% if show_size %}
@@ -331,6 +366,38 @@ $(document).ready(function() {
         }
     });
     {% endif %}
+
+    // Generate PDF from collection
+    $('.generate-collection-pdf-btn').on('click', function() {
+        const button = $(this);
+        const sessionId = button.data('session-id');
+        button.prop('disabled', true).html('<span class="spinner-border spinner-border-sm me-1"></span>Generating...');
+
+        $.ajax({
+            url: `/neetprep/collections/${sessionId}/generate`,
+            type: 'POST',
+            contentType: 'application/json',
+            data: JSON.stringify({}),
+            success: function(response) {
+                button.prop('disabled', false).html('<i class="bi bi-file-pdf me-1"></i>PDF');
+                if (response.success) {
+                    // Open PDF in new tab
+                    window.open(response.pdf_url, '_blank');
+                } else {
+                    alert('Error generating PDF: ' + (response.error || 'Unknown error'));
+                }
+            },
+            error: function(xhr) {
+                button.prop('disabled', false).html('<i class="bi bi-file-pdf me-1"></i>PDF');
+                try {
+                    const response = JSON.parse(xhr.responseText);
+                    alert('Error generating PDF: ' + response.error);
+                } catch(e) {
+                    alert('Error generating PDF');
+                }
+            }
+        });
+    });
 });
 </script>
 {% endblock %}

templates/neetprep.html

@@ -4,122 +4,350 @@
 
 {% block head %}
 <style>
-    .name-column {
-        word-wrap: break-word;
-        white-space: normal;
-        max-width: 250px;
-    }
-    @media (max-width: 768px) {
-        .name-column {
-            max-width: 25%;
-        }
+    body, html {
+        background-color: #212529;
     }
-    .table-responsive {
-        overflow-x: auto;
+
+    .page-header {
+        background: linear-gradient(135deg, #1a1d21 0%, #2b3035 100%);
+        border-radius: 12px;
+        padding: 24px;
+        margin-bottom: 24px;
+        border: 1px solid #343a40;
     }
-    th:first-child, td:first-child {
-        position: sticky;
-        left: 0;
-        z-index: 2;
-        background-color: #212529;
+
+    .page-header h2 {
+        margin: 0;
+        font-weight: 600;
+        color: #fff;
     }
-    th:nth-child(2), td:nth-child(2) {
+
+    .section-card {
+        background-color: #2b3035;
+        border-radius: 12px;
+        padding: 20px;
+        margin-bottom: 20px;
+        border: 1px solid #343a40;
+    }
+
+    .section-title {
+        font-size: 1rem;
+        font-weight: 600;
+        color: #adb5bd;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+        margin-bottom: 16px;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .section-title i {
+        color: #6c757d;
+    }
+
+    /* Sync controls */
+    .sync-controls {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 12px;
+        align-items: center;
+    }
+
+    .sync-btn {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    /* Source filter pills */
+    .source-filter-group {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+    }
+
+    .source-filter-group .btn-check:checked + .btn {
+        box-shadow: 0 0 0 2px rgba(13, 110, 253, 0.5);
+    }
+
+    /* Topic table */
+    .topic-table-container {
+        max-height: 350px;
+        overflow-y: auto;
+        border-radius: 8px;
+        border: 1px solid #343a40;
+    }
+
+    .topic-table {
+        margin-bottom: 0;
+    }
+
+    .topic-table thead th {
         position: sticky;
-        left: 40px;
-        z-index: 2;
+        top: 0;
         background-color: #212529;
+        border-bottom: 2px solid #495057;
+        font-weight: 600;
+        font-size: 0.85rem;
+        color: #adb5bd;
+        text-transform: uppercase;
+        letter-spacing: 0.3px;
+        padding: 12px 10px;
+    }
+
+    .topic-table tbody td {
+        padding: 10px;
+        vertical-align: middle;
+        border-color: #343a40;
+    }
+
+    .topic-table tbody tr:hover {
+        background-color: rgba(13, 110, 253, 0.1);
+    }
+
+    .topic-name {
+        font-weight: 500;
+        color: #e9ecef;
+    }
+
+    /* Action buttons grid */
+    .action-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+        gap: 12px;
+    }
+
+    .action-btn {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        padding: 12px 16px;
+        font-weight: 500;
+        border-radius: 8px;
+        transition: transform 0.1s, box-shadow 0.1s;
+    }
+
+    .action-btn:hover {
+        transform: translateY(-1px);
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    }
+
+    /* Subject filter */
+    .subject-select {
+        max-width: 300px;
+        background-color: #343a40;
+        border-color: #495057;
+        color: #fff;
+    }
+
+    .subject-select:focus {
+        background-color: #343a40;
+        border-color: #0d6efd;
+        color: #fff;
+        box-shadow: 0 0 0 2px rgba(13, 110, 253, 0.25);
+    }
+
+    /* Status alerts */
+    #sync-status .alert {
+        border-radius: 8px;
+        border: none;
+    }
+
+    /* Badge styling */
+    .count-badge {
+        min-width: 40px;
+        display: inline-block;
+        text-align: center;
+    }
+
+    /* Checkbox styling */
+    .form-check-input {
+        width: 18px;
+        height: 18px;
+        cursor: pointer;
+    }
+
+    .form-check-input:checked {
+        background-color: #0d6efd;
+        border-color: #0d6efd;
+    }
+
+    /* Selection info bar */
+    .selection-info {
+        background-color: #343a40;
+        border-radius: 8px;
+        padding: 10px 16px;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        margin-bottom: 12px;
+    }
+
+    .selection-count {
+        font-weight: 500;
+        color: #0d6efd;
     }
 </style>
 {% endblock %}
 
 {% block content %}
-<div class="container-fluid mt-5" style="width: 90%; margin: auto;">
-    <div class="card bg-dark text-white">
-        <div class="card-header">
-            <h2>NeetPrep Incorrect Question Manager</h2>
+<div class="container-fluid mt-4" style="width: 90%; margin: auto;">
+    <!-- Page Header -->
+    <div class="page-header">
+        <div class="d-flex justify-content-between align-items-center flex-wrap gap-3">
+            <h2><i class="bi bi-journal-x me-2"></i>Incorrect Question Manager</h2>
+            <div class="d-flex gap-2">
+                {% if neetprep_enabled %}
+                <a href="/neetprep/edit" class="btn btn-outline-light btn-sm"><i class="bi bi-pencil me-1"></i>Edit Synced</a>
+                {% endif %}
+                <a href="/classified/edit" class="btn btn-outline-light btn-sm"><i class="bi bi-pencil me-1"></i>Edit Classified</a>
+            </div>
         </div>
-        <div class="card-body">
+    </div>
+
+    <div class="row">
+        <!-- Left Column: Controls -->
+        <div class="col-lg-4">
             {% if neetprep_enabled %}
-            <div class="d-flex flex-wrap gap-2 align-items-center mb-3">
-                <button id="sync-btn" class="btn btn-primary">Sync/Fetch Latest Incorrect Questions</button>
-                <div class="form-check">
-                    <input class="form-check-input" type="checkbox" id="force-sync-checkbox">
-                    <label class="form-check-label" for="force-sync-checkbox">
-                        Force full re-sync
-                    </label>
+            <!-- Sync Section -->
+            <div class="section-card">
+                <div class="section-title"><i class="bi bi-cloud-download"></i>NeetPrep Sync</div>
+                <div class="sync-controls">
+                    <button id="sync-btn" class="btn btn-primary sync-btn">
+                        <i class="bi bi-arrow-repeat"></i>Sync Questions
+                    </button>
+                    <div class="form-check">
+                        <input class="form-check-input" type="checkbox" id="force-sync-checkbox">
+                        <label class="form-check-label text-muted" for="force-sync-checkbox">Force full re-sync</label>
+                    </div>
+                </div>
+                <hr class="my-3 border-secondary">
+                <div class="d-flex align-items-center gap-3">
+                    <button id="classify-btn" class="btn btn-warning btn-sm">
+                        <i class="bi bi-tags me-1"></i>Classify
+                    </button>
+                    <span class="text-muted small">{{ unclassified_count }} unclassified</span>
                 </div>
-            </div>
-            <div class="d-flex flex-wrap gap-2 align-items-center">
-                <button id="classify-btn" class="btn btn-warning">Classify Unclassified Questions</button>
-                <span class="ms-3">({{ unclassified_count }} unclassified)</span>
             </div>
             {% else %}
-            <div class="alert alert-info" role="alert">
-                NeetPrep Sync is currently disabled. You can enable it in <a href="{{ url_for('settings.settings') }}" class="alert-link">Settings</a>.
+            <div class="section-card">
+                <div class="alert alert-info mb-0" role="alert">
+                    <i class="bi bi-info-circle me-2"></i>
+                    NeetPrep Sync is disabled. Enable it in <a href="{{ url_for('settings.settings') }}" class="alert-link">Settings</a>.
+                </div>
             </div>
             {% endif %}
-            
-            <div id="sync-status" class="mt-3"></div>
-            <div id="pdf-link-container" class="mt-3"></div>
-
-            <hr class="my-4">
-
-            <h4>Filter by Subject</h4>
-            <form id="subject-filter-form" method="get" action="{{ url_for('neetprep_bp.index') }}" class="mb-3">
-                <div class="row">
-                    <div class="col-md-4">
-                        <select name="subject" id="subject" class="form-select" onchange="this.form.submit()">
-                            {% for subject in available_subjects %}
-                                <option value="{{ subject }}" {% if subject == selected_subject %}selected{% endif %}>{{ subject }}</option>
-                            {% endfor %}
-                        </select>
-                    </div>
-                </div>
-            </form>
 
-            <h4>Generate PDF</h4>
-            <form id="generate-pdf-form">
-                <div class="d-flex flex-wrap gap-2 mb-3">
+            <!-- Subject Filter -->
+            <div class="section-card">
+                <div class="section-title"><i class="bi bi-funnel"></i>Filter by Subject</div>
+                <form id="subject-filter-form" method="get" action="{{ url_for('neetprep_bp.index') }}">
+                    <select name="subject" id="subject" class="form-select subject-select" onchange="this.form.submit()">
+                        {% for subject in available_subjects %}
+                        <option value="{{ subject }}" {% if subject == selected_subject %}selected{% endif %}>{{ subject }}</option>
+                        {% endfor %}
+                    </select>
+                </form>
+            </div>
+
+            <!-- Question Source -->
+            <div class="section-card">
+                <div class="section-title"><i class="bi bi-collection"></i>Question Source</div>
+                <div class="source-filter-group">
+                    <input type="radio" class="btn-check" name="source_filter" id="source-all" value="all" checked>
+                    <label class="btn btn-outline-secondary btn-sm" for="source-all">All</label>
+
                     {% if neetprep_enabled %}
-                    <button type="submit" name="pdf_type" value="all" class="btn btn-success">Generate PDF of All Incorrect Questions</button>
-                    <a href="/neetprep/edit" class="btn btn-secondary">Edit Synced Questions</a>
+                    <input type="radio" class="btn-check" name="source_filter" id="source-neetprep" value="neetprep">
+                    <label class="btn btn-outline-info btn-sm" for="source-neetprep">NeetPrep</label>
                     {% endif %}
-                    <button type="submit" name="pdf_type" value="quiz" class="btn btn-primary">Start Quiz</button>
-                    <a href="/classified/edit" class="btn btn-secondary">Edit Classified Questions</a>
+
+                    <input type="radio" class="btn-check" name="source_filter" id="source-classified" value="classified">
+                    <label class="btn btn-outline-success btn-sm" for="source-classified">Classified</label>
                 </div>
+            </div>
 
-                <h5>Or, Generate by Topic:</h5>
-                <div class="table-responsive" style="max-height: 400px;">
-                    <table class="table table-sm table-hover table-striped">
-                        <thead>
-                            <tr>
-                                <th scope="col" style="width: 3%;">S.No.</th>
-                                <th scope="col" style="width: 3%;"></th>
-                                <th scope="col" class="name-column">Topic</th>
-                                {% if neetprep_enabled %}<th>NeetPrep Questions</th>{% endif %}
-                                <th>My Questions</th>
-                            </tr>
-                        </thead>
-                        <tbody id="topic-list">
-                        {% if topics %}
-                            {% for item in topics %}
-                            <tr>
-                                <td>{{ loop.index }}</td>
-                                <td><input class="form-check-input" type="checkbox" value="{{ item.topic }}"></td>
-                                <td class="name-column">{{ item.topic }}</td>
-                                {% if neetprep_enabled %}<td><span class="badge bg-secondary">{{ item.neetprep_count }}</span></td>{% endif %}
-                                <td><span class="badge bg-info">{{ item.my_questions_count }}</span></td>
-                            </tr>
-                            {% endfor %}
-                        {% else %}
-                            <tr>
-                                <td colspan="{% if neetprep_enabled %}5{% else %}4{% endif %}"><i>No topics found. {% if neetprep_enabled %}Sync with NeetPrep to fetch questions and topics.{% else %}No classified topics found.{% endif %}</i></td>
-                            </tr>
+            <!-- Status Messages -->
+            <div id="sync-status"></div>
+            <div id="pdf-link-container"></div>
+        </div>
+
+        <!-- Right Column: Topics & Actions -->
+        <div class="col-lg-8">
+            <form id="generate-pdf-form">
+                <!-- Quick Actions -->
+                <div class="section-card">
+                    <div class="section-title"><i class="bi bi-lightning"></i>Quick Actions</div>
+                    <div class="action-grid">
+                        {% if neetprep_enabled %}
+                        <button type="submit" name="pdf_type" value="all" class="btn btn-success action-btn">
+                            <i class="bi bi-file-pdf"></i>Generate All PDF
+                        </button>
                         {% endif %}
-                        </tbody>
-                    </table>
+                        <button type="submit" name="pdf_type" value="quiz" class="btn btn-primary action-btn">
+                            <i class="bi bi-play-circle"></i>Start Quiz
+                        </button>
+                        <button type="submit" name="pdf_type" value="selected" class="btn btn-info action-btn" {% if not topics %}disabled{% endif %}>
+                            <i class="bi bi-check2-square"></i>Generate Selected
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Topic Selection -->
+                <div class="section-card">
+                    <div class="section-title"><i class="bi bi-list-check"></i>Select Topics</div>
+
+                    {% if topics %}
+                    <!-- Selection Info Bar -->
+                    <div class="selection-info">
+                        <div>
+                            <input class="form-check-input me-2" type="checkbox" id="select-all-topics">
+                            <label for="select-all-topics" class="form-check-label">Select All</label>
+                        </div>
+                        <span class="selection-count"><span id="selected-count">0</span> / {{ topics|length }} selected</span>
+                    </div>
+                    {% endif %}
+
+                    <div class="topic-table-container">
+                        <table class="table table-dark table-hover topic-table">
+                            <thead>
+                                <tr>
+                                    <th style="width: 50px;">#</th>
+                                    <th style="width: 50px;"></th>
+                                    <th>Topic</th>
+                                    {% if neetprep_enabled %}<th style="width: 100px;">NeetPrep</th>{% endif %}
+                                    <th style="width: 100px;">My Qs</th>
+                                </tr>
+                            </thead>
+                            <tbody id="topic-list">
+                            {% if topics %}
+                                {% for item in topics %}
+                                <tr>
+                                    <td class="text-muted">{{ loop.index }}</td>
+                                    <td><input class="form-check-input topic-checkbox" type="checkbox" value="{{ item.topic }}"></td>
+                                    <td class="topic-name">{{ item.topic }}</td>
+                                    {% if neetprep_enabled %}<td><span class="badge bg-secondary count-badge">{{ item.neetprep_count }}</span></td>{% endif %}
+                                    <td><span class="badge bg-info count-badge">{{ item.my_questions_count }}</span></td>
+                                </tr>
+                                {% endfor %}
+                            {% else %}
+                                <tr>
+                                    <td colspan="{% if neetprep_enabled %}5{% else %}4{% endif %}" class="text-center text-muted py-4">
+                                        <i class="bi bi-inbox fs-1 d-block mb-2"></i>
+                                        {% if neetprep_enabled %}
+                                        No topics found. Sync with NeetPrep to fetch questions.
+                                        {% else %}
+                                        No classified topics found.
+                                        {% endif %}
+                                    </td>
+                                </tr>
+                            {% endif %}
+                            </tbody>
+                        </table>
+                    </div>
                 </div>
-                <button type="submit" name="pdf_type" value="selected" class="btn btn-info mt-2" {% if not topics %}disabled{% endif %}>Generate PDF for Selected Topics</button>
             </form>
         </div>
     </div>
@@ -130,66 +358,87 @@
 <script>
 function loadSettings() {
     const settings = JSON.parse(localStorage.getItem('pdfGeneratorSettings'));
-    console.log("Loaded settings from localStorage:", settings);
     if (settings) {
         return settings;
-    } else {
-        console.log("No settings found in localStorage, using default.");
-        return {
-            images_per_page: 4,
-            orientation: 'portrait',
-            grid_rows: 4,
-            grid_cols: 1,
-            practice_mode: 'none'
-        };
     }
+    return {
+        images_per_page: 4,
+        orientation: 'portrait',
+        grid_rows: 4,
+        grid_cols: 1,
+        practice_mode: 'none'
+    };
+}
+
+// Select all checkbox functionality
+const selectAllCheckbox = document.getElementById('select-all-topics');
+const topicCheckboxes = document.querySelectorAll('.topic-checkbox');
+const selectedCountSpan = document.getElementById('selected-count');
+
+function updateSelectedCount() {
+    const count = document.querySelectorAll('.topic-checkbox:checked').length;
+    if (selectedCountSpan) selectedCountSpan.textContent = count;
+
+    // Update select all checkbox state
+    if (selectAllCheckbox) {
+        selectAllCheckbox.checked = count === topicCheckboxes.length && topicCheckboxes.length > 0;
+        selectAllCheckbox.indeterminate = count > 0 && count < topicCheckboxes.length;
+    }
+}
+
+if (selectAllCheckbox) {
+    selectAllCheckbox.addEventListener('change', () => {
+        topicCheckboxes.forEach(cb => cb.checked = selectAllCheckbox.checked);
+        updateSelectedCount();
+    });
 }
 
+topicCheckboxes.forEach(cb => {
+    cb.addEventListener('change', updateSelectedCount);
+});
+
 // Only attach event listeners if NeetPrep is enabled
 {% if neetprep_enabled %}
 document.getElementById('sync-btn').addEventListener('click', async () => {
     const syncStatus = document.getElementById('sync-status');
     const forceSync = document.getElementById('force-sync-checkbox').checked;
-    syncStatus.innerHTML = '<div class="alert alert-info">Syncing... This may take a while.</div>';
-    
+    syncStatus.innerHTML = '<div class="alert alert-info"><i class="bi bi-hourglass-split me-2"></i>Syncing... This may take a while.</div>';
+
     try {
-        const response = await fetch('/neetprep/sync', { 
+        const response = await fetch('/neetprep/sync', {
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
+            headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ force: forceSync })
         });
         const result = await response.json();
-        
+
         if (response.ok) {
-            syncStatus.innerHTML = `<div class="alert alert-success">${result.status}</div>`;
-            // Reload the page to show updated topics
+            syncStatus.innerHTML = `<div class="alert alert-success"><i class="bi bi-check-circle me-2"></i>${result.status}</div>`;
             setTimeout(() => window.location.reload(), 2000);
         } else {
-            syncStatus.innerHTML = `<div class="alert alert-danger">Error: ${result.error || 'Unknown error'}</div>`;
+            syncStatus.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Error: ${result.error || 'Unknown error'}</div>`;
         }
     } catch (error) {
-        syncStatus.innerHTML = `<div class="alert alert-danger">Request failed: ${error}</div>`;
+        syncStatus.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Request failed: ${error}</div>`;
     }
 });
 
 document.getElementById('classify-btn').addEventListener('click', async () => {
     const syncStatus = document.getElementById('sync-status');
-    syncStatus.innerHTML = '<div class="alert alert-info">Classification started... This will take time due to rate limits.</div>';
-    
+    syncStatus.innerHTML = '<div class="alert alert-info"><i class="bi bi-hourglass-split me-2"></i>Classification started... This will take time due to rate limits.</div>';
+
     try {
         const response = await fetch('/neetprep/classify', { method: 'POST' });
         const result = await response.json();
-        
+
         if (response.ok) {
-            syncStatus.innerHTML = `<div class="alert alert-success">${result.status}</div>`;
+            syncStatus.innerHTML = `<div class="alert alert-success"><i class="bi bi-check-circle me-2"></i>${result.status}</div>`;
             setTimeout(() => window.location.reload(), 2000);
         } else {
-            syncStatus.innerHTML = `<div class="alert alert-danger">Error: ${result.error || 'Unknown error'}</div>`;
+            syncStatus.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Error: ${result.error || 'Unknown error'}</div>`;
         }
     } catch (error) {
-        syncStatus.innerHTML = `<div class="alert alert-danger">Request failed: ${error}</div>`;
+        syncStatus.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Request failed: ${error}</div>`;
     }
 });
 {% endif %}
@@ -199,18 +448,19 @@ document.getElementById('generate-pdf-form').addEventListener('submit', async (e
     const pdfType = e.submitter.value;
     const statusDiv = document.getElementById('sync-status');
     const settings = loadSettings();
+    const sourceFilter = document.querySelector('input[name="source_filter"]:checked').value;
+
     if (pdfType === 'quiz') {
-        const selectedTopics = Array.from(document.querySelectorAll('#topic-list input[type="checkbox"]:checked')).map(cb => cb.value);
+        const selectedTopics = Array.from(document.querySelectorAll('#topic-list .topic-checkbox:checked')).map(cb => cb.value);
         if (selectedTopics.length === 0) {
-            statusDiv.innerHTML = '<div class="alert alert-warning">Please select at least one topic for the quiz.</div>';
+            statusDiv.innerHTML = '<div class="alert alert-warning"><i class="bi bi-exclamation-circle me-2"></i>Please select at least one topic for the quiz.</div>';
             return;
         }
 
-        // For quiz, we do a full page navigation, so we create a form and submit it.
         const form = document.createElement('form');
         form.method = 'POST';
         form.action = '/neetprep/generate';
-        
+
         const typeInput = document.createElement('input');
         typeInput.type = 'hidden';
         typeInput.name = 'type';
@@ -223,14 +473,20 @@ document.getElementById('generate-pdf-form').addEventListener('submit', async (e
         topicsInput.value = JSON.stringify(selectedTopics);
         form.appendChild(topicsInput);
 
+        const sourceInput = document.createElement('input');
+        sourceInput.type = 'hidden';
+        sourceInput.name = 'source';
+        sourceInput.value = sourceFilter;
+        form.appendChild(sourceInput);
+
         document.body.appendChild(form);
         form.submit();
-        return; // Stop the rest of the function
+        return;
     }
 
-    // Existing logic for PDF generation
-    let payload = { 
+    let payload = {
         type: pdfType,
+        source: sourceFilter,
         layout: {
             images_per_page: settings.images_per_page,
             orientation: settings.orientation,
@@ -241,16 +497,15 @@ document.getElementById('generate-pdf-form').addEventListener('submit', async (e
     };
 
     if (pdfType === 'selected') {
-        const selectedTopics = Array.from(document.querySelectorAll('#topic-list input[type="checkbox"]:checked')).map(cb => cb.value);
+        const selectedTopics = Array.from(document.querySelectorAll('#topic-list .topic-checkbox:checked')).map(cb => cb.value);
         if (selectedTopics.length === 0) {
-            statusDiv.innerHTML = '<div class="alert alert-warning">Please select at least one topic.</div>';
+            statusDiv.innerHTML = '<div class="alert alert-warning"><i class="bi bi-exclamation-circle me-2"></i>Please select at least one topic.</div>';
             return;
         }
         payload.topics = selectedTopics;
     }
 
-    console.log("Payload sent to server:", payload);
-    statusDiv.innerHTML = '<div class="alert alert-info">Generating PDF...</div>';
+    statusDiv.innerHTML = '<div class="alert alert-info"><i class="bi bi-hourglass-split me-2"></i>Generating PDF...</div>';
 
     try {
         const response = await fetch('/neetprep/generate', {
@@ -261,24 +516,18 @@ document.getElementById('generate-pdf-form').addEventListener('submit', async (e
         const result = await response.json();
 
         if (response.ok && result.success) {
-            statusDiv.innerHTML = '<div class="alert alert-success">PDF generated!</div>';
+            statusDiv.innerHTML = '<div class="alert alert-success"><i class="bi bi-check-circle me-2"></i>PDF generated!</div>';
             if(result.pdf_url) {
                 const pdfLinkContainer = document.getElementById('pdf-link-container');
-                const link = document.createElement('a');
-                link.href = result.pdf_url;
-                link.textContent = 'View Generated PDF';
-                link.className = 'btn btn-outline-light';
-                link.target = '_blank';
-                pdfLinkContainer.innerHTML = ''; // Clear previous links
-                pdfLinkContainer.appendChild(link);
+                pdfLinkContainer.innerHTML = `<a href="${result.pdf_url}" class="btn btn-outline-light" target="_blank"><i class="bi bi-file-pdf me-2"></i>View Generated PDF</a>`;
                 window.open(result.pdf_url, '_blank');
             }
         } else {
-            statusDiv.innerHTML = `<div class="alert alert-danger">Error: ${result.error || 'PDF generation failed.'}</div>`;
+            statusDiv.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Error: ${result.error || 'PDF generation failed.'}</div>`;
         }
     } catch (error) {
-        statusDiv.innerHTML = `<div class="alert alert-danger">Request failed: ${error}</div>`;
+        statusDiv.innerHTML = `<div class="alert alert-danger"><i class="bi bi-exclamation-triangle me-2"></i>Request failed: ${error}</div>`;
     }
 });
 </script>
-{% endblock %}
+{% endblock %}

templates/neetprep_edit.html

@@ -2,12 +2,58 @@
 
 {% block title %}Edit NeetPrep Questions{% endblock %}
 
+{% block head %}
+<style>
+    /* Style for rendered question HTML */
+    #topic_q_text img {
+        max-width: 100%;
+        height: auto;
+        border-radius: 4px;
+    }
+    #topic_q_text p {
+        margin-bottom: 0.5rem;
+    }
+    #topic_q_text {
+        font-size: 0.95rem;
+        line-height: 1.5;
+    }
+    /* Truncate table cell text */
+    .question-text-cell {
+        max-width: 300px;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+    /* Range toggles */
+    .range-toggle { transition: all 0.2s; }
+    .range-toggle.active { transform: scale(1.02); box-shadow: 0 0 8px rgba(255,255,255,0.2); }
+    .range-toggle.active.btn-outline-primary { background: #0d6efd; color: #fff; }
+    .range-toggle.active.btn-outline-warning { background: #ffc107; color: #000; }
+    .range-toggle.active.btn-outline-info { background: #0dcaf0; color: #000; }
+    /* Range slider styling */
+    .range-slider-row { background: #343a40; border-radius: 8px; padding: 12px; margin-bottom: 10px; }
+    .range-slider-row:hover { background: #3d444b; }
+    .dual-range-container { position: relative; height: 40px; }
+    .dual-range-track { position: absolute; top: 50%; left: 0; right: 0; height: 8px; background: #495057; border-radius: 4px; transform: translateY(-50%); }
+    .dual-range-highlight { position: absolute; top: 50%; height: 8px; background: linear-gradient(90deg, #0d6efd, #0dcaf0); border-radius: 4px; transform: translateY(-50%); }
+    .dual-range-container input[type="range"] { position: absolute; top: 0; left: 0; width: 100%; height: 100%; -webkit-appearance: none; background: transparent; pointer-events: none; }
+    .dual-range-container input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 24px; height: 24px; background: #fff; border: 3px solid #0d6efd; border-radius: 50%; cursor: pointer; pointer-events: auto; box-shadow: 0 2px 6px rgba(0,0,0,0.3); transition: transform 0.15s; }
+    .dual-range-container input[type="range"]::-webkit-slider-thumb:hover { transform: scale(1.15); }
+    .dual-range-container input[type="range"]::-moz-range-thumb { width: 24px; height: 24px; background: #fff; border: 3px solid #0d6efd; border-radius: 50%; cursor: pointer; pointer-events: auto; box-shadow: 0 2px 6px rgba(0,0,0,0.3); }
+</style>
+{% endblock %}
+
 {% block content %}
 <div class="container mt-5">
     <div class="card bg-dark text-white">
-        <div class="card-header d-flex justify-content-between align-items-center">
+        <div class="card-header d-flex justify-content-between align-items-center flex-wrap gap-2">
             <h2>Edit NeetPrep Questions</h2>
-            <a href="/neetprep" class="btn btn-outline-light">Back to NeetPrep Home</a>
+            <div class="d-flex gap-2">
+                <button type="button" class="btn btn-warning" data-bs-toggle="modal" data-bs-target="#manualClassificationModal">
+                    <i class="bi bi-list-check"></i> Manual Classification
+                </button>
+                <a href="/neetprep" class="btn btn-outline-light">Back to NeetPrep Home</a>
+            </div>
         </div>
         <div class="card-body">
             <!-- Filter Form -->
@@ -18,8 +64,11 @@
                 <div class="col-md-4">
                     <select id="topic-filter" class="form-select bg-dark text-white">
                         <option value="all">All Topics</option>
+                        <option value="Unclassified" selected>Unclassified Only</option>
                         {% for topic in topics %}
+                        {% if topic != 'Unclassified' %}
                         <option value="{{ topic }}">{{ topic }}</option>
+                        {% endif %}
                         {% endfor %}
                     </select>
                 </div>
@@ -30,6 +79,7 @@
                 <table class="table table-dark table-hover">
                     <thead>
                         <tr>
+                            <th style="width: 40px;">#</th>
                             <th>Question Text</th>
                             <th>Topic</th>
                             <th>Subject</th>
@@ -38,16 +88,17 @@
                     </thead>
                     <tbody id="questions-table-body">
                         {% for q in questions %}
-                        <tr data-topic="{{ q.topic }}">
-                            <td>{{ q.question_text_plain }}</td>
+                        <tr data-topic="{{ q.topic }}" data-id="{{ q.id }}" data-index="{{ loop.index }}" data-html="{{ q.question_text | e }}">
+                            <td>{{ loop.index }}</td>
+                            <td class="question-text-cell">{{ q.question_text_plain[:100] }}{% if q.question_text_plain|length > 100 %}...{% endif %}</td>
                             <td class="topic-cell">{{ q.topic }}</td>
                             <td class="subject-cell">{{ q.subject }}</td>
                             <td>
-                                <button class="btn btn-sm btn-primary edit-btn" 
-                                        data-id="{{ q.id }}" 
-                                        data-topic="{{ q.topic }}" 
-                                        data-subject="{{ q.subject }}" 
-                                        data-bs-toggle="modal" 
+                                <button class="btn btn-sm btn-primary edit-btn"
+                                        data-id="{{ q.id }}"
+                                        data-topic="{{ q.topic }}"
+                                        data-subject="{{ q.subject }}"
+                                        data-bs-toggle="modal"
                                         data-bs-target="#editModal">
                                     Edit
                                 </button>
@@ -61,7 +112,7 @@
     </div>
 </div>
 
-<!-- Edit Modal -->
+<!-- Edit Modal (Single Question) -->
 <div class="modal fade" id="editModal" tabindex="-1" aria-labelledby="editModalLabel" aria-hidden="true">
     <div class="modal-dialog">
         <div class="modal-content bg-dark text-white">
@@ -89,10 +140,515 @@
         </div>
     </div>
 </div>
+
+<!-- Manual Classification Setup Modal -->
+<div class="modal fade" id="manualClassificationModal" tabindex="-1">
+    <div class="modal-dialog modal-lg">
+        <div class="modal-content bg-dark text-white">
+            <div class="modal-header border-secondary">
+                <h5 class="modal-title"><i class="bi bi-list-check me-2"></i>Quick Classification</h5>
+                <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
+            </div>
+            <div class="modal-body">
+                <div class="alert alert-info border-0 mb-3">
+                    <i class="bi bi-lightning-fill me-2"></i>
+                    <span id="visible-count-info">Classify filtered questions with AI-powered suggestions.</span>
+                </div>
+
+                <!-- Quick Range Toggles -->
+                <div class="mb-3">
+                    <label class="form-label">Quick Select</label>
+                    <div class="d-flex flex-wrap gap-2">
+                        <button type="button" class="btn btn-outline-primary range-toggle active" data-range="all">
+                            <i class="bi bi-collection me-1"></i>All Visible
+                        </button>
+                        <button type="button" class="btn btn-outline-warning range-toggle" data-range="unclassified">
+                            <i class="bi bi-question-circle me-1"></i>Unclassified
+                        </button>
+                        <button type="button" class="btn btn-outline-info range-toggle" data-range="custom">
+                            <i class="bi bi-sliders me-1"></i>Custom Range
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Custom Range Slider UI -->
+                <div id="custom-range-container" class="d-none">
+                    <div class="card bg-secondary mb-3">
+                        <div class="card-body">
+                            <div class="d-flex justify-content-between align-items-center mb-2">
+                                <label class="form-label mb-0">Select Question Ranges</label>
+                                <button type="button" class="btn btn-sm btn-success" onclick="addRangeSlider()">
+                                    <i class="bi bi-plus-lg me-1"></i>Add Range
+                                </button>
+                            </div>
+
+                            <div id="range-sliders-container">
+                                <!-- Range sliders will be added here -->
+                            </div>
+
+                            <div class="mt-3 p-2 bg-dark rounded">
+                                <small class="text-muted">Selected: </small>
+                                <span id="selected-ranges-display" class="text-info fw-bold">None</span>
+                                <small class="text-muted ms-2">(<span id="selected-count">0</span> questions)</small>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Preview Section -->
+                    <div class="row" id="range-preview-section">
+                        <div class="col-6">
+                            <div class="card bg-secondary">
+                                <div class="card-header py-1 text-center">
+                                    <small class="text-success"><i class="bi bi-arrow-right-circle me-1"></i>Start</small>
+                                </div>
+                                <div class="card-body p-2">
+                                    <div id="preview-start-text" class="small" style="max-height: 60px; overflow: hidden;"></div>
+                                    <div class="mt-1"><span class="badge bg-primary" id="preview-start-num">#1</span></div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="card bg-secondary">
+                                <div class="card-header py-1 text-center">
+                                    <small class="text-danger"><i class="bi bi-arrow-left-circle me-1"></i>End</small>
+                                </div>
+                                <div class="card-body p-2">
+                                    <div id="preview-end-text" class="small" style="max-height: 60px; overflow: hidden;"></div>
+                                    <div class="mt-1"><span class="badge bg-primary" id="preview-end-num">#1</span></div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="modal-footer border-secondary">
+                <button type="button" class="btn btn-lg btn-primary w-100" onclick="startManualClassification()">
+                    <i class="bi bi-play-fill me-2"></i>Start Classification
+                </button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Topic Selection Wizard Modal -->
+<div class="modal fade" id="topicSelectionModal" tabindex="-1" data-bs-backdrop="static" data-bs-keyboard="false">
+    <div class="modal-dialog modal-lg modal-dialog-centered">
+        <div class="modal-content bg-dark text-white border-secondary">
+            <div class="modal-header border-secondary py-2">
+                <div class="d-flex align-items-center gap-3">
+                    <span class="badge bg-primary fs-6" id="topic_q_num">#1</span>
+                    <div class="progress flex-grow-1" style="width: 150px; height: 6px;">
+                        <div class="progress-bar" id="topic_progress_bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+                    <small id="topic_progress" class="text-muted">1/10</small>
+                </div>
+                <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
+            </div>
+            <div class="modal-body">
+                <!-- Question Display -->
+                <div class="mb-3 p-3 bg-black bg-opacity-25 rounded border border-secondary" style="max-height: 180px; overflow-y: auto;">
+                    <div id="topic_q_text" class="text-white"></div>
+                </div>
+
+                <!-- Subject Selection (Auto-detected, editable) -->
+                <div class="mb-3">
+                    <label class="form-label small text-muted mb-2">Subject (click to change)</label>
+                    <div id="subject_pills" class="d-flex flex-wrap gap-2">
+                        <button type="button" class="btn btn-outline-success subject-pill" data-subject="Biology">
+                            <i class="bi bi-flower1 me-1"></i>Biology
+                        </button>
+                        <button type="button" class="btn btn-outline-warning subject-pill" data-subject="Chemistry">
+                            <i class="bi bi-droplet me-1"></i>Chemistry
+                        </button>
+                        <button type="button" class="btn btn-outline-info subject-pill" data-subject="Physics">
+                            <i class="bi bi-lightning me-1"></i>Physics
+                        </button>
+                        <button type="button" class="btn btn-outline-danger subject-pill" data-subject="Mathematics">
+                            <i class="bi bi-calculator me-1"></i>Mathematics
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Chapter/Topic Input -->
+                <div class="mb-2">
+                    <label class="form-label small text-muted mb-2">Chapter / Topic</label>
+                    <div class="input-group input-group-lg">
+                        <input type="text" id="topic_input" class="form-control bg-dark text-white border-secondary" placeholder="Start typing or use AI...">
+                        <button class="btn btn-info" type="button" id="btn_get_suggestion" onclick="getAiSuggestion()">
+                            <span class="spinner-border spinner-border-sm d-none" role="status"></span>
+                            <i class="bi bi-stars"></i>
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Suggestions -->
+                <div id="ai_suggestion_container" class="d-none">
+                    <div id="ai_suggestion_chips" class="d-flex flex-wrap gap-2"></div>
+                </div>
+                <div id="ai_error_msg" class="alert alert-danger d-none mt-2 py-2"></div>
+            </div>
+            <div class="modal-footer border-secondary py-2">
+                <button type="button" class="btn btn-outline-secondary btn-lg px-4" onclick="prevTopicQuestion()">
+                    <i class="bi bi-chevron-left"></i>
+                </button>
+                <button type="button" class="btn btn-primary btn-lg px-5" onclick="nextTopicQuestion()">
+                    Next <i class="bi bi-chevron-right ms-1"></i>
+                </button>
+            </div>
+        </div>
+    </div>
+</div>
+            </div>
+        </div>
+    </div>
+</div>
 {% endblock %}
 
 {% block scripts %}
 <script>
+// --- Manual Classification Logic (global functions) ---
+let manualQuestionsList = [];
+let currentManualIndex = 0;
+let manualSubject = "Biology";  // Will be auto-detected
+let suggestionCache = new Map();
+let selectedRangeMode = 'all'; // 'all', 'unclassified', 'custom'
+let customRanges = []; // Array of {start, end, subject} for custom slider ranges
+let questionSubjectMap = new Map(); // Maps question index to pre-selected subject
+
+// Get question text preview by visible index
+function getQuestionPreview(visibleIndex) {
+    const visibleRows = getVisibleRows();
+    if (visibleIndex >= 0 && visibleIndex < visibleRows.length) {
+        const row = visibleRows[visibleIndex];
+        return row.querySelector('.question-text-cell').textContent.substring(0, 80) + '...';
+    }
+    return '';
+}
+
+// Get question number by visible index
+function getQuestionNumber(visibleIndex) {
+    const visibleRows = getVisibleRows();
+    if (visibleIndex >= 0 && visibleIndex < visibleRows.length) {
+        return visibleRows[visibleIndex].dataset.index;
+    }
+    return visibleIndex + 1;
+}
+
+// Add a new range slider
+function addRangeSlider() {
+    const container = document.getElementById('range-sliders-container');
+    const visibleRows = getVisibleRows();
+    const maxVal = visibleRows.length;
+
+    if (maxVal === 0) {
+        alert("No visible questions to select from.");
+        return;
+    }
+
+    const sliderId = Date.now();
+
+    const sliderHtml = `
+        <div class="range-slider-row" id="slider-row-${sliderId}" data-slider-id="${sliderId}">
+            <div class="d-flex justify-content-between align-items-center mb-2">
+                <div class="d-flex align-items-center gap-2">
+                    <span class="badge bg-success" id="start-badge-${sliderId}">Q1</span>
+                    <i class="bi bi-arrow-right text-muted"></i>
+                    <span class="badge bg-danger" id="end-badge-${sliderId}">Q${maxVal}</span>
+                </div>
+                <div class="d-flex align-items-center gap-2">
+                    <select class="form-select form-select-sm bg-dark text-white border-secondary" id="subject-${sliderId}" style="width: auto;">
+                        <option value="auto">🤖 Auto-detect</option>
+                        <option value="Biology">🌱 Biology</option>
+                        <option value="Chemistry">🧪 Chemistry</option>
+                        <option value="Physics">⚡ Physics</option>
+                        <option value="Mathematics">📐 Mathematics</option>
+                    </select>
+                    <button type="button" class="btn btn-sm btn-outline-danger" onclick="removeRangeSlider(${sliderId})">
+                        <i class="bi bi-trash"></i>
+                    </button>
+                </div>
+            </div>
+            <div class="dual-range-container">
+                <div class="dual-range-track"></div>
+                <div class="dual-range-highlight" id="highlight-${sliderId}"></div>
+                <input type="range" min="1" max="${maxVal}" value="1" class="range-start" id="start-${sliderId}"
+                       oninput="updateRangeSlider(${sliderId})">
+                <input type="range" min="1" max="${maxVal}" value="${maxVal}" class="range-end" id="end-${sliderId}"
+                       oninput="updateRangeSlider(${sliderId})">
+            </div>
+        </div>
+    `;
+
+    container.insertAdjacentHTML('beforeend', sliderHtml);
+    customRanges.push({ id: sliderId, start: 1, end: maxVal, subject: 'auto' });
+
+    // Add subject change listener
+    document.getElementById(`subject-${sliderId}`).addEventListener('change', (e) => {
+        const rangeObj = customRanges.find(r => r.id === sliderId);
+        if (rangeObj) rangeObj.subject = e.target.value;
+    });
+
+    updateRangeSlider(sliderId);
+    updateSelectedRangesDisplay();
+    updateRangePreview();
+}
+
+// Update range slider visuals and values
+function updateRangeSlider(sliderId) {
+    const startInput = document.getElementById(`start-${sliderId}`);
+    const endInput = document.getElementById(`end-${sliderId}`);
+    const highlight = document.getElementById(`highlight-${sliderId}`);
+    const startBadge = document.getElementById(`start-badge-${sliderId}`);
+    const endBadge = document.getElementById(`end-badge-${sliderId}`);
+
+    let startVal = parseInt(startInput.value);
+    let endVal = parseInt(endInput.value);
+
+    // Ensure start <= end
+    if (startVal > endVal) {
+        if (startInput === document.activeElement) {
+            endInput.value = startVal;
+            endVal = startVal;
+        } else {
+            startInput.value = endVal;
+            startVal = endVal;
+        }
+    }
+
+    // Update highlight bar
+    const max = parseInt(startInput.max);
+    const leftPercent = ((startVal - 1) / (max - 1)) * 100;
+    const rightPercent = ((endVal - 1) / (max - 1)) * 100;
+    highlight.style.left = leftPercent + '%';
+    highlight.style.width = (rightPercent - leftPercent) + '%';
+
+    // Update badges with actual question numbers
+    startBadge.textContent = `#${getQuestionNumber(startVal - 1)}`;
+    endBadge.textContent = `#${getQuestionNumber(endVal - 1)}`;
+
+    // Update stored range
+    const rangeObj = customRanges.find(r => r.id === sliderId);
+    if (rangeObj) {
+        rangeObj.start = startVal;
+        rangeObj.end = endVal;
+    }
+
+    updateSelectedRangesDisplay();
+    updateRangePreview();
+}
+
+// Remove a range slider
+function removeRangeSlider(sliderId) {
+    document.getElementById(`slider-row-${sliderId}`)?.remove();
+    customRanges = customRanges.filter(r => r.id !== sliderId);
+    updateSelectedRangesDisplay();
+    updateRangePreview();
+}
+
+// Update the display of selected ranges
+function updateSelectedRangesDisplay() {
+    const display = document.getElementById('selected-ranges-display');
+    const countSpan = document.getElementById('selected-count');
+
+    if (customRanges.length === 0) {
+        display.textContent = 'None';
+        countSpan.textContent = '0';
+        return;
+    }
+
+    const rangeStrs = customRanges.map(r => {
+        const startNum = getQuestionNumber(r.start - 1);
+        const endNum = getQuestionNumber(r.end - 1);
+        return r.start === r.end ? `#${startNum}` : `#${startNum}-#${endNum}`;
+    });
+    display.textContent = rangeStrs.join(', ');
+
+    // Count unique questions
+    const indices = new Set();
+    customRanges.forEach(r => {
+        for (let i = r.start; i <= r.end; i++) indices.add(i);
+    });
+    countSpan.textContent = indices.size;
+}
+
+// Update preview text
+function updateRangePreview() {
+    if (customRanges.length === 0) return;
+
+    // Find first and last question across all ranges
+    let minQ = Infinity, maxQ = -Infinity;
+    customRanges.forEach(r => {
+        if (r.start < minQ) minQ = r.start;
+        if (r.end > maxQ) maxQ = r.end;
+    });
+
+    const startIdx = minQ - 1;
+    const endIdx = maxQ - 1;
+
+    document.getElementById('preview-start-text').textContent = getQuestionPreview(startIdx);
+    document.getElementById('preview-end-text').textContent = getQuestionPreview(endIdx);
+    document.getElementById('preview-start-num').textContent = `#${getQuestionNumber(startIdx)}`;
+    document.getElementById('preview-end-num').textContent = `#${getQuestionNumber(endIdx)}`;
+}
+
+// Setup range toggle handlers
+function setupRangeToggles() {
+    document.querySelectorAll('.range-toggle').forEach(btn => {
+        btn.addEventListener('click', () => {
+            document.querySelectorAll('.range-toggle').forEach(b => b.classList.remove('active'));
+            btn.classList.add('active');
+            selectedRangeMode = btn.dataset.range;
+
+            // Show/hide custom range container
+            const customContainer = document.getElementById('custom-range-container');
+            if (selectedRangeMode === 'custom') {
+                customContainer.classList.remove('d-none');
+                // Add initial slider if none exist
+                if (customRanges.length === 0) {
+                    addRangeSlider();
+                }
+            } else {
+                customContainer.classList.add('d-none');
+            }
+        });
+    });
+}
+
+// Subject detection keywords
+const SUBJECT_KEYWORDS = {
+    'Biology': ['cell', 'dna', 'rna', 'protein', 'enzyme', 'mitosis', 'meiosis', 'photosynthesis', 'respiration', 'chromosome', 'gene', 'mutation', 'evolution', 'species', 'organism', 'tissue', 'organ', 'plant', 'animal', 'bacteria', 'virus', 'ecology', 'ecosystem', 'biodiversity', 'reproduction', 'hormone', 'neuron', 'blood', 'heart', 'kidney', 'liver', 'digestion', 'excretion', 'inheritance', 'mendel', 'allele', 'genotype', 'phenotype', 'biomolecule', 'lipid', 'carbohydrate', 'amino acid'],
+    'Chemistry': ['atom', 'molecule', 'electron', 'proton', 'neutron', 'orbital', 'bond', 'ionic', 'covalent', 'reaction', 'oxidation', 'reduction', 'acid', 'base', 'ph', 'salt', 'equilibrium', 'mole', 'molarity', 'concentration', 'solution', 'organic', 'inorganic', 'alkane', 'alkene', 'alkyne', 'alcohol', 'aldehyde', 'ketone', 'ester', 'ether', 'amine', 'polymer', 'thermodynamics', 'enthalpy', 'entropy', 'electrochemistry', 'electrolysis', 'catalyst', 'kinetics', 'periodic table', 'element', 'compound'],
+    'Physics': ['force', 'velocity', 'acceleration', 'momentum', 'energy', 'work', 'power', 'newton', 'gravity', 'friction', 'motion', 'wave', 'frequency', 'wavelength', 'amplitude', 'sound', 'light', 'optics', 'lens', 'mirror', 'reflection', 'refraction', 'diffraction', 'interference', 'electric', 'current', 'voltage', 'resistance', 'capacitor', 'inductor', 'magnetic', 'electromagnetic', 'quantum', 'photon', 'nuclear', 'radioactive', 'thermodynamics', 'heat', 'temperature', 'pressure'],
+    'Mathematics': ['equation', 'function', 'derivative', 'integral', 'limit', 'matrix', 'determinant', 'vector', 'probability', 'statistics', 'mean', 'median', 'variance', 'trigonometry', 'sine', 'cosine', 'tangent', 'logarithm', 'exponential', 'polynomial', 'quadratic', 'linear', 'geometry', 'circle', 'triangle', 'parabola', 'ellipse', 'hyperbola', 'calculus', 'differentiation', 'integration', 'sequence', 'series', 'permutation', 'combination', 'set', 'relation', 'complex number']
+};
+
+// All NCERT chapters by subject for autocomplete
+const ALL_CHAPTERS = {
+    'Biology': [
+        'The Living World', 'Biological Classification', 'Plant Kingdom', 'Animal Kingdom',
+        'Morphology of Flowering Plants', 'Anatomy of Flowering Plants', 'Structural Organisation in Animals',
+        'Cell: The Unit of Life', 'Biomolecules', 'Cell Cycle and Cell Division',
+        'Photosynthesis in Higher Plants', 'Respiration in Plants', 'Plant Growth and Development',
+        'Breathing and Exchange of Gases', 'Body Fluids and Circulation', 'Excretory Products and their Elimination',
+        'Locomotion and Movement', 'Neural Control and Coordination', 'Chemical Coordination and Integration',
+        'Sexual Reproduction in Flowering Plants', 'Human Reproduction', 'Reproductive Health',
+        'Principles of Inheritance and Variation', 'Molecular Basis of Inheritance', 'Evolution',
+        'Health and Disease', 'Improvement in Food Production', 'Microbes in Human Welfare',
+        'Biotechnology - Principles and Processes', 'Biotechnology and Its Applications',
+        'Organisms and Populations', 'Ecosystem', 'Biodiversity and Its Conservation'
+    ],
+    'Chemistry': [
+        'Some Basic Concepts of Chemistry', 'Structure of Atom', 'Classification of Elements and Periodicity in Properties',
+        'Chemical Bonding and Molecular Structure', 'States of Matter: Gases and Liquids', 'Thermodynamics',
+        'Equilibrium', 'Redox Reactions', 'Hydrogen', 'The s-Block Elements', 'The p-Block Elements (Group 13 and 14)',
+        'Organic Chemistry – Some Basic Principles and Techniques (GOC)', 'Hydrocarbons', 'Environmental Chemistry',
+        'The Solid State', 'Solutions', 'Electrochemistry', 'Chemical Kinetics', 'Surface Chemistry',
+        'General Principles and Processes of Isolation of Elements (Metallurgy)', 'The p-Block Elements (Group 15 to 18)',
+        'The d- and f- Block Elements', 'Coordination Compounds', 'Haloalkanes and Haloarenes',
+        'Alcohols, Phenols and Ethers', 'Aldehydes, Ketones and Carboxylic Acids', 'Amines',
+        'Biomolecules', 'Polymers', 'Chemistry in Everyday Life'
+    ],
+    'Physics': [
+        'Units and Measurements', 'Motion in a Straight Line', 'Motion in a Plane', 'Laws of Motion',
+        'Work, Energy and Power', 'System of Particles and Rotational Motion', 'Gravitation',
+        'Mechanical Properties of Solids', 'Mechanical Properties of Fluids', 'Thermal Properties of Matter',
+        'Thermodynamics', 'Kinetic Theory', 'Oscillations', 'Waves',
+        'Electric Charges and Fields', 'Electrostatic Potential and Capacitance', 'Current Electricity',
+        'Moving Charges and Magnetism', 'Magnetism and Matter', 'Electromagnetic Induction',
+        'Alternating Current', 'Electromagnetic Waves', 'Ray Optics and Optical Instruments',
+        'Wave Optics', 'Dual Nature of Radiation and Matter', 'Atoms', 'Nuclei',
+        'Semiconductor Electronics: Materials, Devices and Simple Circuits', 'Communication Systems'
+    ],
+    'Mathematics': [
+        'Sets', 'Relations and Functions', 'Trigonometric Functions', 'Principle of Mathematical Induction',
+        'Complex Numbers and Quadratic Equations', 'Linear Inequalities', 'Permutations and Combinations',
+        'Binomial Theorem', 'Sequences and Series', 'Straight Lines', 'Conic Sections',
+        'Introduction to Three Dimensional Geometry', 'Limits and Derivatives', 'Mathematical Reasoning',
+        'Statistics', 'Probability', 'Inverse Trigonometric Functions', 'Matrices', 'Determinants',
+        'Continuity and Differentiability', 'Application of Derivatives', 'Integrals',
+        'Application of Integrals', 'Differential Equations', 'Vector Algebra',
+        'Three Dimensional Geometry', 'Linear Programming'
+    ]
+};
+
+function detectSubject(text) {
+    const lowerText = text.toLowerCase();
+    const scores = {};
+
+    for (const [subject, keywords] of Object.entries(SUBJECT_KEYWORDS)) {
+        scores[subject] = 0;
+        for (const keyword of keywords) {
+            if (lowerText.includes(keyword)) {
+                scores[subject]++;
+            }
+        }
+    }
+
+    // Sort by score and return top subjects
+    const sorted = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+    const topSubjects = sorted.filter(([_, score]) => score > 0).slice(0, 2).map(([subj, _]) => subj);
+
+    return topSubjects.length > 0 ? topSubjects : ['Biology'];  // Default to Biology
+}
+
+function setActiveSubject(subject) {
+    manualSubject = subject;
+    document.querySelectorAll('.subject-pill').forEach(pill => {
+        if (pill.dataset.subject === subject) {
+            pill.classList.remove('btn-outline-success', 'btn-outline-warning', 'btn-outline-info', 'btn-outline-danger');
+            pill.classList.add('btn-success', 'btn-warning', 'btn-info', 'btn-danger');
+            // Keep the appropriate color
+            if (subject === 'Biology') { pill.className = 'btn btn-success subject-pill'; }
+            else if (subject === 'Chemistry') { pill.className = 'btn btn-warning subject-pill'; }
+            else if (subject === 'Physics') { pill.className = 'btn btn-info subject-pill'; }
+            else if (subject === 'Mathematics') { pill.className = 'btn btn-danger subject-pill'; }
+        } else {
+            // Reset to outline
+            if (pill.dataset.subject === 'Biology') { pill.className = 'btn btn-outline-success subject-pill'; }
+            else if (pill.dataset.subject === 'Chemistry') { pill.className = 'btn btn-outline-warning subject-pill'; }
+            else if (pill.dataset.subject === 'Physics') { pill.className = 'btn btn-outline-info subject-pill'; }
+            else if (pill.dataset.subject === 'Mathematics') { pill.className = 'btn btn-outline-danger subject-pill'; }
+        }
+    });
+}
+
+function getVisibleRows() {
+    // Get only currently visible (filtered) rows
+    return Array.from(document.querySelectorAll('#questions-table-body tr')).filter(row => row.style.display !== 'none');
+}
+
+function updateTypingSuggestions(inputValue) {
+    const container = document.getElementById('ai_suggestion_container');
+    const chipsContainer = document.getElementById('ai_suggestion_chips');
+
+    if (!inputValue || inputValue.length < 2) {
+        return;
+    }
+
+    const chapters = ALL_CHAPTERS[manualSubject] || [];
+    const searchLower = inputValue.toLowerCase();
+
+    // Filter chapters that match the input
+    const matches = chapters.filter(ch => ch.toLowerCase().includes(searchLower)).slice(0, 6);
+
+    if (matches.length > 0) {
+        container.classList.remove('d-none');
+        chipsContainer.innerHTML = '';
+
+        matches.forEach(suggestion => {
+            const chip = document.createElement('button');
+            chip.className = 'btn btn-outline-secondary btn-sm rounded-pill';
+            chip.innerText = suggestion;
+            chip.onclick = () => {
+                document.getElementById('topic_input').value = suggestion;
+                chipsContainer.innerHTML = '';
+                container.classList.add('d-none');
+            };
+            chipsContainer.appendChild(chip);
+        });
+    }
+}
+
 document.addEventListener('DOMContentLoaded', function () {
     const editModal = new bootstrap.Modal(document.getElementById('editModal'));
     const editQuestionId = document.getElementById('edit-question-id');
@@ -121,15 +677,12 @@ document.addEventListener('DOMContentLoaded', function () {
             const result = await response.json();
 
             if (result.success) {
-                // Update the table row
                 const row = document.querySelector(`button[data-id='${id}']`).closest('tr');
                 row.querySelector('.topic-cell').textContent = topic;
                 row.querySelector('.subject-cell').textContent = subject;
-                // Update the button's data attributes as well
                 const editBtn = row.querySelector('.edit-btn');
                 editBtn.dataset.topic = topic;
                 editBtn.dataset.subject = subject;
-
                 editModal.hide();
             } else {
                 alert(`Error: ${result.error}`);
@@ -153,7 +706,7 @@ document.addEventListener('DOMContentLoaded', function () {
             const row = rows[i];
             const topic = row.dataset.topic;
             const text = row.textContent || row.innerText;
-            
+
             const topicMatch = (selectedTopic === 'all' || topic === selectedTopic);
             const searchMatch = (text.toLowerCase().indexOf(searchText) > -1);
 
@@ -167,6 +720,424 @@ document.addEventListener('DOMContentLoaded', function () {
 
     searchInput.addEventListener('keyup', filterTable);
     topicFilter.addEventListener('change', filterTable);
+
+    // Apply filter on page load (default to Unclassified)
+    filterTable();
+
+    // Update visible count when modal opens
+    document.getElementById('manualClassificationModal').addEventListener('show.bs.modal', () => {
+        const visibleCount = getVisibleRows().length;
+        document.getElementById('visible-count-info').textContent =
+            `${visibleCount} questions currently visible. Classification will apply to these.`;
+        // Reset slider state when modal opens
+        customRanges = [];
+        document.getElementById('range-sliders-container').innerHTML = '';
+        document.getElementById('custom-range-container').classList.add('d-none');
+        document.querySelectorAll('.range-toggle').forEach(b => b.classList.toggle('active', b.dataset.range === 'all'));
+        selectedRangeMode = 'all';
+    });
+
+    // Setup range toggles
+    setupRangeToggles();
+
+    // Live autocomplete as user types in topic input
+    document.getElementById('topic_input').addEventListener('input', (e) => {
+        updateTypingSuggestions(e.target.value);
+    });
 });
+
+function parseRange(rangeStr, maxVal) {
+    const indices = new Set();
+    const parts = rangeStr.split(',');
+    for (let part of parts) {
+        part = part.trim();
+        if (!part) continue;
+        if (part.includes('-')) {
+            const [start, end] = part.split('-').map(Number);
+            if (!isNaN(start) && !isNaN(end)) {
+                for (let i = start; i <= end; i++) indices.add(i);
+            }
+        } else {
+            const num = Number(part);
+            if (!isNaN(num)) indices.add(num);
+        }
+    }
+    return Array.from(indices).filter(i => i >= 1 && i <= maxVal).sort((a, b) => a - b);
+}
+
+function startManualClassification() {
+    // Get only visible (filtered) rows
+    const visibleRows = getVisibleRows();
+    const numQuestions = visibleRows.length;
+
+    if (numQuestions === 0) {
+        alert("No questions visible. Please adjust your filter.");
+        return;
+    }
+
+    // Build list based on selected mode
+    questionSubjectMap.clear();
+    if (selectedRangeMode === 'custom') {
+        // Use custom slider ranges with their subject settings
+        if (customRanges.length === 0) {
+            alert("Please add at least one range.");
+            return;
+        }
+        const visibleIndices = visibleRows.map((row, idx) => ({ idx, qIndex: parseInt(row.dataset.index) }));
+        const selectedIndices = new Set();
+        customRanges.forEach(r => {
+            for (let i = r.start; i <= r.end; i++) {
+                if (i <= visibleIndices.length) {
+                    const qIndex = visibleIndices[i - 1].qIndex;
+                    selectedIndices.add(qIndex);
+                    // Store subject for this question (if not auto)
+                    if (r.subject && r.subject !== 'auto') {
+                        questionSubjectMap.set(qIndex, r.subject);
+                    }
+                }
+            }
+        });
+        manualQuestionsList = Array.from(selectedIndices).sort((a, b) => a - b);
+    } else if (selectedRangeMode === 'unclassified') {
+        // Only unclassified from visible
+        manualQuestionsList = visibleRows
+            .filter(row => {
+                const topic = row.querySelector('.topic-cell').textContent;
+                return !topic || topic === 'Unclassified';
+            })
+            .map(row => parseInt(row.dataset.index));
+    } else {
+        // All visible questions
+        manualQuestionsList = visibleRows.map(row => parseInt(row.dataset.index));
+    }
+
+    if (manualQuestionsList.length === 0) {
+        alert("No questions match the selected criteria.");
+        return;
+    }
+
+    currentManualIndex = 0;
+    suggestionCache.clear();
+
+    const modal1 = bootstrap.Modal.getInstance(document.getElementById('manualClassificationModal'));
+    modal1.hide();
+
+    const modal2 = new bootstrap.Modal(document.getElementById('topicSelectionModal'));
+    modal2.show();
+
+    // Setup subject pill click handlers
+    document.querySelectorAll('.subject-pill').forEach(pill => {
+        pill.onclick = () => {
+            setActiveSubject(pill.dataset.subject);
+            // Clear suggestions and show loading when subject changes
+            const container = document.getElementById('ai_suggestion_container');
+            const chipsContainer = document.getElementById('ai_suggestion_chips');
+            container.classList.remove('d-none');
+            chipsContainer.innerHTML = '<span class="text-muted"><i class="bi bi-hourglass-split me-1"></i>Loading...</span>';
+            document.getElementById('topic_input').value = '';
+            // Clear cache for current question and refetch
+            const qIndex = manualQuestionsList[currentManualIndex];
+            const row = document.querySelector(`#questions-table-body tr[data-index="${qIndex}"]`);
+            if (row) {
+                suggestionCache.delete(row.dataset.id);
+                getAiSuggestion();
+            }
+        };
+    });
+
+    loadTopicQuestion();
+
+    // Prefetch suggestions for up to 30 questions in background
+    prefetchSuggestions(0, 30);
+}
+
+function prefetchSuggestions(startIndex, count) {
+    // Group questions by their pre-selected subject for batch processing
+    const subjectBatches = new Map(); // subject -> [{qIndex, questionId}]
+    const autoDetectQueue = []; // Questions without pre-selected subject
+
+    for (let i = startIndex; i < startIndex + count && i < manualQuestionsList.length; i++) {
+        const qIndex = manualQuestionsList[i];
+        const row = document.querySelector(`#questions-table-body tr[data-index="${qIndex}"]`);
+        if (!row) continue;
+        const questionId = row.dataset.id;
+
+        if (suggestionCache.has(questionId)) continue;
+
+        const preSelectedSubject = questionSubjectMap.get(qIndex);
+        if (preSelectedSubject) {
+            // Group by subject for batch processing
+            if (!subjectBatches.has(preSelectedSubject)) {
+                subjectBatches.set(preSelectedSubject, []);
+            }
+            subjectBatches.get(preSelectedSubject).push({ qIndex, questionId });
+        } else {
+            // Auto-detect: process individually
+            autoDetectQueue.push({ qIndex, questionId });
+        }
+    }
+
+    // Process batched requests (up to 8 per subject per batch)
+    for (const [subject, questions] of subjectBatches) {
+        for (let i = 0; i < questions.length; i += 8) {
+            const batch = questions.slice(i, i + 8);
+            const questionIds = batch.map(q => q.questionId);
+
+            // Create a single promise for the batch
+            const batchPromise = fetch('/neetprep/get_suggestions_batch', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ question_ids: questionIds, subject: subject })
+            })
+            .then(res => res.json())
+            .then(data => {
+                if (data.success && data.results) {
+                    return data.results; // Map of questionId -> result
+                }
+                throw new Error(data.error || 'Batch request failed');
+            })
+            .catch(err => {
+                // Return fallback for all questions in batch
+                const fallback = {};
+                questionIds.forEach(id => {
+                    fallback[id] = { status: 'error', suggestions: ['Unclassified'], subject: subject, error: err.message };
+                });
+                return fallback;
+            });
+
+            // Store promise for each question that resolves to its specific result
+            batch.forEach(q => {
+                suggestionCache.set(q.questionId, batchPromise.then(results => {
+                    const result = results[q.questionId];
+                    if (result) {
+                        return {
+                            status: 'done',
+                            suggestions: result.suggestions || ['Unclassified'],
+                            subject: result.subject || subject,
+                            otherSubjects: result.other_possible_subjects || []
+                        };
+                    }
+                    return { status: 'done', suggestions: ['Unclassified'], subject: subject, otherSubjects: [] };
+                }));
+            });
+        }
+    }
+
+    // Process auto-detect questions individually
+    for (const q of autoDetectQueue) {
+        const promise = fetch(`/neetprep/get_suggestions/${q.questionId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({})
+        })
+        .then(res => res.json())
+        .then(data => {
+            if (data.success) {
+                return {
+                    status: 'done',
+                    suggestions: data.suggestions || ['Unclassified'],
+                    subject: data.subject,
+                    otherSubjects: data.other_possible_subjects || []
+                };
+            }
+            return { status: 'done', suggestions: ['Unclassified'], subject: 'Biology' };
+        })
+        .catch(err => ({ status: 'error', suggestions: ['Unclassified'], subject: 'Biology', error: err.message }));
+
+        suggestionCache.set(q.questionId, promise);
+    }
+}
+
+function loadTopicQuestion() {
+    const qIndex = manualQuestionsList[currentManualIndex];
+    const row = document.querySelector(`#questions-table-body tr[data-index="${qIndex}"]`);
+    if (!row) return;
+
+    const questionId = row.dataset.id;
+    const questionHtml = row.dataset.html || row.querySelector('.question-text-cell').textContent;
+    const questionPlainText = row.querySelector('.question-text-cell').textContent;
+    const currentTopic = row.querySelector('.topic-cell').textContent;
+    const currentSubjectFromRow = row.querySelector('.subject-cell').textContent;
+
+    // Check if subject was pre-selected in slider, otherwise auto-detect
+    const preSelectedSubject = questionSubjectMap.get(qIndex);
+    if (preSelectedSubject) {
+        manualSubject = preSelectedSubject;
+    } else if (currentSubjectFromRow && currentSubjectFromRow !== 'Unclassified' && ALL_CHAPTERS[currentSubjectFromRow]) {
+        manualSubject = currentSubjectFromRow;
+    } else {
+        const detectedSubjects = detectSubject(questionPlainText);
+        manualSubject = detectedSubjects[0];
+    }
+    setActiveSubject(manualSubject);
+
+    // Update UI
+    document.getElementById('topic_q_num').innerText = `#${qIndex}`;
+    document.getElementById('topic_q_text').innerHTML = questionHtml;  // Render HTML
+    document.getElementById('topic_input').value = (currentTopic && currentTopic !== 'Unclassified') ? currentTopic : '';
+    document.getElementById('topic_progress').innerText = `${currentManualIndex + 1}/${manualQuestionsList.length}`;
+
+    // Update progress bar
+    const progressPercent = ((currentManualIndex + 1) / manualQuestionsList.length) * 100;
+    document.getElementById('topic_progress_bar').style.width = `${progressPercent}%`;
+
+    // Clear previous suggestions
+    document.getElementById('ai_suggestion_container').classList.add('d-none');
+    document.getElementById('ai_suggestion_chips').innerHTML = '';
+    document.getElementById('ai_error_msg').classList.add('d-none');
+
+    // Reset button
+    const btn = document.getElementById('btn_get_suggestion');
+    btn.disabled = false;
+    btn.querySelector('.spinner-border').classList.add('d-none');
+
+    // Auto-get suggestions if topic is empty
+    if (!document.getElementById('topic_input').value) {
+        getAiSuggestion();
+    }
+}
+
+async function nextTopicQuestion() {
+    // Save in background (don't await - non-blocking)
+    saveCurrentTopic();
+
+    if (currentManualIndex < manualQuestionsList.length - 1) {
+        currentManualIndex++;
+        loadTopicQuestion();
+        // Prefetch more suggestions as we progress (sliding window of 30)
+        prefetchSuggestions(currentManualIndex + 1, 30);
+    } else {
+        const modal2 = bootstrap.Modal.getInstance(document.getElementById('topicSelectionModal'));
+        modal2.hide();
+        alert("Manual classification completed!");
+        // Refresh the filter to show updated results
+        document.getElementById('topic-filter').dispatchEvent(new Event('change'));
+    }
+}
+
+function prevTopicQuestion() {
+    if (currentManualIndex > 0) {
+        currentManualIndex--;
+        loadTopicQuestion();
+    }
+}
+
+function saveCurrentTopic() {
+    const qIndex = manualQuestionsList[currentManualIndex];
+    const row = document.querySelector(`#questions-table-body tr[data-index="${qIndex}"]`);
+    if (!row) return;
+
+    const questionId = row.dataset.id;
+    const topic = document.getElementById('topic_input').value || 'Unclassified';
+
+    // Update UI immediately
+    row.querySelector('.topic-cell').textContent = topic;
+    row.querySelector('.subject-cell').textContent = manualSubject;
+    row.dataset.topic = topic;  // Update data attribute for filtering
+    const editBtn = row.querySelector('.edit-btn');
+    if (editBtn) {
+        editBtn.dataset.topic = topic;
+        editBtn.dataset.subject = manualSubject;
+    }
+
+    // Save to backend in background (fire and forget)
+    fetch(`/neetprep/update_question/${questionId}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ topic: topic, subject: manualSubject })
+    }).catch(e => console.error("Failed to save topic", e));
+}
+
+async function getAiSuggestion() {
+    const qIndex = manualQuestionsList[currentManualIndex];
+    const row = document.querySelector(`#questions-table-body tr[data-index="${qIndex}"]`);
+    if (!row) return;
+
+    const questionId = row.dataset.id;
+    const btn = document.getElementById('btn_get_suggestion');
+    const container = document.getElementById('ai_suggestion_container');
+    const chipsContainer = document.getElementById('ai_suggestion_chips');
+    const errorDiv = document.getElementById('ai_error_msg');
+
+    btn.disabled = true;
+    btn.querySelector('.spinner-border').classList.remove('d-none');
+    errorDiv.classList.add('d-none');
+
+    try {
+        let result;
+        if (suggestionCache.has(questionId)) {
+            result = await suggestionCache.get(questionId);
+        } else {
+            // Check if subject was pre-selected in slider
+            const preSelectedSubject = questionSubjectMap.get(qIndex);
+            const requestBody = preSelectedSubject
+                ? { subject: preSelectedSubject }
+                : {};  // No subject - AI will detect
+
+            const promise = fetch(`/neetprep/get_suggestions/${questionId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody)
+            })
+            .then(res => res.json())
+            .then(data => ({
+                status: 'done',
+                suggestions: data.suggestions || ['Unclassified'],
+                subject: data.subject,
+                otherSubjects: data.other_possible_subjects || []
+            }))
+            .catch(err => ({ status: 'error', suggestions: ['Unclassified'], subject: 'Biology', error: err.message }));
+
+            suggestionCache.set(questionId, promise);
+            result = await promise;
+        }
+
+        // Update subject from AI response
+        if (result.subject) {
+            setActiveSubject(result.subject);
+        }
+
+        container.classList.remove('d-none');
+        chipsContainer.innerHTML = '';
+
+        // Add a label for AI suggestions
+        const label = document.createElement('span');
+        label.className = 'badge bg-info me-2';
+        label.innerText = 'AI';
+        chipsContainer.appendChild(label);
+
+        // Show other possible subjects if detected
+        if (result.otherSubjects && result.otherSubjects.length > 0) {
+            const otherLabel = document.createElement('span');
+            otherLabel.className = 'badge bg-secondary me-2';
+            otherLabel.innerText = `Also: ${result.otherSubjects.join(', ')}`;
+            otherLabel.title = 'This question may also belong to these subjects';
+            chipsContainer.appendChild(otherLabel);
+        }
+
+        result.suggestions.forEach(suggestion => {
+            const chip = document.createElement('button');
+            chip.className = 'btn btn-outline-info btn-sm rounded-pill';
+            chip.innerText = suggestion;
+            chip.onclick = () => {
+                document.getElementById('topic_input').value = suggestion;
+            };
+            chipsContainer.appendChild(chip);
+        });
+
+        // Auto-fill if empty
+        const currentVal = document.getElementById('topic_input').value;
+        if (!currentVal && result.suggestions.length > 0) {
+            document.getElementById('topic_input').value = result.suggestions[0];
+        }
+
+    } catch (e) {
+        errorDiv.innerText = `Error: ${e.message}`;
+        errorDiv.classList.remove('d-none');
+    } finally {
+        btn.disabled = false;
+        btn.querySelector('.spinner-border').classList.add('d-none');
+    }
+}
 </script>
 {% endblock %}

templates/pdf_manager.html

@@ -128,7 +128,6 @@
     </nav>
     {% endif %}
 
-    <form id="pdf-print-form" action="/print_pdfs" method="post" target="_blank">
     <div class="row row-cols-1 row-cols-sm-2 row-cols-md-3 row-cols-lg-4 g-4">
         {% if not all_view %}
         <!-- Folders -->
@@ -168,13 +167,6 @@
                         <a href="{{ '/view_pdf_v2/' if current_user.v2_default else '/view_pdf/' }}{{ pdf.filename }}" target="_blank" class="text-white text-decoration-none">
                             <span class="fw-bold pdf-filename">{{ pdf.filename }}</span>
                         </a>
-                        <a href="intent://{{ request.host }}{{ url_for('main.download_file', filename=pdf.filename) }}#Intent;scheme={{ request.scheme }};action=android.intent.action.VIEW;type=application/pdf;end"
-                           class="ms-2 text-white text-decoration-none"
-                           title="Open in external app"
-                           style="display: inline-block; vertical-align: middle;"
-                           target="_blank">
-                            <i class="bi bi-phone ms-1"></i>
-                        </a>
                     </div>
                     <div class="form-check">
                         <input type="checkbox" class="form-check-input item-checkbox" data-item-type="pdf" value="{{ pdf.id }}" style="z-index: 2; position: relative;">
@@ -183,13 +175,6 @@
                 <div class="card-body">
                     <p class="card-text small text-muted">
                         Subject: {{ pdf.subject or 'No subject' }}
-                        <a href="intent://{{ request.host }}{{ url_for('main.download_file', filename=pdf.filename) }}#Intent;scheme={{ request.scheme }};action=android.intent.action.VIEW;type=application/pdf;end"
-                           class="ms-1 text-muted text-decoration-none"
-                           title="Open in external app"
-                           style="display: inline-block; vertical-align: middle;"
-                           target="_blank">
-                            <i class="bi bi-phone"></i>
-                        </a>
                     </p>
                     <p class="card-text">
                         {% if pdf.tags %}
@@ -203,13 +188,19 @@
                     <small class="text-muted">{{ pdf.created_at.strftime('%Y-%m-%d %I:%M %p') }}</small>
                     <div class="d-flex align-items-center gap-2">
                         {% if pdf.persist %}<i class="bi bi-pin-angle-fill text-primary" title="Persisted"></i>{% endif %}
+                        <a href="intent://{{ request.host }}{{ url_for('main.download_file', filename=pdf.filename) }}#Intent;scheme={{ request.scheme }};action=android.intent.action.VIEW;type=application/pdf;end"
+                           class="btn btn-sm btn-outline-info" title="Open in external app" target="_blank">
+                            <i class="bi bi-box-arrow-up-right"></i>
+                        </a>
+                        <a href="{{ url_for('main.download_file', filename=pdf.filename) }}" class="btn btn-sm btn-outline-success" title="Download">
+                            <i class="bi bi-download"></i>
+                        </a>
                         <div class="dropdown">
                             <button class="btn btn-sm btn-outline-secondary dropdown-toggle no-caret" type="button" data-bs-toggle="dropdown">
                                 <i class="bi bi-three-dots-vertical"></i>
                             </button>
                             <ul class="dropdown-menu dropdown-menu-dark dropdown-menu-end">
                                 <li><a class="dropdown-item edit-single-btn" href="#" data-id="{{ pdf.id }}"><i class="bi bi-info-circle me-2"></i> Details</a></li>
-                                <li><a class="dropdown-item" href="{{ url_for('main.download_file', filename=pdf.filename) }}"><i class="bi bi-download me-2"></i> Download</a></li>
                                 <li><hr class="dropdown-divider"></li>
                                 <li><a class="dropdown-item text-danger delete-item-btn" href="#" data-item-type="pdf" data-id="{{ pdf.id }}"><i class="bi bi-trash me-2"></i> Delete</a></li>
                             </ul>
@@ -220,8 +211,7 @@
         </div>
         {% endfor %}
     </div>
-    </form>
-    
+
     <!-- Modals --><!-- Create Folder Modal -->
 <div class="modal fade" id="createFolderModal" tabindex="-1">
   <div class="modal-dialog">
@@ -550,7 +540,10 @@
 
             input.addEventListener('blur', saveChanges);
             input.addEventListener('keydown', e => {
-                if (e.key === 'Enter') saveChanges();
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    saveChanges();
+                }
                 if (e.key === 'Escape') titleElement.textContent = currentName;
             });
         });
@@ -920,7 +913,7 @@
                         if (card.classList.contains('folder-card')) {
                             window.location.href = `/pdf_manager/browse/${card.dataset.path}`;
                         } else {
-                            const link = card.querySelector('a.stretched-link');
+                            const link = card.querySelector('.card-header a.text-white');
                             if (link) link.click();
                         }
                     }

templates/question_entry_v2.html

@@ -11,6 +11,30 @@
     .status-btn:hover { background: #495057; }
     .auto-extract-btn { min-width: 120px; }
 
+    /* Subject pills */
+    .subject-pill { transition: all 0.2s; }
+    .subject-pill.active { transform: scale(1.05); box-shadow: 0 0 10px rgba(255,255,255,0.3); }
+
+    /* Range toggles */
+    .range-toggle { transition: all 0.2s; }
+    .range-toggle.active { transform: scale(1.02); box-shadow: 0 0 8px rgba(255,255,255,0.2); }
+    .range-toggle.active.btn-outline-primary { background: #0d6efd; color: #fff; }
+    .range-toggle.active.btn-outline-warning { background: #ffc107; color: #000; }
+    .range-toggle.active.btn-outline-danger { background: #dc3545; color: #fff; }
+    .range-toggle.active.btn-outline-secondary { background: #6c757d; color: #fff; }
+    .range-toggle.active.btn-outline-info { background: #0dcaf0; color: #000; }
+
+    /* Range slider styling */
+    .range-slider-row { background: #343a40; border-radius: 8px; padding: 12px; margin-bottom: 10px; }
+    .range-slider-row:hover { background: #3d444b; }
+    .dual-range-container { position: relative; height: 40px; }
+    .dual-range-track { position: absolute; top: 50%; left: 0; right: 0; height: 8px; background: #495057; border-radius: 4px; transform: translateY(-50%); }
+    .dual-range-highlight { position: absolute; top: 50%; height: 8px; background: linear-gradient(90deg, #0d6efd, #0dcaf0); border-radius: 4px; transform: translateY(-50%); }
+    .dual-range-container input[type="range"] { position: absolute; top: 0; left: 0; width: 100%; height: 100%; -webkit-appearance: none; background: transparent; pointer-events: none; }
+    .dual-range-container input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 24px; height: 24px; background: #fff; border: 3px solid #0d6efd; border-radius: 50%; cursor: pointer; pointer-events: auto; box-shadow: 0 2px 6px rgba(0,0,0,0.3); transition: transform 0.15s; }
+    .dual-range-container input[type="range"]::-webkit-slider-thumb:hover { transform: scale(1.15); }
+    .dual-range-container input[type="range"]::-moz-range-thumb { width: 24px; height: 24px; background: #fff; border: 3px solid #0d6efd; border-radius: 50%; cursor: pointer; pointer-events: auto; box-shadow: 0 2px 6px rgba(0,0,0,0.3); }
+
     /* Tom Select Dark Theme */
     .ts-wrapper .ts-control, .ts-wrapper .ts-control input {
         background: #212529;
@@ -276,72 +300,163 @@
 
 <!-- Modal 1: Range & Subject -->
 <div class="modal fade" id="manualClassificationModal" tabindex="-1">
-    <div class="modal-dialog">
+    <div class="modal-dialog modal-lg">
         <div class="modal-content bg-dark text-white">
-            <div class="modal-header">
-                <h5 class="modal-title">Manual Classification Setup</h5>
+            <div class="modal-header border-secondary">
+                <h5 class="modal-title"><i class="bi bi-list-check me-2"></i>Quick Classification</h5>
                 <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
             </div>
             <div class="modal-body">
-                <div class="mb-3">
-                    <label class="form-label">Select Subject</label>
-                    <select id="manual_subject" class="form-select bg-dark text-white border-secondary">
-                        <option value="Biology">Biology</option>
-                        <option value="Chemistry">Chemistry</option>
-                        <option value="Physics">Physics</option>
-                        <option value="Mathematics">Mathematics</option>
-                    </select>
+                <div class="alert alert-info border-0 mb-3">
+                    <i class="bi bi-lightning-fill me-2"></i>
+                    Classify questions with AI-powered suggestions. Subject will be auto-detected.
                 </div>
+
+                <!-- Quick Range Toggles -->
                 <div class="mb-3">
-                    <label class="form-label">Question Range (e.g., "1-5, 8, 10-12")</label>
-                    <input type="text" id="manual_range" class="form-control bg-dark text-white border-secondary" placeholder="Leave empty for all questions">
-                    <small class="text-muted">Enter ranges like 1-5 or comma separated values.</small>
+                    <label class="form-label">Quick Select</label>
+                    <div class="d-flex flex-wrap gap-2">
+                        <button type="button" class="btn btn-outline-primary range-toggle active" data-range="all">
+                            <i class="bi bi-collection me-1"></i>All
+                        </button>
+                        <button type="button" class="btn btn-outline-warning range-toggle" data-range="unclassified">
+                            <i class="bi bi-question-circle me-1"></i>Unclassified
+                        </button>
+                        <button type="button" class="btn btn-outline-danger range-toggle" data-range="wrong">
+                            <i class="bi bi-x-circle me-1"></i>Wrong Only
+                        </button>
+                        <button type="button" class="btn btn-outline-secondary range-toggle" data-range="unattempted">
+                            <i class="bi bi-dash-circle me-1"></i>Unattempted
+                        </button>
+                        <button type="button" class="btn btn-outline-info range-toggle" data-range="custom">
+                            <i class="bi bi-sliders me-1"></i>Custom Range
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Custom Range Slider UI -->
+                <div id="custom-range-container" class="d-none">
+                    <div class="card bg-secondary mb-3">
+                        <div class="card-body">
+                            <div class="d-flex justify-content-between align-items-center mb-2">
+                                <label class="form-label mb-0">Select Question Ranges</label>
+                                <button type="button" class="btn btn-sm btn-success" onclick="addRangeSlider()">
+                                    <i class="bi bi-plus-lg me-1"></i>Add Range
+                                </button>
+                            </div>
+
+                            <div id="range-sliders-container">
+                                <!-- Range sliders will be added here -->
+                            </div>
+
+                            <div class="mt-3 p-2 bg-dark rounded">
+                                <small class="text-muted">Selected: </small>
+                                <span id="selected-ranges-display" class="text-info fw-bold">None</span>
+                                <small class="text-muted ms-2">(<span id="selected-count">0</span> questions)</small>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Preview Section -->
+                    <div class="row" id="range-preview-section">
+                        <div class="col-6">
+                            <div class="card bg-secondary">
+                                <div class="card-header py-1 text-center">
+                                    <small class="text-success"><i class="bi bi-arrow-right-circle me-1"></i>Start</small>
+                                </div>
+                                <div class="card-body p-2 text-center">
+                                    <img id="preview-start-img" src="" class="img-fluid rounded" style="max-height: 120px; object-fit: contain;">
+                                    <div class="mt-1"><span class="badge bg-primary" id="preview-start-num">#1</span></div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="card bg-secondary">
+                                <div class="card-header py-1 text-center">
+                                    <small class="text-danger"><i class="bi bi-arrow-left-circle me-1"></i>End</small>
+                                </div>
+                                <div class="card-body p-2 text-center">
+                                    <img id="preview-end-img" src="" class="img-fluid rounded" style="max-height: 120px; object-fit: contain;">
+                                    <div class="mt-1"><span class="badge bg-primary" id="preview-end-num">#1</span></div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
                 </div>
             </div>
-            <div class="modal-footer">
-                <button type="button" class="btn btn-primary" onclick="startManualClassification()">Start Classification</button>
+            <div class="modal-footer border-secondary">
+                <button type="button" class="btn btn-lg btn-primary w-100" onclick="startManualClassification()">
+                    <i class="bi bi-play-fill me-2"></i>Start Classification
+                </button>
             </div>
         </div>
     </div>
 </div>
 
 <!-- Modal 2: Topic Wizard -->
-<div class="modal fade" id="topicSelectionModal" tabindex="-1" data-bs-backdrop="static">
-    <div class="modal-dialog modal-lg">
-        <div class="modal-content bg-dark text-white">
-            <div class="modal-header">
-                <h5 class="modal-title">Classify Question <span id="topic_q_num"></span></h5>
+<div class="modal fade" id="topicSelectionModal" tabindex="-1" data-bs-backdrop="static" data-bs-keyboard="false">
+    <div class="modal-dialog modal-lg modal-dialog-centered">
+        <div class="modal-content bg-dark text-white border-secondary">
+            <div class="modal-header border-secondary py-2">
+                <div class="d-flex align-items-center gap-3">
+                    <span class="badge bg-primary fs-6" id="topic_q_num">#1</span>
+                    <div class="progress flex-grow-1" style="width: 150px; height: 6px;">
+                        <div class="progress-bar" id="topic_progress_bar" role="progressbar" style="width: 0%"></div>
+                    </div>
+                    <small id="topic_progress" class="text-muted">1/10</small>
+                </div>
                 <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
             </div>
             <div class="modal-body">
+                <!-- Question Image -->
                 <div class="text-center mb-3">
-                    <img id="topic_q_img" src="" class="img-fluid rounded" style="max-height: 200px; object-fit: contain;">
+                    <img id="topic_q_img" src="" class="img-fluid rounded border border-secondary" style="max-height: 180px; object-fit: contain;">
                 </div>
+
+                <!-- Subject Selection (Auto-detected, editable) -->
                 <div class="mb-3">
-                    <label class="form-label">Subject: <span id="topic_subject_display" class="fw-bold text-info"></span></label>
+                    <label class="form-label small text-muted mb-2">Subject (click to change)</label>
+                    <div id="subject_pills" class="d-flex flex-wrap gap-2">
+                        <button type="button" class="btn btn-outline-success subject-pill" data-subject="Biology">
+                            <i class="bi bi-flower1 me-1"></i>Biology
+                        </button>
+                        <button type="button" class="btn btn-outline-warning subject-pill" data-subject="Chemistry">
+                            <i class="bi bi-droplet me-1"></i>Chemistry
+                        </button>
+                        <button type="button" class="btn btn-outline-info subject-pill" data-subject="Physics">
+                            <i class="bi bi-lightning me-1"></i>Physics
+                        </button>
+                        <button type="button" class="btn btn-outline-danger subject-pill" data-subject="Mathematics">
+                            <i class="bi bi-calculator me-1"></i>Mathematics
+                        </button>
+                    </div>
                 </div>
-                <div class="mb-3">
-                    <label class="form-label">Chapter / Topic</label>
-                    <div class="input-group">
-                        <input type="text" id="topic_input" class="form-control bg-dark text-white border-secondary" placeholder="Enter topic...">
-                        <button class="btn btn-outline-info" type="button" id="btn_get_suggestion" onclick="getAiSuggestion()">
+
+                <!-- Chapter/Topic Input -->
+                <div class="mb-2">
+                    <label class="form-label small text-muted mb-2">Chapter / Topic</label>
+                    <div class="input-group input-group-lg">
+                        <input type="text" id="topic_input" class="form-control bg-dark text-white border-secondary" placeholder="Start typing or use AI...">
+                        <button class="btn btn-info" type="button" id="btn_get_suggestion" onclick="getAiSuggestion()">
                             <span class="spinner-border spinner-border-sm d-none" role="status"></span>
-                            ✨ Get AI Suggestion
+                            <i class="bi bi-stars"></i>
                         </button>
                     </div>
                 </div>
-                <div id="ai_suggestion_container" class="d-none mt-2">
-                    <label class="form-label text-muted small">AI Suggestions:</label>
+
+                <!-- Suggestions -->
+                <div id="ai_suggestion_container" class="d-none">
                     <div id="ai_suggestion_chips" class="d-flex flex-wrap gap-2"></div>
                 </div>
-                <div id="ai_error_msg" class="alert alert-danger d-none mt-2"></div>
+                <div id="ai_error_msg" class="alert alert-danger d-none mt-2 py-2"></div>
             </div>
-            <div class="modal-footer d-flex justify-content-between">
-                <button type="button" class="btn btn-secondary" onclick="prevTopicQuestion()">Previous</button>
-                <div>
-                    <span id="topic_progress" class="me-3 text-muted"></span>
-                    <button type="button" class="btn btn-primary" onclick="nextTopicQuestion()">Next</button>
-                </div>
+            <div class="modal-footer border-secondary py-2">
+                <button type="button" class="btn btn-outline-secondary btn-lg px-4" onclick="prevTopicQuestion()">
+                    <i class="bi bi-chevron-left"></i>
+                </button>
+                <button type="button" class="btn btn-primary btn-lg px-5" onclick="nextTopicQuestion()">
+                    Next <i class="bi bi-chevron-right ms-1"></i>
+                </button>
             </div>
         </div>
     </div>
@@ -981,8 +1096,257 @@
     // --- Manual Classification Logic ---
     let manualQuestionsList = [];
     let currentManualIndex = 0;
-    let manualSubject = "";
-    let suggestionCache = new Map(); // Stores promises or results: imageId -> {suggestions: [], status: 'pending'|'done'}
+    let manualSubject = "Biology"; // Default, will be auto-detected
+    let suggestionCache = new Map();
+    let selectedRangeMode = 'all'; // 'all', 'unclassified', 'wrong', 'unattempted', 'custom'
+    let customRanges = []; // Array of {start, end, subject} for custom slider ranges
+    let questionSubjectMap = new Map(); // Maps question index to pre-selected subject
+
+    // Get question image URL by index
+    function getQuestionImageUrl(index) {
+        const fieldset = document.querySelector(`fieldset[data-question-index="${index}"]`);
+        if (!fieldset) return '';
+        const img = fieldset.querySelector('img');
+        return img ? img.src : '';
+    }
+
+    // Get question number by index
+    function getQuestionNumber(index) {
+        const fieldset = document.querySelector(`fieldset[data-question-index="${index}"]`);
+        if (!fieldset) return index + 1;
+        const input = fieldset.querySelector('input[name^="question_number_"]');
+        return input && input.value ? input.value : (index + 1);
+    }
+
+    // Add a new range slider
+    function addRangeSlider() {
+        const container = document.getElementById('range-sliders-container');
+        const sliderId = Date.now();
+        const maxVal = numImages;
+
+        const sliderHtml = `
+            <div class="range-slider-row" id="slider-row-${sliderId}" data-slider-id="${sliderId}">
+                <div class="d-flex justify-content-between align-items-center mb-2">
+                    <div class="d-flex align-items-center gap-2">
+                        <span class="badge bg-success" id="start-badge-${sliderId}">Q1</span>
+                        <i class="bi bi-arrow-right text-muted"></i>
+                        <span class="badge bg-danger" id="end-badge-${sliderId}">Q${maxVal}</span>
+                    </div>
+                    <div class="d-flex align-items-center gap-2">
+                        <select class="form-select form-select-sm bg-dark text-white border-secondary" id="subject-${sliderId}" style="width: auto;">
+                            <option value="auto">🤖 Auto-detect</option>
+                            <option value="Biology">🌱 Biology</option>
+                            <option value="Chemistry">🧪 Chemistry</option>
+                            <option value="Physics">⚡ Physics</option>
+                            <option value="Mathematics">📐 Mathematics</option>
+                        </select>
+                        <button type="button" class="btn btn-sm btn-outline-danger" onclick="removeRangeSlider(${sliderId})">
+                            <i class="bi bi-trash"></i>
+                        </button>
+                    </div>
+                </div>
+                <div class="dual-range-container">
+                    <div class="dual-range-track"></div>
+                    <div class="dual-range-highlight" id="highlight-${sliderId}"></div>
+                    <input type="range" min="1" max="${maxVal}" value="1" class="range-start" id="start-${sliderId}"
+                           oninput="updateRangeSlider(${sliderId})">
+                    <input type="range" min="1" max="${maxVal}" value="${maxVal}" class="range-end" id="end-${sliderId}"
+                           oninput="updateRangeSlider(${sliderId})">
+                </div>
+            </div>
+        `;
+
+        container.insertAdjacentHTML('beforeend', sliderHtml);
+        customRanges.push({ id: sliderId, start: 1, end: maxVal, subject: 'auto' });
+
+        // Add subject change listener
+        document.getElementById(`subject-${sliderId}`).addEventListener('change', (e) => {
+            const rangeObj = customRanges.find(r => r.id === sliderId);
+            if (rangeObj) rangeObj.subject = e.target.value;
+        });
+
+        updateRangeSlider(sliderId);
+        updateSelectedRangesDisplay();
+        updateRangePreview();
+    }
+
+    // Update range slider visuals and values
+    function updateRangeSlider(sliderId) {
+        const startInput = document.getElementById(`start-${sliderId}`);
+        const endInput = document.getElementById(`end-${sliderId}`);
+        const highlight = document.getElementById(`highlight-${sliderId}`);
+        const startBadge = document.getElementById(`start-badge-${sliderId}`);
+        const endBadge = document.getElementById(`end-badge-${sliderId}`);
+
+        let startVal = parseInt(startInput.value);
+        let endVal = parseInt(endInput.value);
+
+        // Ensure start <= end
+        if (startVal > endVal) {
+            if (startInput === document.activeElement) {
+                endInput.value = startVal;
+                endVal = startVal;
+            } else {
+                startInput.value = endVal;
+                startVal = endVal;
+            }
+        }
+
+        // Update highlight bar
+        const max = parseInt(startInput.max);
+        const leftPercent = ((startVal - 1) / (max - 1)) * 100;
+        const rightPercent = ((endVal - 1) / (max - 1)) * 100;
+        highlight.style.left = leftPercent + '%';
+        highlight.style.width = (rightPercent - leftPercent) + '%';
+
+        // Update badges
+        startBadge.textContent = `Q${getQuestionNumber(startVal - 1)}`;
+        endBadge.textContent = `Q${getQuestionNumber(endVal - 1)}`;
+
+        // Update stored range
+        const rangeObj = customRanges.find(r => r.id === sliderId);
+        if (rangeObj) {
+            rangeObj.start = startVal;
+            rangeObj.end = endVal;
+        }
+
+        updateSelectedRangesDisplay();
+        updateRangePreview();
+    }
+
+    // Remove a range slider
+    function removeRangeSlider(sliderId) {
+        document.getElementById(`slider-row-${sliderId}`)?.remove();
+        customRanges = customRanges.filter(r => r.id !== sliderId);
+        updateSelectedRangesDisplay();
+        updateRangePreview();
+    }
+
+    // Update the display of selected ranges
+    function updateSelectedRangesDisplay() {
+        const display = document.getElementById('selected-ranges-display');
+        const countSpan = document.getElementById('selected-count');
+
+        if (customRanges.length === 0) {
+            display.textContent = 'None';
+            countSpan.textContent = '0';
+            return;
+        }
+
+        const rangeStrs = customRanges.map(r => r.start === r.end ? `${r.start}` : `${r.start}-${r.end}`);
+        display.textContent = rangeStrs.join(', ');
+
+        // Count unique questions
+        const indices = new Set();
+        customRanges.forEach(r => {
+            for (let i = r.start; i <= r.end; i++) indices.add(i);
+        });
+        countSpan.textContent = indices.size;
+    }
+
+    // Update preview images
+    function updateRangePreview() {
+        if (customRanges.length === 0) return;
+
+        // Find first and last question across all ranges
+        let minQ = Infinity, maxQ = -Infinity;
+        customRanges.forEach(r => {
+            if (r.start < minQ) minQ = r.start;
+            if (r.end > maxQ) maxQ = r.end;
+        });
+
+        const startIdx = minQ - 1;
+        const endIdx = maxQ - 1;
+
+        document.getElementById('preview-start-img').src = getQuestionImageUrl(startIdx);
+        document.getElementById('preview-end-img').src = getQuestionImageUrl(endIdx);
+        document.getElementById('preview-start-num').textContent = `#${getQuestionNumber(startIdx)}`;
+        document.getElementById('preview-end-num').textContent = `#${getQuestionNumber(endIdx)}`;
+    }
+
+    // Subject detection keywords
+    const SUBJECT_KEYWORDS = {
+        'Biology': ['cell', 'dna', 'rna', 'protein', 'enzyme', 'mitosis', 'meiosis', 'chromosome', 'gene', 'photosynthesis', 'respiration', 'nucleus', 'cytoplasm', 'membrane', 'tissue', 'organ', 'species', 'evolution', 'ecology', 'bacteria', 'virus', 'plant', 'animal', 'blood', 'heart', 'kidney', 'liver', 'neuron', 'hormone', 'digestion', 'reproduction', 'inheritance', 'mutation', 'allele', 'phenotype', 'genotype', 'ecosystem', 'biodiversity', 'nitrogen cycle', 'carbon cycle', 'food chain', 'lymph', 'antibody', 'antigen', 'vaccine', 'pathogen', 'biomolecule', 'carbohydrate', 'lipid', 'amino acid', 'nucleotide', 'atp', 'chlorophyll', 'stomata', 'xylem', 'phloem', 'transpiration', 'pollination', 'fertilization', 'embryo', 'zygote', 'gamete', 'ovary', 'testis', 'sperm', 'ovum', 'menstrual', 'placenta', 'umbilical', 'gestation', 'lactation', 'immunology', 'homeostasis'],
+        'Chemistry': ['atom', 'molecule', 'ion', 'electron', 'proton', 'neutron', 'orbital', 'bond', 'covalent', 'ionic', 'metallic', 'oxidation', 'reduction', 'redox', 'acid', 'base', 'ph', 'salt', 'solution', 'concentration', 'mole', 'molarity', 'stoichiometry', 'equilibrium', 'catalyst', 'reaction', 'organic', 'inorganic', 'hydrocarbon', 'alkane', 'alkene', 'alkyne', 'alcohol', 'aldehyde', 'ketone', 'carboxylic', 'ester', 'amine', 'amide', 'polymer', 'isomer', 'electrolysis', 'electrochemical', 'thermodynamics', 'enthalpy', 'entropy', 'gibbs', 'periodic table', 'atomic number', 'mass number', 'isotope', 'valence', 'hybridization', 'resonance', 'aromaticity', 'benzene', 'phenol', 'ether', 'haloalkane', 'grignard', 'nucleophile', 'electrophile', 'sn1', 'sn2', 'elimination', 'addition', 'substitution', 'coordination', 'ligand', 'crystal field', 'lanthanide', 'actinide', 'd-block', 'p-block', 's-block', 'f-block', 'buffer', 'titration', 'indicator', 'solubility', 'precipitation', 'colligative', 'osmotic', 'vapour pressure', 'raoult', 'henry', 'nernst', 'faraday', 'electrochemistry', 'galvanic', 'electrolytic'],
+        'Physics': ['force', 'mass', 'acceleration', 'velocity', 'momentum', 'energy', 'work', 'power', 'newton', 'gravity', 'friction', 'tension', 'torque', 'angular', 'rotational', 'oscillation', 'wave', 'frequency', 'wavelength', 'amplitude', 'sound', 'light', 'optics', 'lens', 'mirror', 'reflection', 'refraction', 'diffraction', 'interference', 'polarization', 'electric', 'current', 'voltage', 'resistance', 'capacitor', 'inductor', 'magnetic', 'electromagnetic', 'induction', 'transformer', 'generator', 'motor', 'circuit', 'ohm', 'kirchhoff', 'coulomb', 'gauss', 'ampere', 'faraday', 'lenz', 'maxwell', 'photoelectric', 'quantum', 'photon', 'electron', 'nucleus', 'radioactive', 'decay', 'fission', 'fusion', 'relativity', 'thermodynamics', 'heat', 'temperature', 'entropy', 'carnot', 'adiabatic', 'isothermal', 'isobaric', 'isochoric', 'kinetic theory', 'ideal gas', 'real gas', 'semiconductor', 'diode', 'transistor', 'logic gate', 'communication', 'modulation', 'satellite', 'doppler', 'spectrum', 'laser', 'holography', 'fibre optic', 'ray optics', 'wave optics', 'young', 'single slit', 'double slit', 'grating', 'brewster', 'malus', 'huygen'],
+        'Mathematics': ['equation', 'function', 'derivative', 'integral', 'limit', 'matrix', 'vector', 'determinant', 'polynomial', 'quadratic', 'linear', 'differential', 'probability', 'statistics', 'mean', 'median', 'variance', 'standard deviation', 'permutation', 'combination', 'trigonometry', 'sine', 'cosine', 'tangent', 'logarithm', 'exponential', 'complex number', 'real number', 'set', 'relation', 'sequence', 'series', 'arithmetic progression', 'geometric progression', 'binomial', 'conic', 'parabola', 'ellipse', 'hyperbola', 'circle', 'straight line', 'plane', 'three dimensional', 'coordinate', 'calculus', 'continuity', 'differentiability', 'maxima', 'minima', 'area under curve', 'definite integral', 'indefinite integral', 'inverse trigonometric', 'mathematical induction', 'boolean algebra']
+    };
+
+    // All NCERT chapters for autocomplete
+    const ALL_CHAPTERS = {
+        'Biology': ['The Living World', 'Biological Classification', 'Plant Kingdom', 'Animal Kingdom', 'Morphology of Flowering Plants', 'Anatomy of Flowering Plants', 'Structural Organisation in Animals', 'Cell: The Unit of Life', 'Biomolecules', 'Cell Cycle and Cell Division', 'Photosynthesis in Higher Plants', 'Respiration in Plants', 'Plant Growth and Development', 'Breathing and Exchange of Gases', 'Body Fluids and Circulation', 'Excretory Products and their Elimination', 'Locomotion and Movement', 'Neural Control and Coordination', 'Chemical Coordination and Integration', 'Reproduction in Organisms', 'Sexual Reproduction in Flowering Plants', 'Human Reproduction', 'Reproductive Health', 'Principles of Inheritance and Variation', 'Molecular Basis of Inheritance', 'Evolution', 'Human Health and Disease', 'Strategies for Enhancement in Food Production', 'Microbes in Human Welfare', 'Biotechnology: Principles and Processes', 'Biotechnology and its Applications', 'Organisms and Populations', 'Ecosystem', 'Biodiversity and Conservation', 'Environmental Issues', 'Transport in Plants', 'Mineral Nutrition', 'Digestion and Absorption'],
+        'Chemistry': ['Some Basic Concepts of Chemistry', 'Structure of Atom', 'Classification of Elements and Periodicity in Properties', 'Chemical Bonding and Molecular Structure', 'Thermodynamics', 'Equilibrium', 'Redox Reactions', 'Organic Chemistry – Some Basic Principles and Techniques (GOC)', 'Hydrocarbons', 'Hydrogen', 'The s-Block Elements', 'The p-Block Elements', 'The d- and f-Block Elements', 'Coordination Compounds', 'Haloalkanes and Haloarenes', 'Alcohols, Phenols and Ethers', 'Aldehydes, Ketones and Carboxylic Acids', 'Amines', 'Biomolecules', 'Polymers', 'Chemistry in Everyday Life', 'Electrochemistry', 'Chemical Kinetics', 'Surface Chemistry', 'General Principles and Processes of Isolation of Elements', 'Solutions', 'Solid State', 'States of Matter'],
+        'Physics': ['Physical World', 'Units and Measurements', 'Motion in a Straight Line', 'Motion in a Plane', 'Laws of Motion', 'Work, Energy and Power', 'System of Particles and Rotational Motion', 'Gravitation', 'Mechanical Properties of Solids', 'Mechanical Properties of Fluids', 'Thermal Properties of Matter', 'Thermodynamics', 'Kinetic Theory', 'Oscillations', 'Waves', 'Electric Charges and Fields', 'Electrostatic Potential and Capacitance', 'Current Electricity', 'Moving Charges and Magnetism', 'Magnetism and Matter', 'Electromagnetic Induction', 'Alternating Current', 'Electromagnetic Waves', 'Ray Optics and Optical Instruments', 'Wave Optics', 'Dual Nature of Radiation and Matter', 'Atoms', 'Nuclei', 'Semiconductor Electronics', 'Communication Systems'],
+        'Mathematics': ['Sets', 'Relations and Functions', 'Trigonometric Functions', 'Complex Numbers and Quadratic Equations', 'Linear Inequalities', 'Permutations and Combinations', 'Binomial Theorem', 'Sequences and Series', 'Straight Lines', 'Conic Sections', 'Introduction to Three Dimensional Geometry', 'Limits and Derivatives', 'Statistics', 'Probability', 'Matrices', 'Determinants', 'Continuity and Differentiability', 'Applications of Derivatives', 'Integrals', 'Applications of Integrals', 'Differential Equations', 'Vector Algebra', 'Three Dimensional Geometry', 'Linear Programming', 'Inverse Trigonometric Functions', 'Mathematical Reasoning', 'Principle of Mathematical Induction']
+    };
+
+    // Detect subject from question text
+    function detectSubject(text) {
+        if (!text) return ['Biology'];
+        const lowerText = text.toLowerCase();
+        const scores = {};
+
+        for (const [subject, keywords] of Object.entries(SUBJECT_KEYWORDS)) {
+            scores[subject] = 0;
+            for (const kw of keywords) {
+                if (lowerText.includes(kw.toLowerCase())) {
+                    scores[subject]++;
+                }
+            }
+        }
+
+        const sorted = Object.entries(scores)
+            .filter(([_, score]) => score > 0)
+            .sort((a, b) => b[1] - a[1]);
+
+        if (sorted.length === 0) return ['Biology'];
+        if (sorted.length === 1) return [sorted[0][0]];
+        return [sorted[0][0], sorted[1][0]].slice(0, 2);
+    }
+
+    // Set active subject pill
+    function setActiveSubject(subject) {
+        manualSubject = subject;
+        document.querySelectorAll('.subject-pill').forEach(pill => {
+            pill.classList.remove('active', 'btn-success', 'btn-warning', 'btn-info', 'btn-danger');
+            pill.classList.add('btn-outline-success', 'btn-outline-warning', 'btn-outline-info', 'btn-outline-danger');
+            if (pill.dataset.subject === subject) {
+                pill.classList.remove('btn-outline-success', 'btn-outline-warning', 'btn-outline-info', 'btn-outline-danger');
+                const colorMap = { 'Biology': 'btn-success', 'Chemistry': 'btn-warning', 'Physics': 'btn-info', 'Mathematics': 'btn-danger' };
+                pill.classList.add('active', colorMap[subject] || 'btn-primary');
+            }
+        });
+    }
+
+    // Update typing suggestions based on input
+    function updateTypingSuggestions() {
+        const input = document.getElementById('topic_input');
+        const container = document.getElementById('ai_suggestion_container');
+        const chipsContainer = document.getElementById('ai_suggestion_chips');
+        const query = input.value.toLowerCase().trim();
+
+        if (query.length < 2) {
+            container.classList.add('d-none');
+            return;
+        }
+
+        const chapters = ALL_CHAPTERS[manualSubject] || [];
+        const matches = chapters.filter(ch => ch.toLowerCase().includes(query)).slice(0, 5);
+
+        if (matches.length > 0) {
+            container.classList.remove('d-none');
+            chipsContainer.innerHTML = '';
+            matches.forEach(suggestion => {
+                const chip = document.createElement('button');
+                chip.className = 'btn btn-outline-info btn-sm rounded-pill';
+                chip.innerText = suggestion;
+                chip.onclick = () => { input.value = suggestion; container.classList.add('d-none'); };
+                chipsContainer.appendChild(chip);
+            });
+        } else {
+            container.classList.add('d-none');
+        }
+    }
 
     function parseRange(rangeStr, maxVal) {
         const indices = new Set();
@@ -1004,61 +1368,219 @@
     }
 
     function startManualClassification() {
-        manualSubject = document.getElementById('manual_subject').value;
-        const rangeStr = document.getElementById('manual_range').value;
-        
-        if (rangeStr.trim() === "") {
-             manualQuestionsList = Array.from({length: numImages}, (_, i) => i);
+        // Build question list based on selected mode
+        manualQuestionsList = [];
+
+        if (selectedRangeMode === 'custom') {
+            // Use custom slider ranges with their subject settings
+            if (customRanges.length === 0) {
+                alert("Please add at least one range.");
+                return;
+            }
+            const indices = new Set();
+            questionSubjectMap.clear();
+            customRanges.forEach(r => {
+                for (let i = r.start; i <= r.end; i++) {
+                    const idx = i - 1; // Convert to 0-indexed
+                    indices.add(idx);
+                    // Store subject for this question (if not auto)
+                    if (r.subject && r.subject !== 'auto') {
+                        questionSubjectMap.set(idx, r.subject);
+                    }
+                }
+            });
+            manualQuestionsList = Array.from(indices).sort((a, b) => a - b);
         } else {
-             manualQuestionsList = parseRange(rangeStr, numImages);
+            // Use quick select mode
+            document.querySelectorAll('fieldset[data-question-index]').forEach((fieldset, i) => {
+                const imageId = fieldset.querySelector('input[name^="image_id_"]').value;
+                const chapterSpan = document.getElementById(`chapter_${imageId}`);
+                const chapter = chapterSpan ? chapterSpan.innerText : '';
+                const statusSelect = fieldset.querySelector('select[name^="status_"]');
+                const status = statusSelect ? statusSelect.value : '';
+
+                let include = false;
+                switch (selectedRangeMode) {
+                    case 'all':
+                        include = true;
+                        break;
+                    case 'unclassified':
+                        include = !chapter || chapter === 'N/A' || chapter === 'Unclassified';
+                        break;
+                    case 'wrong':
+                        include = status === 'wrong';
+                        break;
+                    case 'unattempted':
+                        include = status === 'unattempted';
+                        break;
+                }
+                if (include) manualQuestionsList.push(i);
+            });
         }
 
         if (manualQuestionsList.length === 0) {
-            alert("No valid questions selected in range.");
+            alert("No questions match the selected criteria.");
             return;
         }
 
         currentManualIndex = 0;
-        suggestionCache.clear(); // Clear cache on new run
+        suggestionCache.clear();
+
+        // Setup subject pill click handlers
+        document.querySelectorAll('.subject-pill').forEach(pill => {
+            pill.onclick = () => {
+                setActiveSubject(pill.dataset.subject);
+
+                // Clear current suggestions and show loading state immediately
+                const container = document.getElementById('ai_suggestion_container');
+                const chipsContainer = document.getElementById('ai_suggestion_chips');
+                container.classList.remove('d-none');
+                chipsContainer.innerHTML = '<span class="text-muted"><i class="bi bi-hourglass-split me-1"></i>Loading suggestions...</span>';
+
+                // Clear input field for fresh suggestions
+                document.getElementById('topic_input').value = '';
+
+                // Clear cache and fetch new suggestions with the new subject
+                const globalIndex = manualQuestionsList[currentManualIndex];
+                const fieldset = document.querySelector(`fieldset[data-question-index="${globalIndex}"]`);
+                const imageId = fieldset.querySelector('input[name^="image_id_"]').value;
+                suggestionCache.delete(imageId);
+                getAiSuggestion();
+            };
+        });
+
+        // Setup typing suggestions
+        document.getElementById('topic_input').addEventListener('input', updateTypingSuggestions);
 
         const modal1 = bootstrap.Modal.getInstance(document.getElementById('manualClassificationModal'));
         modal1.hide();
-        
+
         const modal2 = new bootstrap.Modal(document.getElementById('topicSelectionModal'));
         modal2.show();
-        
+
         loadTopicQuestion();
-        
-        // Trigger prefetch for the first few questions
-        prefetchSuggestions(0, 2);
+
+        // Prefetch suggestions for first 30 questions
+        prefetchSuggestions(0, 30);
+    }
+
+    // Setup range toggle handlers
+    function setupRangeToggles() {
+        document.querySelectorAll('.range-toggle').forEach(btn => {
+            btn.addEventListener('click', () => {
+                document.querySelectorAll('.range-toggle').forEach(b => b.classList.remove('active'));
+                btn.classList.add('active');
+                selectedRangeMode = btn.dataset.range;
+
+                // Show/hide custom range container
+                const customContainer = document.getElementById('custom-range-container');
+                if (selectedRangeMode === 'custom') {
+                    customContainer.classList.remove('d-none');
+                    // Add initial slider if none exist
+                    if (customRanges.length === 0) {
+                        addRangeSlider();
+                    }
+                } else {
+                    customContainer.classList.add('d-none');
+                }
+            });
+        });
     }
 
     async function prefetchSuggestions(startIndex, count) {
+        // Group questions by their pre-selected subject for batch processing
+        const subjectBatches = new Map(); // subject -> [{globalIndex, imageId}]
+        const autoDetectQueue = []; // Questions without pre-selected subject
+
         for (let i = startIndex; i < startIndex + count && i < manualQuestionsList.length; i++) {
             const globalIndex = manualQuestionsList[i];
             const fieldset = document.querySelector(`fieldset[data-question-index="${globalIndex}"]`);
             const imageId = fieldset.querySelector('input[name^="image_id_"]').value;
-            
-            if (!suggestionCache.has(imageId)) {
-                // Initiate fetch and store the promise
-                const promise = fetch('/get_topic_suggestions', {
+
+            if (suggestionCache.has(imageId)) continue;
+
+            const preSelectedSubject = questionSubjectMap.get(globalIndex);
+            if (preSelectedSubject) {
+                // Group by subject for batch processing
+                if (!subjectBatches.has(preSelectedSubject)) {
+                    subjectBatches.set(preSelectedSubject, []);
+                }
+                subjectBatches.get(preSelectedSubject).push({ globalIndex, imageId });
+            } else {
+                // Auto-detect: process individually
+                autoDetectQueue.push({ globalIndex, imageId });
+            }
+        }
+
+        // Process batched requests (up to 8 per subject per batch)
+        for (const [subject, questions] of subjectBatches) {
+            for (let i = 0; i < questions.length; i += 8) {
+                const batch = questions.slice(i, i + 8);
+                const imageIds = batch.map(q => q.imageId);
+
+                // Create a single promise for the batch
+                const batchPromise = fetch('/get_topic_suggestions_batch', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ image_id: imageId, subject: manualSubject })
+                    body: JSON.stringify({ image_ids: imageIds, subject: subject })
                 })
                 .then(res => res.json())
                 .then(data => {
-                    if (data.success) {
-                        return { status: 'done', suggestions: data.suggestions || [data.chapter_title] };
-                    } else {
-                        throw new Error(data.error);
+                    if (data.success && data.results) {
+                        return data.results; // Map of imageId -> result
                     }
+                    throw new Error(data.error || 'Batch request failed');
                 })
-                .catch(err => ({ status: 'error', error: err.message }));
-                
-                suggestionCache.set(imageId, promise);
+                .catch(err => {
+                    // Return fallback for all images in batch
+                    const fallback = {};
+                    imageIds.forEach(id => {
+                        fallback[id] = { status: 'error', suggestions: ['Unclassified'], subject: subject, error: err.message };
+                    });
+                    return fallback;
+                });
+
+                // Store promise for each image that resolves to its specific result
+                batch.forEach(q => {
+                    suggestionCache.set(q.imageId, batchPromise.then(results => {
+                        const result = results[q.imageId];
+                        if (result) {
+                            return {
+                                status: 'done',
+                                suggestions: result.suggestions || ['Unclassified'],
+                                subject: result.subject || subject,
+                                otherSubjects: result.other_possible_subjects || []
+                            };
+                        }
+                        return { status: 'done', suggestions: ['Unclassified'], subject: subject, otherSubjects: [] };
+                    }));
+                });
             }
         }
+
+        // Process auto-detect questions individually
+        for (const q of autoDetectQueue) {
+            const promise = fetch('/get_topic_suggestions', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ image_id: q.imageId })
+            })
+            .then(res => res.json())
+            .then(data => {
+                if (data.success) {
+                    return {
+                        status: 'done',
+                        suggestions: data.suggestions || [data.chapter_title],
+                        subject: data.subject,
+                        otherSubjects: data.other_possible_subjects || []
+                    };
+                }
+                throw new Error(data.error);
+            })
+            .catch(err => ({ status: 'error', error: err.message }));
+
+            suggestionCache.set(q.imageId, promise);
+        }
     }
 
     function loadTopicQuestion() {
@@ -1068,9 +1590,19 @@
         const qNum = fieldset.querySelector('input[name^="question_number_"]').value;
         const img = fieldset.querySelector('img');
         const imgUrl = img ? img.src : '';
-        
+        const imgAlt = img ? img.alt : '';
+
+        // Check if subject was pre-selected in slider, otherwise auto-detect
+        const preSelectedSubject = questionSubjectMap.get(globalIndex);
+        if (preSelectedSubject) {
+            setActiveSubject(preSelectedSubject);
+        } else {
+            const detectedSubjects = detectSubject(imgAlt);
+            setActiveSubject(detectedSubjects[0] || 'Biology');
+        }
+
         // UI Updates
-        document.getElementById('topic_q_num').innerText = qNum;
+        document.getElementById('topic_q_num').innerText = `#${qNum || (currentManualIndex + 1)}`;
         const modalImg = document.getElementById('topic_q_img');
         if (imgUrl) {
             modalImg.src = imgUrl;
@@ -1079,50 +1611,38 @@
             modalImg.style.display = 'none';
         }
 
-        document.getElementById('topic_subject_display').innerText = manualSubject;
-        
+        // Update progress bar
+        const progressPercent = ((currentManualIndex + 1) / manualQuestionsList.length) * 100;
+        document.getElementById('topic_progress_bar').style.width = `${progressPercent}%`;
+        document.getElementById('topic_progress').innerText = `${currentManualIndex + 1}/${manualQuestionsList.length}`;
+
         const chapterSpan = document.getElementById(`chapter_${imageId}`);
         const currentChapter = chapterSpan ? chapterSpan.innerText : '';
         document.getElementById('topic_input').value = (currentChapter && currentChapter !== 'N/A' && currentChapter !== 'Unclassified') ? currentChapter : '';
-        
-        document.getElementById('topic_progress').innerText = `${currentManualIndex + 1} / ${manualQuestionsList.length}`;
-        
+
         // Clear previous suggestions
         document.getElementById('ai_suggestion_container').classList.add('d-none');
         document.getElementById('ai_suggestion_chips').innerHTML = '';
         document.getElementById('ai_error_msg').classList.add('d-none');
-        
+
         // Reset button
         const btn = document.getElementById('btn_get_suggestion');
         btn.disabled = false;
-        btn.innerHTML = `<span class="spinner-border spinner-border-sm d-none" role="status"></span> ✨ Get AI Suggestion`;
-
-        // Check cache for instant load (optional: auto-show if cached?)
-        // Let's stick to user clicking for now, or we can auto-load.
-        // The user asked "auto get multiple ai suggestions". So we should try to show them if available.
-        if (suggestionCache.has(imageId)) {
-             // If we have it (or it's loading), we can try to show it automatically or just wait for click.
-             // Given "auto get", let's simulate a click if the user hasn't entered a topic yet.
-             if (!document.getElementById('topic_input').value) {
-                 getAiSuggestion();
-             }
-        } else {
-            // Not in cache, start fetching now (prefetch logic handles this, but ensuring current is fetched)
-            prefetchSuggestions(currentManualIndex, 1);
-            if (!document.getElementById('topic_input').value) {
-                 getAiSuggestion();
-            }
+        btn.innerHTML = `<span class="spinner-border spinner-border-sm d-none" role="status"></span> <i class="bi bi-stars"></i>`;
+
+        // Auto-load suggestions if topic is empty
+        if (!document.getElementById('topic_input').value) {
+            getAiSuggestion();
         }
     }
 
     async function nextTopicQuestion() {
-        await saveCurrentTopic();
-        
+        // Save current topic (fire and forget - non-blocking)
+        saveCurrentTopic();
+
         if (currentManualIndex < manualQuestionsList.length - 1) {
             currentManualIndex++;
             loadTopicQuestion();
-            // Prefetch next few
-            prefetchSuggestions(currentManualIndex + 1, 2);
         } else {
             const modal2 = bootstrap.Modal.getInstance(document.getElementById('topicSelectionModal'));
             modal2.hide();
@@ -1137,31 +1657,29 @@
         }
     }
 
-    async function saveCurrentTopic() {
+    function saveCurrentTopic() {
         const globalIndex = manualQuestionsList[currentManualIndex];
         const fieldset = document.querySelector(`fieldset[data-question-index="${globalIndex}"]`);
         const imageId = fieldset.querySelector('input[name^="image_id_"]').value;
         const topic = document.getElementById('topic_input').value;
 
+        // Update UI immediately
         const subjectSpan = document.getElementById(`subject_${imageId}`);
         if(subjectSpan) subjectSpan.innerText = manualSubject;
-        
+
         const chapterSpan = document.getElementById(`chapter_${imageId}`);
         if(chapterSpan) chapterSpan.innerText = topic || 'Unclassified';
 
-        try {
-            await fetch('/classified/update_single', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    image_id: imageId,
-                    subject: manualSubject,
-                    chapter: topic
-                })
-            });
-        } catch (e) {
-            console.error("Failed to save topic", e);
-        }
+        // Save to backend in background (fire and forget)
+        fetch('/classified/update_single', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                image_id: imageId,
+                subject: manualSubject,
+                chapter: topic
+            })
+        }).catch(e => console.error("Failed to save topic", e));
     }
 
     async function getAiSuggestion() {
@@ -1172,7 +1690,7 @@
         const container = document.getElementById('ai_suggestion_container');
         const chipsContainer = document.getElementById('ai_suggestion_chips');
         const errorDiv = document.getElementById('ai_error_msg');
-        
+
         btn.disabled = true;
         btn.querySelector('.spinner-border').classList.remove('d-none');
         errorDiv.classList.add('d-none');
@@ -1182,27 +1700,51 @@
             if (suggestionCache.has(imageId)) {
                 result = await suggestionCache.get(imageId);
             } else {
-                // Should be covered by prefetch, but fallback just in case
+                // Check if subject was pre-selected in slider
+                const preSelectedSubject = questionSubjectMap.get(globalIndex);
+                const requestBody = preSelectedSubject
+                    ? { image_id: imageId, subject: preSelectedSubject }
+                    : { image_id: imageId };  // No subject - AI will detect
+
                 const promise = fetch('/get_topic_suggestions', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ image_id: imageId, subject: manualSubject })
+                    body: JSON.stringify(requestBody)
                 })
                 .then(res => res.json())
                 .then(data => {
-                    if (data.success) return { status: 'done', suggestions: data.suggestions || [data.chapter_title] };
+                    if (data.success) return {
+                        status: 'done',
+                        suggestions: data.suggestions || [data.chapter_title],
+                        subject: data.subject,  // AI-detected subject
+                        otherSubjects: data.other_possible_subjects || []
+                    };
                     else throw new Error(data.error);
                 })
                 .catch(err => ({ status: 'error', error: err.message }));
-                
+
                 suggestionCache.set(imageId, promise);
                 result = await promise;
             }
 
             if (result.status === 'done') {
+                // Update subject from AI response
+                if (result.subject) {
+                    setActiveSubject(result.subject);
+                }
+
                 container.classList.remove('d-none');
                 chipsContainer.innerHTML = '';
-                
+
+                // Show other possible subjects if detected
+                if (result.otherSubjects && result.otherSubjects.length > 0) {
+                    const otherLabel = document.createElement('span');
+                    otherLabel.className = 'badge bg-secondary me-2';
+                    otherLabel.innerText = `Also: ${result.otherSubjects.join(', ')}`;
+                    otherLabel.title = 'This question may also belong to these subjects';
+                    chipsContainer.appendChild(otherLabel);
+                }
+
                 result.suggestions.forEach(suggestion => {
                     const chip = document.createElement('button');
                     chip.className = 'btn btn-outline-info btn-sm rounded-pill';
@@ -1212,7 +1754,7 @@
                     };
                     chipsContainer.appendChild(chip);
                 });
-                
+
                 // Auto-fill input if empty and we have a primary suggestion
                 const currentVal = document.getElementById('topic_input').value;
                 if (!currentVal && result.suggestions.length > 0) {
@@ -1235,6 +1777,7 @@
         initializeTomSelect(); // Initialize Tom Select here
         loadSettings();
         setupEventListeners();
+        setupRangeToggles();
     });
 </script>
 {% endblock %}

templates/quiz_v2.html

@@ -12,10 +12,8 @@
     }
 
     /* --- MAIN CONTAINER (The Hammer) --- */
-    /* We force this to be exactly 88% of the screen height. 
-       The remaining 12% allows for the Navbar above it. */
     .quiz-container {
-        height: 88dvh; 
+        height: 88dvh;
         max-height: 88dvh;
         width: 100%;
         display: flex;
@@ -39,36 +37,50 @@
 
     /* --- 2. MIDDLE IMAGE AREA (Flexible) --- */
     .question-display {
-        flex: 1;           /* Fill all available space between progress and buttons */
-        min-height: 0;     /* CRITICAL: Allows this box to shrink if image is huge */
+        flex: 1;
+        min-height: 0;
         display: flex;
         justify-content: center;
         align-items: center;
         padding: 5px;
         position: relative;
-        overflow: hidden;  /* Cut off anything spilling out */
+        overflow: hidden;
     }
 
     .question-image {
         max-width: 100%;
-        max-height: 100%;  /* Force image to fit INSIDE the .question-display box */
+        max-height: 100%;
         width: auto;
         height: auto;
-        object-fit: contain; /* Maintain aspect ratio, never crop */
+        object-fit: contain;
         border-radius: 6px;
+        opacity: 0;
+        transition: opacity 0.3s ease-in;
+    }
+    .question-image.loaded {
+        opacity: 1;
+    }
+
+    /* Loading spinner for lazy load */
+    .image-loading {
+        position: absolute;
+        display: none;
+        color: #6c757d;
+    }
+    .image-loading.show {
+        display: block;
     }
 
     /* --- 3. BOTTOM CONTROLS (Fixed Height) --- */
     .quiz-controls {
-        flex-shrink: 0; /* Never shrink buttons */
-        height: 70px;   /* Fixed height for stability */
+        flex-shrink: 0;
+        height: 70px;
         display: grid;
         grid-template-columns: 1fr auto 1fr;
         align-items: center;
         padding: 0 15px;
         background-color: #212529;
         border-top: 1px solid #495057;
-        /* Ensure it sits above everything */
         z-index: 50;
     }
 
@@ -77,7 +89,7 @@
         display: none;
         background-color: #343a40;
         border-top: 1px solid #6c757d;
-        max-height: 30%; /* Only take up 30% of container when open */
+        max-height: 30%;
         overflow-y: auto;
         padding: 15px;
         font-size: 0.9rem;
@@ -86,7 +98,7 @@
 
     /* --- BUTTON STYLES --- */
     .btn-pill { border-radius: 50px; }
-    
+
     /* --- OVERLAYS --- */
     .answer-overlay {
         position: absolute;
@@ -104,6 +116,28 @@
     #your-answer-overlay { left: 10px; background: rgba(13, 110, 253, 0.9); }
     #correct-answer-overlay { right: 10px; background: rgba(25, 135, 84, 0.9); }
 
+    /* Bookmark button states */
+    .bookmark-btn.bookmarked {
+        background-color: #ffc107 !important;
+        border-color: #ffc107 !important;
+        color: #000 !important;
+    }
+    .bookmark-btn.bookmarked i::before {
+        content: "\F147"; /* bi-bookmark-fill */
+    }
+
+    /* Collection list in modal */
+    .collection-item {
+        cursor: pointer;
+        transition: background-color 0.15s;
+    }
+    .collection-item:hover {
+        background-color: #3d444b;
+    }
+    .collection-item.selected {
+        background-color: #0d6efd;
+        color: white;
+    }
 </style>
 {% endblock %}
 
@@ -116,6 +150,11 @@
 
     <!-- 2. Image (Will auto-resize to fit remaining space) -->
     <div class="question-display">
+        <div class="image-loading" id="image-loading">
+            <div class="spinner-border text-secondary" role="status">
+                <span class="visually-hidden">Loading...</span>
+            </div>
+        </div>
         <img src="" id="question-image" class="question-image" alt="Question">
         <div id="your-answer-overlay" class="answer-overlay"></div>
         <div id="correct-answer-overlay" class="answer-overlay"></div>
@@ -130,12 +169,15 @@
     <!-- 4. Controls -->
     <div class="quiz-controls">
         <!-- Left -->
-        <div>
+        <div class="d-flex gap-2">
             <button id="prev-btn" class="btn btn-secondary btn-sm btn-pill">
                 <i class="bi bi-arrow-left"></i> Prev
             </button>
+            <button id="bookmark-btn" class="btn btn-outline-warning btn-sm btn-pill bookmark-btn" title="Add to Collection">
+                <i class="bi bi-bookmark"></i>
+            </button>
         </div>
-        
+
         <!-- Center -->
         <div class="text-center">
             <button id="spoiler-btn" class="btn btn-warning btn-sm btn-pill px-3">Check Answer</button>
@@ -151,6 +193,35 @@
     </div>
 </div>
 
+<!-- Bookmark Collection Modal -->
+<div class="modal fade" id="bookmarkModal" tabindex="-1">
+    <div class="modal-dialog modal-dialog-centered">
+        <div class="modal-content bg-dark text-white">
+            <div class="modal-header border-secondary">
+                <h5 class="modal-title"><i class="bi bi-bookmark me-2"></i>Add to Collection</h5>
+                <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal"></button>
+            </div>
+            <div class="modal-body">
+                <div id="collections-list" class="mb-3">
+                    <div class="text-muted text-center py-3">Loading collections...</div>
+                </div>
+                <div class="border-top border-secondary pt-3">
+                    <div class="input-group">
+                        <input type="text" id="new-collection-name" class="form-control bg-secondary text-white border-secondary" placeholder="New collection name...">
+                        <button class="btn btn-success" id="create-collection-btn">
+                            <i class="bi bi-plus-lg"></i> Create
+                        </button>
+                    </div>
+                </div>
+            </div>
+            <div class="modal-footer border-secondary">
+                <span id="bookmark-status" class="text-muted small me-auto"></span>
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+            </div>
+        </div>
+    </div>
+</div>
+
 <script>
     const questions = {{ questions | tojson | safe }};
 </script>
@@ -161,23 +232,87 @@
 document.addEventListener('DOMContentLoaded', () => {
     let currentQuestionIndex = 0;
     const img = document.getElementById('question-image');
+    const imgLoading = document.getElementById('image-loading');
     const counter = document.getElementById('question-counter');
     const pBar = document.getElementById('progress-bar');
     const spoiler = document.getElementById('details-spoiler');
     const spoilerBtn = document.getElementById('spoiler-btn');
     const yourOv = document.getElementById('your-answer-overlay');
     const corrOv = document.getElementById('correct-answer-overlay');
+    const bookmarkBtn = document.getElementById('bookmark-btn');
+
+    // Lazy loading: preload adjacent images
+    const imageCache = new Map();
+    let collections = [];
+    let questionBookmarks = new Map(); // questionId -> [collectionIds]
+
+    function preloadImage(path) {
+        if (imageCache.has(path)) return imageCache.get(path);
+        const promise = new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => resolve(path);
+            img.onerror = reject;
+            img.src = path;
+        });
+        imageCache.set(path, promise);
+        return promise;
+    }
+
+    function getImagePath(q) {
+        let path = q.image_path;
+        // If path already starts with /, it's already an absolute URL path
+        if (path.startsWith('/')) {
+            // Convert /processed/ or /tmp/ to /neetprep/processed/ or /neetprep/tmp/
+            if (path.startsWith('/processed/')) return `/neetprep${path}`;
+            if (path.startsWith('/tmp/')) return `/neetprep${path}`;
+            return path;
+        }
+        // Handle relative paths (legacy)
+        if(path.includes('/processed/')) path = `/neetprep/processed/${path.split('/processed/')[1]}`;
+        else if(path.includes('/tmp/')) path = `/neetprep/tmp/${path.split('/tmp/')[1]}`;
+        return path;
+    }
+
+    // Preload images around current index
+    function preloadAround(index) {
+        const toPreload = [index - 1, index, index + 1, index + 2, index + 3];
+        toPreload.forEach(i => {
+            if (i >= 0 && i < questions.length) {
+                preloadImage(getImagePath(questions[i]));
+            }
+        });
+    }
 
     function loadQ(i) {
         if(i < 0 || i >= questions.length) return;
         currentQuestionIndex = i;
         const q = questions[i];
+        const path = getImagePath(q);
 
-        // Path Fix
-        let path = q.image_path;
-        if(path.includes('/processed/')) path = `/neetprep/processed/${path.split('/processed/')[1]}`;
-        else if(path.includes('/tmp/')) path = `/neetprep/tmp/${path.split('/tmp/')[1]}`;
-        img.src = path;
+        // Show loading, hide image
+        img.classList.remove('loaded');
+        imgLoading.classList.add('show');
+
+        // Check cache or load
+        if (imageCache.has(path)) {
+            imageCache.get(path).then(() => {
+                img.src = path;
+                img.classList.add('loaded');
+                imgLoading.classList.remove('show');
+            });
+        } else {
+            preloadImage(path).then(() => {
+                img.src = path;
+                img.classList.add('loaded');
+                imgLoading.classList.remove('show');
+            }).catch(() => {
+                img.src = path; // Try anyway
+                imgLoading.classList.remove('show');
+            });
+        }
+
+        // Preload adjacent images
+        preloadAround(i);
 
         // UI Updates
         counter.textContent = `${i+1} / ${questions.length}`;
@@ -203,8 +338,194 @@ document.addEventListener('DOMContentLoaded', () => {
 
         document.getElementById('prev-btn').disabled = i === 0;
         document.getElementById('next-btn').disabled = i === questions.length - 1;
+
+        // Fetch and update bookmark button state
+        const qId = q.details?.id;
+        if (qId && !questionBookmarks.has(qId)) {
+            // Fetch bookmark status if not already cached
+            fetchQuestionBookmarks(qId);
+        } else {
+            updateBookmarkButton();
+        }
+    }
+
+    function updateBookmarkButton() {
+        const q = questions[currentQuestionIndex];
+        const qId = q.details?.id;
+        if (qId && questionBookmarks.has(qId) && questionBookmarks.get(qId).length > 0) {
+            bookmarkBtn.classList.add('bookmarked');
+            bookmarkBtn.title = 'Bookmarked';
+        } else {
+            bookmarkBtn.classList.remove('bookmarked');
+            bookmarkBtn.title = 'Add to Collection';
+        }
+    }
+
+    // Fetch collections
+    async function fetchCollections() {
+        try {
+            const res = await fetch('/neetprep/collections');
+            const data = await res.json();
+            if (data.success) {
+                collections = data.collections;
+            }
+        } catch (e) {
+            console.error('Failed to fetch collections:', e);
+        }
+    }
+
+    // Fetch which collections the current question is in
+    async function fetchQuestionBookmarks(questionId) {
+        if (!questionId) return;
+        try {
+            const res = await fetch(`/neetprep/question/${questionId}/collections`);
+            const data = await res.json();
+            if (data.success) {
+                questionBookmarks.set(questionId, data.collections.map(c => c.id));
+                updateBookmarkButton();
+            }
+        } catch (e) {
+            console.error('Failed to fetch question bookmarks:', e);
+        }
+    }
+
+    // Batch fetch bookmark status for all questions
+    async function fetchAllBookmarkStatuses() {
+        const questionIds = questions
+            .map(q => q.details?.id)
+            .filter(id => id != null);
+
+        if (questionIds.length === 0) return;
+
+        try {
+            const res = await fetch('/neetprep/bookmarks/batch', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ question_ids: questionIds })
+            });
+            const data = await res.json();
+            if (data.success && data.bookmarks) {
+                // Populate the questionBookmarks map
+                for (const [qId, collectionIds] of Object.entries(data.bookmarks)) {
+                    questionBookmarks.set(qId, collectionIds);
+                }
+                updateBookmarkButton();
+            }
+        } catch (e) {
+            console.error('Failed to batch fetch bookmarks:', e);
+        }
     }
 
+    function renderCollectionsList() {
+        const list = document.getElementById('collections-list');
+        const q = questions[currentQuestionIndex];
+        const qId = q.details?.id;
+        const bookmarkedIn = questionBookmarks.get(qId) || [];
+
+        if (collections.length === 0) {
+            list.innerHTML = '<div class="text-muted text-center py-3">No collections yet. Create one below!</div>';
+            return;
+        }
+
+        list.innerHTML = collections.map(c => {
+            const isBookmarked = bookmarkedIn.includes(c.id);
+            return `
+                <div class="collection-item d-flex justify-content-between align-items-center p-2 rounded mb-1 ${isBookmarked ? 'selected' : ''}"
+                     data-id="${c.id}">
+                    <span>
+                        <i class="bi bi-folder${isBookmarked ? '-fill' : ''} me-2"></i>${c.name}
+                        <small class="text-muted">(${c.question_count || 0})</small>
+                    </span>
+                    <span>
+                        ${isBookmarked
+                            ? '<i class="bi bi-check-circle-fill text-success"></i>'
+                            : '<i class="bi bi-plus-circle text-secondary"></i>'}
+                    </span>
+                </div>
+            `;
+        }).join('');
+
+        // Add click handlers
+        list.querySelectorAll('.collection-item').forEach(item => {
+            item.onclick = async () => {
+                const collectionId = item.dataset.id;
+                const isBookmarked = bookmarkedIn.includes(collectionId);
+                const questionType = q.details?.source || 'neetprep';
+
+                try {
+                    if (isBookmarked) {
+                        // Remove bookmark
+                        await fetch('/neetprep/bookmark', {
+                            method: 'DELETE',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ question_id: qId, session_id: collectionId, question_type: questionType })
+                        });
+                        questionBookmarks.set(qId, bookmarkedIn.filter(id => id !== collectionId));
+                        document.getElementById('bookmark-status').textContent = 'Removed from collection';
+                    } else {
+                        // Add bookmark
+                        await fetch('/neetprep/bookmark', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ question_id: qId, session_id: collectionId, question_type: questionType })
+                        });
+                        questionBookmarks.set(qId, [...bookmarkedIn, collectionId]);
+                        document.getElementById('bookmark-status').textContent = 'Added to collection';
+                    }
+                    // Refresh collections count and UI
+                    await fetchCollections();
+                    renderCollectionsList();
+                    updateBookmarkButton();
+                } catch (e) {
+                    console.error('Bookmark operation failed:', e);
+                    document.getElementById('bookmark-status').textContent = 'Error: ' + e.message;
+                }
+            };
+        });
+    }
+
+    // Create new collection
+    document.getElementById('create-collection-btn').onclick = async () => {
+        const nameInput = document.getElementById('new-collection-name');
+        const name = nameInput.value.trim();
+        if (!name) return;
+
+        try {
+            const res = await fetch('/neetprep/collections/create', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name })
+            });
+            const data = await res.json();
+            if (data.success) {
+                nameInput.value = '';
+                await fetchCollections();
+                renderCollectionsList();
+                document.getElementById('bookmark-status').textContent = `Created "${name}"`;
+            }
+        } catch (e) {
+            console.error('Failed to create collection:', e);
+        }
+    };
+
+    // Bookmark button click
+    bookmarkBtn.onclick = async () => {
+        const q = questions[currentQuestionIndex];
+        const qId = q.details?.id;
+        if (!qId) {
+            alert('This question cannot be bookmarked (no ID)');
+            return;
+        }
+
+        // Fetch current bookmarks for this question
+        await fetchQuestionBookmarks(qId);
+        await fetchCollections();
+        renderCollectionsList();
+
+        const modal = new bootstrap.Modal(document.getElementById('bookmarkModal'));
+        modal.show();
+    };
+
     spoilerBtn.onclick = () => {
         if(spoiler.style.display === 'none') {
             spoiler.style.display = 'block';
@@ -225,12 +546,29 @@ document.addEventListener('DOMContentLoaded', () => {
     document.getElementById('next-btn').onclick = () => loadQ(currentQuestionIndex + 1);
 
     document.addEventListener('keydown', e => {
+        // Ignore if typing in input
+        if (e.target.tagName === 'INPUT') return;
+
         if(e.key === 'ArrowLeft') loadQ(currentQuestionIndex - 1);
         if(e.key === 'ArrowRight') loadQ(currentQuestionIndex + 1);
-        if(e.key === ' ' || e.key === 'Enter' || e.key === 'c') spoilerBtn.click();
+        if(e.key === ' ' || e.key === 'Enter' || e.key === 'c') { e.preventDefault(); spoilerBtn.click(); }
+        if(e.key === 'b') bookmarkBtn.click();
     });
 
-    if(questions.length) loadQ(0);
+    // Initial load
+    if(questions.length) {
+        fetchCollections();
+        // Batch fetch all bookmark statuses, then load first question
+        fetchAllBookmarkStatuses().then(() => {
+            // After batch fetch, ensure first question shows correct status
+            updateBookmarkButton();
+        });
+        loadQ(0);
+        // Prefetch first few questions on initial load
+        for (let i = 0; i < Math.min(5, questions.length); i++) {
+            preloadImage(getImagePath(questions[i]));
+        }
+    }
 });
 </script>
 {% endblock %}