Major refactor: simplified navigation and code structure

app.py

@@ -10,21 +10,17 @@ import tempfile
 import sqlite3
 from datetime import datetime
 
-# Load environment variables from .env file
+# Load environment variables
 load_dotenv()
 
 SERPAPI_KEY = os.getenv("SERPAPI_KEY")
 HYPERBOLIC_API_KEY = os.getenv("HYPERBOLIC_API_KEY")
 ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
-
-# Admin password
 ADMIN_PASSWORD = "BT54iv!@"
-
-# Database setup
 DB_PATH = "students.db"
 
+# --- DATABASE FUNCTIONS ---
 def init_database():
-    """Initialize the SQLite database and create students table if it doesn't exist."""
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
     cursor.execute("""
@@ -40,14 +36,10 @@ def init_database():
     conn.close()
 
 def save_student(name, medical_school, year):
-    """Save student information to the database."""
     try:
         conn = sqlite3.connect(DB_PATH)
         cursor = conn.cursor()
-        cursor.execute(
-            "INSERT INTO students (name, medical_school, year) VALUES (?, ?, ?)",
-            (name, medical_school, year)
-        )
+        cursor.execute("INSERT INTO students (name, medical_school, year) VALUES (?, ?, ?)", (name, medical_school, year))
         conn.commit()
         conn.close()
         return True
@@ -56,1268 +48,348 @@ def save_student(name, medical_school, year):
         return False
 
 def get_all_students():
-    """Retrieve all students from the database."""
     try:
         conn = sqlite3.connect(DB_PATH)
         cursor = conn.cursor()
         cursor.execute("SELECT id, name, medical_school, year, registration_date FROM students ORDER BY registration_date DESC")
-        students = cursor.fetchall()
-        conn.close()
-        return students
-    except Exception as e:
-        print(f"Error retrieving students: {e}")
+        return cursor.fetchall()
+    except Exception:
         return []
 
-# Initialize database on startup
 init_database()
 
-
-# Hyperbolic API configuration
+# --- API CONFIGURATION ---
 HYPERBOLIC_API_URL = "https://api.hyperbolic.xyz/v1/chat/completions"
 HYPERBOLIC_MODEL = "meta-llama/Llama-3.3-70B-Instruct"
-
-# ElevenLabs API configuration
 ELEVENLABS_API_URL = "https://api.elevenlabs.io/v1/text-to-speech"
-# Using a standard "Professor" like voice (e.g., "Brian" - a deep, authoritative British voice, or similar)
-# Voice ID for "Brian": nPczCjzI2devNBz1zQrb
 ELEVENLABS_VOICE_ID = "nPczCjzI2devNBz1zQrb" 
 
+# --- LOGIC FUNCTIONS ---
 def generate_audio(text: str, student_name: str = None) -> str:
-    """
-    Generate audio from text using ElevenLabs API.
-    If student_name is provided, prepends a personalized greeting.
-    Returns path to temporary audio file or None if failed.
-    """
-    if not ELEVENLABS_API_KEY:
-        print("⚠️ ELEVENLABS_API_KEY is missing")
-        return None
-    
-    if not text:
-        print("⚠️ No text provided for audio generation")
-        return None
-    
-    # Add personalized greeting if student name is provided
-    if student_name:
-        text = f"Welcome to Viva, Doctor {student_name}, let's start. {text}"
-        
-    print(f"Generating audio for text: {text[:50]}...")
-        
+    if not ELEVENLABS_API_KEY or not text: return None
+    if student_name: text = f"Welcome to Viva, Doctor {student_name}, let's start. {text}"
     try:
         url = f"{ELEVENLABS_API_URL}/{ELEVENLABS_VOICE_ID}"
-        headers = {
-            "Accept": "audio/mpeg",
-            "Content-Type": "application/json",
-            "xi-api-key": ELEVENLABS_API_KEY
-        }
-        data = {
-            "text": text,
-            "model_id": "eleven_turbo_v2",
-            "voice_settings": {
-                "stability": 0.5,
-                "similarity_boost": 0.5
-            }
-        }
-        
+        headers = {"Accept": "audio/mpeg", "Content-Type": "application/json", "xi-api-key": ELEVENLABS_API_KEY}
+        data = {"text": text, "model_id": "eleven_turbo_v2", "voice_settings": {"stability": 0.5, "similarity_boost": 0.5}}
         response = requests.post(url, json=data, headers=headers)
-        
         if response.status_code == 200:
-            # Save to temp file
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as f:
                 f.write(response.content)
-                print(f"✅ Audio generated successfully: {f.name}")
                 return f.name
-        else:
-            print(f"❌ ElevenLabs API Error ({response.status_code}): {response.text}")
-            return None
-            
+        return None
     except Exception as e:
-        print(f"Error generating audio: {str(e)}")
+        print(f"Error generating audio: {e}")
         return None
 
 def is_anatomy_related(query: str) -> tuple[bool, str]:
-    """
-    Validate if the query is anatomy-related using the LLM.
-    Returns (is_valid, message)
-    """
-    validation_prompt = f"""You are an anatomy topic validator for medical students. 
-Determine if the following question is related to human anatomy ONLY.
-
-Question: "{query}"
-
-Respond with ONLY "YES" if it's about anatomy (structures, organs, systems, blood vessels, nerves, bones, muscles, etc.)
-Respond with ONLY "NO" if it's not about anatomy (physiology, biochemistry, pharmacology, diseases, treatments, etc.)
-
-Response:"""
-
+    prompt = f"Is this question related to human anatomy ONLY? '{query}'. Respond YES or NO."
     try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
-        }
-        
-        payload = {
-            "model": HYPERBOLIC_MODEL,
-            "messages": [{"role": "user", "content": validation_prompt}],
-            "max_tokens": 10,
-            "temperature": 0.1
-        }
-        
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"}
+        payload = {"model": HYPERBOLIC_MODEL, "messages": [{"role": "user", "content": prompt}], "max_tokens": 10}
         response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=10)
-        response.raise_for_status()
-        
-        result = response.json()
-        answer = result["choices"][0]["message"]["content"].strip().upper()
-        
-        if "YES" in answer:
-            return True, ""
-        else:
-            return False, "⚠️ Please ask questions related to anatomy only. This question appears to be about other medical topics."
-    
-    except Exception as e:
-        # If validation fails, allow the query but log the error
-        print(f"Validation error: {e}")
-        return True, ""
-
+        if "YES" in response.json()["choices"][0]["message"]["content"].upper(): return True, ""
+        return False, "⚠️ Please ask questions related to anatomy only."
+    except: return True, ""
 
 def search_anatomy_image(query: str) -> tuple[list, str]:
-    """
-    Search for anatomy images using SERPAPI Google Images.
-    Returns (list_of_image_urls, error_message)
-    """
     try:
-        params = {
-            "engine": "google_images",
-            "q": f"{query} anatomy diagram",
-            "api_key": SERPAPI_KEY,
-            "num": 10,  # Get more results for fallback
-            "safe": "active"
-        }
-        
-        response = requests.get("https://serpapi.com/search", params=params, timeout=15)
-        response.raise_for_status()
-        
-        data = response.json()
-        
-        if "images_results" in data and len(data["images_results"]) > 0:
-            # Get multiple image URLs, filter out SVG files
-            image_urls = []
-            for img in data["images_results"]:
-                url = img.get("original", "")
-                # Skip SVG files and other problematic formats
-                if url and not url.lower().endswith('.svg'):
-                    image_urls.append(url)
-            
-            if image_urls:
-                return image_urls, ""
-            else:
-                return [], "No supported image formats found (SVG files excluded)."
-        else:
-            return [], "No images found for this anatomy topic."
-    
-    except Exception as e:
-        return [], f"Error searching for images: {str(e)}"
-
-
-def download_image(image_url: str) -> Image.Image:
-    """
-    Download and return PIL Image from URL.
-    """
+        params = {"engine": "google_images", "q": f"{query} anatomy diagram", "api_key": SERPAPI_KEY, "num": 5, "safe": "active"}
+        data = requests.get("https://serpapi.com/search", params=params).json()
+        if "images_results" in data:
+            return [img["original"] for img in data["images_results"] if not img["original"].endswith('.svg')], ""
+        return [], "No images found."
+    except Exception as e: return [], str(e)
+
+def download_image(url):
     try:
-        # Add headers to mimic a browser request and avoid 403 errors
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-            'Accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Referer': 'https://www.google.com/'
-        }
-        response = requests.get(image_url, headers=headers, timeout=10)
-        response.raise_for_status()
-        img = Image.open(BytesIO(response.content))
-        return img
-    except Exception as e:
-        raise Exception(f"Error downloading image: {str(e)}")
-
+        headers = {'User-Agent': 'Mozilla/5.0'}
+        return Image.open(BytesIO(requests.get(url, headers=headers, timeout=10).content))
+    except: return None
 
 def generate_anatomy_info(query: str) -> str:
-    """
-    Generate educational information about the anatomy topic using Hyperbolic API.
-    """
     try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
-        }
-        
-        prompt = f"""You are an expert anatomy professor teaching MBBS students. Provide a detailed, high-level educational summary about: {query}
-
-Format your response with clear sections using these exact emoji icons:
-
-📍 **Location & Definition:**
-[Precise anatomical definition, location, and relations using standard medical terminology]
-
-🔍 **Key Anatomical Features:**
-- [Detailed feature 1 (e.g., attachments, blood supply, innervation)]
-- [Detailed feature 2]
-- [Detailed feature 3]
-
-🏥 **Clinical Significance:**
-- [Clinical correlation 1 (e.g., pathologies, surgical relevance)]
-- [Clinical correlation 2]
-
-🔗 **Related Structures:**
-- [Related structure 1]
-- [Related structure 2]
-
-💡 **Quick Memory Tip:**
-[A high-yield mnemonic or tip for exams]
-
-Keep it professional, accurate, and suitable for medical school level study. Use proper anatomical terminology throughout."""
-
-        payload = {
-            "model": HYPERBOLIC_MODEL,
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": 600,
-            "temperature": 0.7
-        }
-        
-        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=20)
-        response.raise_for_status()
-        
-        result = response.json()
-        info = result["choices"][0]["message"]["content"]
-        
-        # Add prominent header to make it stand out
-        formatted_info = f"""## 📚 Key Learning Points
-
-{info}
-
----
-💪 **Study Tip:** Read through these points carefully, then test yourself with VIVA mode!"""
-        
-        return formatted_info
-    
-    except Exception as e:
-        return f"⚠️ Error generating information: {str(e)}"
-
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"}
+        prompt = f"Provide a detailed anatomy summary for medical students about: {query}. Use emojis for sections."
+        payload = {"model": HYPERBOLIC_MODEL, "messages": [{"role": "user", "content": prompt}], "max_tokens": 600}
+        return requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload).json()["choices"][0]["message"]["content"]
+    except Exception as e: return f"Error: {e}"
 
 def generate_viva_questions(topic: str) -> list:
-    """
-    Generate 5 viva questions for the anatomy topic.
-    Returns list of question dictionaries with question, hint, and expected answer.
-    """
     try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
-        }
-        
-        prompt = f"""You are a strict but fair anatomy professor conducting a VIVA exam for final year MBBS students on: {topic}
-
-Generate exactly 5 viva questions that test deep anatomical understanding, clinical application, and relations. For each question, provide:
-1. The question (challenging, requiring synthesis of knowledge)
-2. A helpful hint (guides thinking without giving the answer)
-3. The expected key points in the answer (using proper terminology)
-
-Format your response EXACTLY as follows:
-Q1: [question]
-HINT: [hint]
-ANSWER: [expected answer key points]
-
-Q2: [question]
-HINT: [hint]
-ANSWER: [expected answer key points]
-
-... and so on for all 5 questions.
-
-Make questions progressively harder. Start with detailed relations/supply, then move to complex clinical scenarios."""
-
-        payload = {
-            "model": HYPERBOLIC_MODEL,
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": 800,
-            "temperature": 0.7
-        }
-        
-        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=25)
-        response.raise_for_status()
-        
-        result = response.json()
-        content = result["choices"][0]["message"]["content"]
-        
-        # Parse the questions
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"}
+        prompt = f"Generate 5 hard anatomy VIVA questions on: {topic}. Format: Q1: ... HINT: ... ANSWER: ..."
+        payload = {"model": HYPERBOLIC_MODEL, "messages": [{"role": "user", "content": prompt}], "max_tokens": 800}
+        content = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload).json()["choices"][0]["message"]["content"]
         questions = []
-        lines = content.split('\n')
-        current_q = {}
-        
-        for line in lines:
+        current = {}
+        for line in content.split('\n'):
             line = line.strip()
             if line.startswith('Q') and ':' in line:
-                if current_q:
-                    questions.append(current_q)
-                current_q = {'question': line.split(':', 1)[1].strip()}
-            elif line.startswith('HINT:'):
-                current_q['hint'] = line.split(':', 1)[1].strip()
-            elif line.startswith('ANSWER:'):
-                current_q['answer'] = line.split(':', 1)[1].strip()
-        
-        if current_q:
-            questions.append(current_q)
-        
-        return questions[:5]  # Ensure exactly 5 questions
-    
-    except Exception as e:
-        print(f"Error generating viva questions: {e}")
-        return []
-
-
-def evaluate_viva_answer(question: str, student_answer: str, expected_answer: str) -> tuple[str, str]:
-    """
-    Evaluate student's answer and provide feedback.
-    Returns (feedback, score_emoji)
-    """
-    if not student_answer.strip():
-        return "⏸️ Please provide an answer to continue.", "⏸️"
-    
+                if current: questions.append(current)
+                current = {'question': line.split(':', 1)[1].strip()}
+            elif line.startswith('HINT:'): current['hint'] = line.split(':', 1)[1].strip()
+            elif line.startswith('ANSWER:'): current['answer'] = line.split(':', 1)[1].strip()
+        if current: questions.append(current)
+        return questions[:5]
+    except: return []
+
+def evaluate_viva_answer(question, student_ans, expected):
+    if not student_ans.strip(): return "Please provide an answer.", "⏸️"
     try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
-        }
-        
-        prompt = f"""You are an anatomy professor evaluating an MBBS student's VIVA answer. Expect high standards and precise terminology.
-
-Question: {question}
-Expected key points: {expected_answer}
-Student's answer: {student_answer}
-
-Provide feedback in this EXACT format:
-
-[First, write one sentence evaluating the precision and depth of the answer]
-
-✅ **What was correct:**
-[List correct points. Praise use of proper terminology.]
-
-❌ **What was missing:**
-[List missing key points, relations, or clinical aspects. Be specific about missing terminology.]
-
-**Score:** [Choose: DISTINCTION, PASS, BORDERLINE, or FAIL]
-
-[End with a constructive comment on how to improve to a professional medical standard]
-
-Be professional and constructive. Demand accuracy."""
-
-        payload = {
-            "model": HYPERBOLIC_MODEL,
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": 400,
-            "temperature": 0.6
-        }
-        
-        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=15)
-        response.raise_for_status()
-        
-        result = response.json()
-        feedback = result["choices"][0]["message"]["content"]
-        
-        # Determine emoji and encouragement based on feedback content
-        feedback_upper = feedback.upper()
-        if "DISTINCTION" in feedback_upper:
-            emoji = "🌟"
-            encouragement = "\n\n🎉 **Outstanding!** Distinction level answer! You're mastering this topic!"
-        elif "PASS" in feedback_upper:
-            emoji = "✅"
-            encouragement = "\n\n👏 **Good Pass!** Solid understanding. Review the finer details to reach distinction level."
-        elif "BORDERLINE" in feedback_upper:
-            emoji = "⚠️"
-            encouragement = "\n\n💪 **Borderline.** You have the basics, but need more precision with terminology."
-        else:
-            emoji = "📚"
-            encouragement = "\n\n🌱 **Keep studying.** Focus on the key anatomical relations and clinical points."
-        
-        # Format the complete feedback
-        formatted_feedback = f"{emoji} **VIVA Feedback:**\n\n{feedback}{encouragement}\n\n---\n\n📖 **Reference Answer:**\n{expected_answer}"
-        
-        return formatted_feedback, emoji
-    
-    except Exception as e:
-        return f"⚠️ Could not evaluate answer: {str(e)}", "⚠️"
-
-
-def process_anatomy_query(query: str) -> tuple:
-    """
-    Main function to process anatomy queries.
-    Returns (image, info_text, error_message)
-    """
-    if not query.strip():
-        return None, "", "Please enter a question about anatomy."
-    
-    # Validate if query is anatomy-related
-    is_valid, validation_msg = is_anatomy_related(query)
-    if not is_valid:
-        return None, "", validation_msg
-    
-    # Search for images
-    image_urls, img_error = search_anatomy_image(query)
-    
-    # Generate educational information
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"}
+        prompt = f"Evaluate this VIVA answer. Question: {question}. Student: {student_ans}. Expected: {expected}. Give feedback and score."
+        payload = {"model": HYPERBOLIC_MODEL, "messages": [{"role": "user", "content": prompt}], "max_tokens": 400}
+        feedback = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload).json()["choices"][0]["message"]["content"]
+        emoji = "🌟" if "DISTINCTION" in feedback.upper() else "✅" if "PASS" in feedback.upper() else "⚠️"
+        return f"{emoji} **Feedback:**\n\n{feedback}\n\n📖 **Ref:** {expected}", emoji
+    except: return "Error evaluating.", "⚠️"
+
+def process_anatomy_query(query):
+    if not query.strip(): return None, "", "Enter a question."
+    valid, msg = is_anatomy_related(query)
+    if not valid: return None, "", msg
+    
+    urls, err = search_anatomy_image(query)
     info = generate_anatomy_info(query)
     
-    # Try to download images from the list until one succeeds
-    image = None
-    download_error = ""
-    
-    if image_urls:
-        for url in image_urls[:5]:  # Try up to 5 images
-            try:
-                image = download_image(url)
-                download_error = ""  # Success!
-                break  # Stop trying once we get a valid image
-            except Exception as e:
-                download_error = str(e)
-                continue  # Try next image
+    img = None
+    for url in urls:
+        img = download_image(url)
+        if img: break
         
-        if not image and download_error:
-            img_error = f"Could not download images. Last error: {download_error}"
-    
-    # Prepare result
-    error_message = ""
-    if img_error:
-        error_message = f"⚠️ {img_error}"
-    
-    return image, info, error_message
+    return img, f"## 📚 Key Learning Points\n\n{info}", err
 
-
-# Book Learning Mode Functions
 def process_uploaded_book(pdf_file):
-    """
-    Process uploaded PDF book and extract all pages with images and text.
-    Returns (list_of_tuples, status_message) where tuple is (image, caption, text)
-    """
-    if pdf_file is None:
-        return [], "Please upload a PDF file."
-    
+    if not pdf_file: return [], "No file uploaded."
     try:
-        extracted_data = []
-        
-        # Save uploaded file temporarily
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-            tmp_file.write(pdf_file)
-            tmp_path = tmp_file.name
-        
-        try:
-            # Convert all pages to images (this might take a while for large books)
-            images = convert_from_path(tmp_path, dpi=150)
-            
-            # Extract text from pages
-            reader = PyPDF2.PdfReader(tmp_path)
-            
-            for i, image in enumerate(images):
-                # Get text for this page if available
-                text_content = ""
-                if i < len(reader.pages):
-                    try:
-                        text_content = reader.pages[i].extract_text()
-                    except:
-                        text_content = "Could not extract text from this page."
-                
-                # Limit text length to avoid token limits
-                if len(text_content) > 2000:
-                    text_content = text_content[:2000] + "..."
-                
-                extracted_data.append((image, f"Page {i+1}", text_content))
-            
-            status = f"✅ Successfully processed {len(extracted_data)} pages from your anatomy textbook!"
-            return extracted_data, status
-        
-        finally:
-            # Clean up temp file
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
-    
-    except Exception as e:
-        return [], f"⚠️ Error processing PDF: {str(e)}"
-
-
-def analyze_book_image(image, page_info, page_text=""):
-    """
-    Analyze selected image from book using AI to extract anatomical information.
-    Returns formatted explanation text.
-    """
-    if image is None:
-        return "Please select an image from the book."
-    
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp:
+            tmp.write(pdf_file)
+            tmp_path = tmp.name
+        images = convert_from_path(tmp_path, dpi=150)
+        reader = PyPDF2.PdfReader(tmp_path)
+        data = []
+        for i, img in enumerate(images):
+            txt = reader.pages[i].extract_text()[:2000] if i < len(reader.pages) else ""
+            data.append((img, f"Page {i+1}", txt))
+        os.unlink(tmp_path)
+        return data, f"Processed {len(data)} pages."
+    except Exception as e: return [], f"Error: {e}"
+
+def analyze_book_image(image, page_info, page_text):
     try:
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"
-        }
-        
-        # Include extracted text in the prompt context
-        context_text = f"Page Content:\n{page_text}" if page_text else "No text extracted from this page."
-        
-        prompt = f"""You are an expert anatomy professor helping MBBS students analyze their textbook content.
-
-A student is looking at {page_info} of their anatomy textbook.
-{context_text}
-
-Based on the text content above, provide a high-level medical analysis:
-
-## 📖 Page Overview
-[Summarize the key anatomical topic using standard medical terminology]
-
-## 🔍 Key Concepts Explained
-[Explain the concepts in detail, focusing on relations, blood supply, nerve supply, and lymphatic drainage where applicable]
-
-## 🏥 Clinical Relevance
-[Detailed clinical correlations, surgical landmarks, or pathological conditions mentioned or relevant]
-
-## 💡 Study Tips
-[High-yield memory aids for medical exams]
-
-## ❓ Self-Test Questions (MBBS Level)
-1. [Question based on the page text]
-2. [Question based on the page text]
-...
-15. [Question based on the page text]
-
-(Provide at least 15 distinct, challenging questions covering detailed anatomy, relations, and clinical application)
-
-Be professional, accurate, and suitable for medical school level study."""
-
-        payload = {
-            "model": HYPERBOLIC_MODEL,
-            "messages": [{"role": "user", "content": prompt}],
-            "max_tokens": 1200,
-            "temperature": 0.5
-        }
-        
-        response = requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload, timeout=25)
-        response.raise_for_status()
-        
-        result = response.json()
-        explanation = result["choices"][0]["message"]["content"]
-        
-        formatted_output = f"""# 📚 Textbook Analysis: {page_info}
-
-{explanation}
-
----
-
-💪 **Next Steps:** Mastered this page? Try the VIVA mode to test yourself!"""
-        
-        return formatted_output
-    
-    except Exception as e:
-        return f"⚠️ Error analyzing image: {str(e)}"
-
-
-# VIVA Mode Handler Functions
-def start_viva_mode(topic, image, student_name=""):
-    """Initialize VIVA mode with questions."""
-    if not topic or not image:
-        return (
-            gr.update(visible=False),  # viva_container
-            "Please learn about a topic first before starting VIVA mode!",  # viva_status
-            None, None, None, None, None, None, [], None, student_name  # other outputs
-        )
-    
-    questions = generate_viva_questions(topic)
-    
-    if not questions or len(questions) == 0:
-        return (
-            gr.update(visible=False),
-            "Error generating VIVA questions. Please try again.",
-            None, None, None, None, None, gr.update(interactive=False), [], None, student_name
-        )
-   
-    # Start with question 1
-    q1 = questions[0]
-    
-    # Generate audio for first question with student name
-    audio_path = generate_audio(q1['question'], student_name if student_name else None)
-    
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {HYPERBOLIC_API_KEY}"}
+        prompt = f"Analyze this anatomy book page ({page_info}): {page_text}. Give summary, clinical points, and 15 study questions."
+        payload = {"model": HYPERBOLIC_MODEL, "messages": [{"role": "user", "content": prompt}], "max_tokens": 1000}
+        return requests.post(HYPERBOLIC_API_URL, headers=headers, json=payload).json()["choices"][0]["message"]["content"]
+    except Exception as e: return f"Error: {e}"
+
+def start_viva_mode(topic, image, name=""):
+    if not topic: return [gr.update()] * 11 
+    qs = generate_viva_questions(topic)
+    if not qs: return [gr.update()] * 11
+    
+    audio = generate_audio(qs[0]['question'], name)
     return (
-        gr.update(visible=True),  # Show VIVA container
-        f"**VIVA MODE ACTIVE** 📝\nTopic: {topic}",  # viva_status
-        image,  # viva_image
-        f"### Question 1 of 5\n\n**{q1['question']}**",  # current_question_display
-        f"💡 **Hint:** {q1.get('hint', 'Think about the key anatomical features.')}",  # hint_display
-        "",  # Clear answer input
-        "",  # Clear feedback
-        gr.update(interactive=True, value="Submit Answer"),  # Enable submit button
-        questions,  # Store questions in state
-        audio_path,  # Return audio path
-        student_name  # Return student name to maintain in state
+        gr.update(visible=True), # Container
+        f"**VIVA ACTIVE:** {topic}", # Status
+        image, # Image
+        f"### Q1: {qs[0]['question']}", # Q Display
+        f"💡 {qs[0].get('hint','')}", # Hint
+        "", "", # Answer, Feedback
+        gr.update(interactive=True, value="Submit"), # Button
+        qs, audio, name
     )
 
-# Wrapper to start VIVA with personalized greeting
-def start_viva_with_name(name, topic, image):
-    viva_container_out, viva_status_out, viva_image_out, cur_q_disp, hint_disp, stu_ans, fb_disp, sub_btn, viva_q_state, q_audio, student_name_out = start_viva_mode(topic, image, name)
-    greeting = f"Doctor {name}, let's go to VIVA!"
-    # Add greeting as separate markdown component above question
-    viva_greeting_out = greeting
-    return viva_container_out, viva_status_out, viva_image_out, cur_q_disp, hint_disp, stu_ans, fb_disp, sub_btn, viva_q_state, q_audio, viva_greeting_out, student_name_out
-
-
-def submit_viva_answer(answer, questions, current_q_idx, student_name=""):
-    """Process student's answer and move to next question."""
-    if not questions or current_q_idx >= len(questions):
-        return ("VIVA Complete!", "", "", gr.update(interactive=False), current_q_idx, None)
-    
-    q = questions[current_q_idx]
-    feedback_text, emoji = evaluate_viva_answer(q['question'], answer, q.get('answer', ''))
-    
-    # Move to next question
-    next_idx = current_q_idx + 1
+def submit_viva_answer_logic(ans, qs, idx, name):
+    if idx >= len(qs): return "Done", "", "", "", gr.update(interactive=False), idx, None
+    fb, _ = evaluate_viva_answer(qs[idx]['question'], ans, qs[idx].get('answer',''))
     
-    if next_idx < len(questions):
-        next_q = questions[next_idx]
-        next_question = f"### Question {next_idx + 1} of 5\n\n**{next_q['question']}**"
-        next_hint = f"💡 **Hint:** {next_q.get('hint', 'Think carefully about the anatomical relationships.')}"
-        
-        # Generate audio for next question with student name
-        audio_path = generate_audio(next_q['question'], student_name if student_name else None)
-        
-        return (
-            next_question,  # Show next question
-            next_hint,  # Show next hint
-            "",  # Clear answer box
-            feedback_text,  # Show feedback for current answer
-            gr.update(interactive=True, value="Submit Answer"),  # Keep button enabled
-            next_idx,  # Update question index
-            audio_path  # Play next question audio
-        )
+    next_idx = idx + 1
+    if next_idx < len(qs):
+        nxt = qs[next_idx]
+        audio = generate_audio(nxt['question'], name)
+        return f"### Q{next_idx+1}: {nxt['question']}", f"💡 {nxt.get('hint','')}", "", fb, gr.update(), next_idx, audio
     else:
-        # VIVA complete
-        completion_msg = f"### 🎉 VIVA Complete!\n\nYou've answered all 5 questions. Great job on completing your anatomy VIVA training!"
-        return (
-            completion_msg,
-            "",  # Clear hint
-            "",  # Clear answer
-            feedback_text,  # Final feedback
-            gr.update(interactive=False, value="VIVA Complete"),
-            next_idx,
-            None  # No audio
-        )
-
-
-# Create Gradio interface
-with gr.Blocks(title="AnatomyBot - MBBS Anatomy Tutor") as demo:
-    # State variables
-    student_name_state = gr.State("")
-    viva_questions_state = gr.State([])
-    current_question_idx = gr.State(0)
-    current_topic = gr.State("")
-    current_image_state = gr.State(None)
-    is_registered = gr.State(False)  # Track if user has registered
-    
-    # Add custom CSS styling via HTML
-    gr.HTML("""
-        <style>
-            /* Modal backdrop using body::after when modal exists and is visible */
-            body:has(#registration_modal:not([style*="display: none"]))::after {
-                content: '';
-                position: fixed;
-                top: 0;
-                left: 0;
-                right: 0;
-                bottom: 0;
-                background: rgba(0, 0, 0, 0.6);
-                backdrop-filter: blur(8px);
-                -webkit-backdrop-filter: blur(8px);
-                z-index: 999;
-                pointer-events: all;
-            }
-            
-            /* Modal container */
-            #registration_modal {
-                position: fixed !important;
-                top: 50% !important;
-                left: 50% !important;
-                transform: translate(-50%, -50%) !important;
-                z-index: 1000 !important;
-                background: linear-gradient(135deg, #ffffff 0%, #f8f9fa 100%) !important;
-                padding: 2.5rem !important;
-                border-radius: 20px !important;
-                border: 3px solid rgba(255,107,53,0.5) !important;
-                box-shadow: 
-                    0 10px 40px rgba(0,0,0,0.3),
-                    0 0 20px rgba(255,107,53,0.2),
-                    inset 0 1px 0 rgba(255,255,255,0.9) !important;
-                max-width: 600px !important;
-                width: 90% !important;
-                animation: modalSlideIn 0.3s ease-out !important;
-            }
-            
-            /* Modal animation */
-            @keyframes modalSlideIn {
-                from {
-                    opacity: 0;
-                    transform: translate(-50%, -60%);
-                }
-                to {
-                    opacity: 1;
-                    transform: translate(-50%, -50%);
-                }
-            }
-            
-            /* Beautify modal content */
-            #registration_modal h1 {
-                color: #2c3e50 !important;
-                margin-bottom: 0.5rem !important;
-                font-size: 2rem !important;
-            }
-            
-            #registration_modal h3 {
-                color: #7f8c8d !important;
-                font-weight: 400 !important;
-                font-size: 1.1rem !important;
-            }
-            
-            /* ========================================
-               RESPONSIVE NAVIGATION BAR FIX
-               Ensures navigation stays horizontal in iframe/HF Spaces
-               ======================================== */
-            
-            /* Force navigation bar to stay horizontal */
-            #nav_bar {
-                display: flex !important;
-                flex-direction: row !important;
-                flex-wrap: nowrap !important;
-                gap: 0.5rem !important;
-                width: 100% !important;
-                overflow-x: auto !important;
-                overflow-y: hidden !important;
-            }
-            
-            /* Equal-width buttons that shrink gracefully */
-            #nav_bar button {
-                flex: 1 1 0 !important;
-                min-width: 0 !important;
-                white-space: nowrap !important;
-                overflow: hidden !important;
-                text-overflow: ellipsis !important;
-                font-size: 0.875rem !important;
-                padding: 0.5rem 0.75rem !important;
-            }
-            
-            /* Responsive adjustments for narrower viewports */
-            @media (max-width: 900px) {
-                #nav_bar button {
-                    font-size: 0.75rem !important;
-                    padding: 0.4rem 0.5rem !important;
-                }
-            }
-            
-            @media (max-width: 600px) {
-                #nav_bar button {
-                    font-size: 0.7rem !important;
-                    padding: 0.3rem 0.4rem !important;
-                }
-                
-                /* Hide emojis on very small screens */
-                #nav_bar button::before {
-                    content: none !important;
-                }
-            }
-        </style>
-    """)
-    
-    # Main Application (always visible now)
-    with gr.Column() as main_app:
-        gr.Markdown(
-            """
-            # 🩺 AnatomyBot - Your MBBS Anatomy Tutor
-            
-            Master anatomy through AI-powered learning and interactive VIVA practice!
-            """
-        )
-        
-        # Display student name
-        student_name_display = gr.Markdown("")
-        
-        # Custom Navigation Bar
+        return "### 🎉 VIVA Complete!", "", "", fb, gr.update(interactive=False, value="Done"), next_idx, None
+
+# --- GRADIO UI ---
+with gr.Blocks(title="AnatomyBot", css="""
+    /* HIDE DEFAULT TABS HEADER to use Custom Nav */
+    .tabs > .tab-nav { display: none !important; }
+    
+    #registration_modal {
+        position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
+        z-index: 1000; background: white; padding: 2rem; border-radius: 20px;
+        box-shadow: 0 10px 40px rgba(0,0,0,0.3); border: 2px solid #ff6b35; width: 80%; max-width: 600px;
+    }
+    body:has(#registration_modal:not([style*="display: none"]))::after {
+        content: ''; position: fixed; inset: 0; background: rgba(0,0,0,0.5); z-index: 999;
+    }
+    #nav_bar { display: flex; gap: 10px; overflow-x: auto; padding-bottom: 5px; }
+    #nav_bar button { flex: 1; white-space: nowrap; }
+""") as demo:
+    
+    # State
+    student_name = gr.State("")
+    viva_qs = gr.State([])
+    q_idx = gr.State(0)
+    cur_topic = gr.State("")
+    cur_img = gr.State(None)
+    cur_book_topic = gr.State("")
+    
+    # Modal
+    with gr.Column(elem_id="registration_modal") as modal:
+        gr.Markdown("# 👨‍⚕️ Welcome, Doctor!")
+        m_name = gr.Textbox(label="Name")
+        m_school = gr.Textbox(label="Medical School")
+        m_year = gr.Dropdown(["Year 1", "Year 2", "Year 3", "Final Year", "Intern"], label="Year")
+        m_btn = gr.Button("Start Learning", variant="primary")
+
+    # Main App
+    with gr.Column():
+        gr.Markdown("# 🩺 AnatomyBot - MBBS Tutor")
+        welcome_msg = gr.Markdown("")
+        
+        # Custom Nav
         with gr.Row(elem_id="nav_bar"):
-            nav_learning_btn = gr.Button("📚 Learning Mode", variant="primary", scale=1)
-            nav_viva_btn = gr.Button("🎯 VIVA Training Mode", variant="secondary", scale=1)
-            nav_book_btn = gr.Button("📖 Book Learning Mode", variant="secondary", scale=1)
-            nav_admin_btn = gr.Button("🔐 Admin Panel", variant="secondary", scale=1)
+            btn_learn = gr.Button("📚 Learning Mode", variant="primary")
+            btn_viva = gr.Button("🎯 VIVA Training", variant="secondary")
+            btn_book = gr.Button("📖 Book Mode", variant="secondary")
+            btn_admin = gr.Button("🔐 Admin", variant="secondary")
 
-        # LEARNING MODE COLUMN
-        with gr.Column(visible=True, elem_id="learning_col") as learning_col:
-            # Search and examples at the top
-            with gr.Row():
-                query_input = gr.Textbox(
-                    label="Ask an Anatomy Question",
-                    placeholder="e.g., Show me the Circle of Willis",
-                    lines=2
-                )
-            
-            # Examples
-            gr.Examples(
-                examples=[
-                    ["Show me the Circle of Willis"],
-                    ["Brachial plexus anatomy"],
-                    ["Carpal bones arrangement"],
-                    ["Layers of the scalp"],
-                    ["Anatomy of the heart chambers"],
-                    ["Cranial nerves and their functions"],
-                    ["Structure of the kidney nephron"],
-                    ["Branches of the abdominal aorta"],
-                    ["Rotator cuff muscles"],
-                    ["Spinal cord cross section"],
-                    ["Femoral triangle anatomy"],
-                    ["Larynx cartilages and membranes"],
-                    ["Portal venous system"],
-                    ["Anatomy of the eyeball"],
-                    ["Bronchopulmonary segments"]
-                ],
-                inputs=query_input
-            )
-            
-            with gr.Row():
-                submit_btn = gr.Button("🔍 Search & Learn", variant="primary", size="lg")
-                start_viva_btn = gr.Button("🎯 Start VIVA Training", variant="secondary", size="lg")
-            
-            error_output = gr.Markdown(label="Status")
-            
-            # Main content: Key Learning Points (left) and Anatomy Diagram (right)
-            with gr.Row():
-                with gr.Column(scale=1):
-                    info_output = gr.Markdown(label="📚 Key Learning Points")
-                
-                with gr.Column(scale=1):
-                    image_output = gr.Image(label="🖼️ Anatomy Diagram", type="pil")
-        
-        # VIVA MODE COLUMN
-        with gr.Column(visible=False, elem_id="viva_col") as viva_col:
-            viva_status = gr.Markdown("Click 'Start VIVA Training' from Learning Mode after studying a topic!")
-            
-            # Additional greeting component (initially hidden)
-            viva_greeting = gr.Markdown("", visible=False)
+        # TABS Container (This solves the overlapping issue)
+        with gr.Tabs(elem_id="main_tabs") as tabs:
             
-            with gr.Column(visible=False) as viva_container:
+            # TAB 1: LEARNING
+            with gr.TabItem("Learning", id="tab_learn"):
                 with gr.Row():
-                    with gr.Column(scale=1):
-                        viva_image = gr.Image(label="Reference Image", type="pil", interactive=False)
-                    
-                        with gr.Column(scale=2):
-                            current_question_display = gr.Markdown("### Question will appear here")
-                            hint_display = gr.Markdown("💡 Hint will appear here")
-                        
-                            # Audio player for question
-                            question_audio = gr.Audio(label="🔊 Listen to Question", autoplay=True, interactive=False)
-                        
-                            student_answer = gr.Textbox(
-                                label="Your Answer",
-                                placeholder="Type your answer here...",
-                                lines=4
-                            )
-                        
-                            submit_answer_btn = gr.Button("Submit Answer", variant="primary")
-                        
-                            feedback_display = gr.Markdown("Feedback will appear here after you submit your answer")
-
-        # BOOK LEARNING MODE COLUMN
-        with gr.Column(visible=False, elem_id="book_col") as book_col:
-            # Upload PDF
-            pdf_upload = gr.File(label="Upload Anatomy Textbook (PDF)", file_types=[".pdf"], type="binary")
-            upload_status = gr.Markdown()
-            
-            # State to hold extracted images, captions, and text
-            book_images_state = gr.State([])
-            page_captions_state = gr.State([])
-            page_texts_state = gr.State([])
-            
-            # Dropdown to select a page after processing
-            page_dropdown = gr.Dropdown(label="Select Page", choices=[], interactive=False)
-            
-            # Display selected page image
-            selected_page_image = gr.Image(label="Selected Page", type="pil")
-            
-            # Analysis output
-            analysis_output = gr.Markdown(label="Page Analysis")
-            
-            # Button to start VIVA from this page
-            start_viva_book_btn = gr.Button("🎯 Start VIVA Training from this Page", variant="primary", visible=False)
-            
-            # Process upload
-            def handle_book_upload(pdf_bytes):
-                extracted_data, status_msg = process_uploaded_book(pdf_bytes)
-                if not extracted_data:
-                    # No data extracted
-                    return [], status_msg, [], [], gr.update(choices=[], interactive=False), None, ""
-                
-                # Separate images, captions, and text
-                img_list = [item[0] for item in extracted_data]
-                caps = [item[1] for item in extracted_data]
-                texts = [item[2] for item in extracted_data]
-                
-                # Update dropdown with captions and enable it
-                dropdown_update = gr.update(choices=caps, interactive=True)
-                return img_list, status_msg, caps, texts, dropdown_update, None, ""
-            
-            pdf_upload.upload(
-                fn=handle_book_upload,
-                inputs=[pdf_upload],
-                outputs=[book_images_state, upload_status, page_captions_state, page_texts_state, page_dropdown, selected_page_image, analysis_output]
-            )
-            
-            # When a page is selected, show image and analysis
-            def show_page_analysis(selected_caption, images, captions, texts):
-                if not selected_caption:
-                    return None, ""
-                # Find index
-                try:
-                    idx = captions.index(selected_caption)
-                except ValueError:
-                    return None, ""
-                
-                img = images[idx]
-                text = texts[idx] if idx < len(texts) else ""
-                
-                analysis = analyze_book_image(img, selected_caption, text)
-                
-                # Construct a topic string for VIVA
-                viva_topic = f"Anatomy of {selected_caption} (from textbook)"
-                
-                return img, analysis, viva_topic, gr.update(visible=True)
-            
-            # Hidden state to store current page topic for VIVA
-            current_book_topic = gr.State("")
-            
-            page_dropdown.change(
-                fn=show_page_analysis, 
-                inputs=[page_dropdown, book_images_state, page_captions_state, page_texts_state], 
-                outputs=[selected_page_image, analysis_output, current_book_topic, start_viva_book_btn]
-            )
-            
-            # Start VIVA from Book Mode handler moved to end of file to resolve NameError
-        
-        # ADMIN PANEL COLUMN
-        with gr.Column(visible=False, elem_id="admin_col") as admin_col:
-            gr.Markdown("## Admin Panel - Student Database")
-            gr.Markdown("Enter the admin password to view registered students.")
-            
-            # Password input
-            with gr.Row():
-                admin_password_input = gr.Textbox(
-                    label="Admin Password",
-                    placeholder="Enter admin password",
-                    type="password",
-                    scale=2
-                )
-                admin_login_btn = gr.Button("🔓 Login", variant="primary", scale=1)
-            
-            admin_status = gr.Markdown("")
-            
-            # Admin content (hidden until authenticated)
-            with gr.Column(visible=False) as admin_content:
-                gr.Markdown("### 📊 Registered Students")
-                
-                admin_stats = gr.Markdown("")
+                    q_in = gr.Textbox(label="Anatomy Question", placeholder="e.g. Circle of Willis")
+                with gr.Row():
+                    b_search = gr.Button("🔍 Search", variant="primary")
+                    b_to_viva = gr.Button("🎯 Start VIVA on this Topic", variant="secondary")
                 
+                err_out = gr.Markdown()
                 with gr.Row():
-                    refresh_btn = gr.Button("🔄 Refresh Data", variant="secondary")
-                    logout_btn = gr.Button("🚪 Logout", variant="secondary")
+                    info_out = gr.Markdown()
+                    img_out = gr.Image(type="pil", label="Diagram")
+
+            # TAB 2: VIVA
+            with gr.TabItem("VIVA", id="tab_viva"):
+                v_status = gr.Markdown("Select a topic in Learning Mode or Book Mode first!")
+                with gr.Column(visible=False) as v_cont:
+                    with gr.Row():
+                        v_img = gr.Image(interactive=False, type="pil", label="Reference")
+                        with gr.Column():
+                            v_q_disp = gr.Markdown("Question...")
+                            v_hint = gr.Markdown("Hint...")
+                            v_audio = gr.Audio(autoplay=True, interactive=False)
+                            v_ans = gr.Textbox(label="Answer", lines=3)
+                            v_sub = gr.Button("Submit")
+                            v_fb = gr.Markdown()
+
+            # TAB 3: BOOK
+            with gr.TabItem("Book", id="tab_book"):
+                bk_file = gr.File(label="Upload PDF", file_types=[".pdf"], type="binary")
+                bk_stat = gr.Markdown()
                 
-                students_table = gr.Dataframe(
-                    headers=["ID", "Name", "Medical School", "Year", "Registration Date"],
-                    label="Students Database",
-                    interactive=False,
-                    wrap=True
-                )
-    
-    # Registration Modal Popup (shown on first load)
-    with gr.Column(visible=True, elem_id="registration_modal") as registration_modal:
-        with gr.Row():
-            with gr.Column(scale=1):
-                pass  # Spacer
-            with gr.Column(scale=2):
-                gr.Markdown(
-                    """
-                    # 👨‍⚕️ Welcome to AnatomyBot!
-                    ### Please enter your information to get started
-                    """
-                )
-                modal_name_input = gr.Textbox(
-                    label="Your Name",
-                    placeholder="Enter your name",
-                    lines=1
-                )
-                modal_school_input = gr.Textbox(
-                    label="Medical School",
-                    placeholder="Enter your medical school",
-                    lines=1
-                )
-                modal_year_input = gr.Dropdown(
-                    label="Year/Level",
-                    choices=["MBBS 1st Year", "MBBS 2nd Year", "MBBS 3rd Year", "MBBS Final Year", "Intern"],
-                    value=None
-                )
-                modal_submit_btn = gr.Button(
-                    "✅ Start Learning",
-                    variant="primary",
-                    size="lg"
-                )
-            with gr.Column(scale=1):
-                pass  # Spacer
-
-    
-    # Event Handlers
-    
-    # Navigation Logic - change_view function returns exactly 4 values for 4 columns
-    def change_view(target_view):
-        """
-        Handle navigation between views with mutual exclusivity.
-        
-        Args:
-            target_view: The view to display ("learning", "viva", "book", or "admin")
-            
-        Returns:
-            Tuple of 4 gr.update() objects for [learning_col, viva_col, book_col, admin_col]
-            Exactly ONE will have visible=True, the rest will have visible=False
-        """
-        if target_view == "learning":
-            return (
-                gr.update(visible=True),   # learning_col
-                gr.update(visible=False),  # viva_col
-                gr.update(visible=False),  # book_col
-                gr.update(visible=False)   # admin_col
-            )
-        elif target_view == "viva":
-            return (
-                gr.update(visible=False),  # learning_col
-                gr.update(visible=True),   # viva_col
-                gr.update(visible=False),  # book_col
-                gr.update(visible=False)   # admin_col
-            )
-        elif target_view == "book":
-            return (
-                gr.update(visible=False),  # learning_col
-                gr.update(visible=False),  # viva_col
-                gr.update(visible=True),   # book_col
-                gr.update(visible=False)   # admin_col
-            )
-        elif target_view == "admin":
-            return (
-                gr.update(visible=False),  # learning_col
-                gr.update(visible=False),  # viva_col
-                gr.update(visible=False),  # book_col
-                gr.update(visible=True)    # admin_col
-            )
-        # Default to learning mode if invalid target
-        return (
-            gr.update(visible=True),   # learning_col
-            gr.update(visible=False),  # viva_col
-            gr.update(visible=False),  # book_col
-            gr.update(visible=False)   # admin_col
-        )
-
-    # Bind Navigation Buttons - Apply change_view logic to all four top buttons
-    nav_learning_btn.click(
-        fn=lambda: change_view("learning"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
-    )
-    
-    nav_viva_btn.click(
-        fn=lambda: change_view("viva"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
-    )
-    
-    nav_book_btn.click(
-        fn=lambda: change_view("book"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
-    )
-    
-    nav_admin_btn.click(
-        fn=lambda: change_view("admin"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
+                # Book State
+                bk_imgs = gr.State([])
+                bk_caps = gr.State([])
+                bk_txts = gr.State([])
+                
+                bk_page_sel = gr.Dropdown(label="Select Page", interactive=False)
+                bk_view = gr.Image(label="Page View", type="pil")
+                bk_anl = gr.Markdown()
+                b_bk_viva = gr.Button("🎯 Start VIVA from Page", visible=False)
+
+            # TAB 4: ADMIN
+            with gr.TabItem("Admin", id="tab_admin"):
+                p_in = gr.Textbox(label="Password", type="password")
+                b_login = gr.Button("Login")
+                with gr.Column(visible=False) as adm_panel:
+                    adm_stat = gr.Markdown()
+                    b_refresh = gr.Button("Refresh")
+                    tbl = gr.Dataframe()
+
+    # --- EVENT HANDLERS ---
+    
+    # 1. Modal Close
+    m_btn.click(
+        fn=lambda n,s,y: (gr.update(visible=False), f"**Doctor {n}** | {s}", n, save_student(n,s,y)),
+        inputs=[m_name, m_school, m_year],
+        outputs=[modal, welcome_msg, student_name, gr.State()] # dummy output for save
     )
 
-    # Welcome Screen Handler (now for modal)
-    def handle_modal_submit(name, medical_school, year):
-        """Handle registration modal submission."""
-        if not name or not name.strip():
-            return gr.update(), gr.update(), ""  # Don't proceed if name is empty
-        
-        if not medical_school or not medical_school.strip():
-            return gr.update(), gr.update(), ""  # Don't proceed if medical school is empty
-        
-        if not year:
-            return gr.update(), gr.update(), ""  # Don't proceed if year is not selected
-        
-        # Save to database
-        save_student(name.strip(), medical_school.strip(), year)
+    # 2. Navigation (Updates the Tabs 'selected' state)
+    btn_learn.click(lambda: gr.Tabs(selected="tab_learn"), outputs=tabs)
+    btn_viva.click(lambda: gr.Tabs(selected="tab_viva"), outputs=tabs)
+    btn_book.click(lambda: gr.Tabs(selected="tab_book"), outputs=tabs)
+    btn_admin.click(lambda: gr.Tabs(selected="tab_admin"), outputs=tabs)
+
+    # 3. Learning Mode
+    def run_search(q):
+        img, txt, err = process_anatomy_query(q)
+        return img, txt, err, q, img, gr.update(interactive=True)
         
-        greeting = f"**Welcome, Doctor {name}!** 👋 from {medical_school} ({year})"
-        return (
-            gr.update(visible=False),  # Hide modal
-            greeting,                   # Display greeting
-            name                        # Store name in state
-        )
-    
-    modal_submit_btn.click(
-        fn=handle_modal_submit,
-        inputs=[modal_name_input, modal_school_input, modal_year_input],
-        outputs=[registration_modal, student_name_display, student_name_state],
-        js="""
-        (name, school, year) => {
-            if (name && name.trim() !== "" && school && school.trim() !== "" && year) {
-                const modal = document.getElementById('registration_modal');
-                if (modal) {
-                    modal.style.display = 'none';
-                }
-            }
-        }
-        """
-    )
-    
-    # Event handlers for Learning Mode
-    def handle_query(query):
-        """Handle learning mode query and store topic/image."""
-        img, info, error = process_anatomy_query(query)
-        # Reset Start VIVA button
-        viva_btn_update = gr.update(value="🎯 Start VIVA Training", interactive=True)
-        return img, info, error, query, img, viva_btn_update  # Return topic, image, and button update
-    
-    submit_btn.click(
-        fn=handle_query,
-        inputs=[query_input],
-        outputs=[image_output, info_output, error_output, current_topic, current_image_state, start_viva_btn]
-    )
-    
-    query_input.submit(
-        fn=handle_query,
-        inputs=[query_input],
-        outputs=[image_output, info_output, error_output, current_topic, current_image_state, start_viva_btn]
-    )
-    
-    # Start VIVA Mode - Directly start with pre-collected name
-    start_viva_btn.click(
-        fn=lambda: gr.update(value="⏳ Processing VIVA Question...", interactive=False),
-        outputs=[start_viva_btn]
-    ).then(
-        fn=lambda name, topic, image: start_viva_mode(topic, image, name),
-        inputs=[student_name_state, current_topic, current_image_state],
-        outputs=[
-            viva_container, viva_status, viva_image,
-            current_question_display, hint_display,
-            student_answer, feedback_display, submit_answer_btn,
-            viva_questions_state,
-            question_audio,  # Output audio
-            student_name_state  # Return student name (unchanged)
-        ]
-    ).then(
-        fn=lambda: change_view("viva"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
+    b_search.click(run_search, q_in, [img_out, info_out, err_out, cur_topic, cur_img, b_to_viva])
+    q_in.submit(run_search, q_in, [img_out, info_out, err_out, cur_topic, cur_img, b_to_viva])
+
+    # 4. Start VIVA (Learning Mode)
+    b_to_viva.click(
+        fn=lambda: gr.update(value="Generating...", interactive=False), outputs=b_to_viva
     ).then(
-        fn=lambda: gr.update(value="🎯 Start VIVA Training", interactive=True),  # Reset button
-        outputs=[start_viva_btn]
+        fn=start_viva_mode,
+        inputs=[cur_topic, cur_img, student_name],
+        outputs=[v_cont, v_status, v_img, v_q_disp, v_hint, v_ans, v_fb, v_sub, viva_qs, v_audio, gr.State()]
     ).then(
-        fn=lambda: 0,  # Reset question index
-        outputs=[current_question_idx]
-    )
-    
-    # Submit VIVA Answer
-    submit_answer_btn.click(
-        fn=submit_viva_answer,
-        inputs=[student_answer, viva_questions_state, current_question_idx, student_name_state],
-        outputs=[
-            current_question_display, hint_display, student_answer,
-            feedback_display, submit_answer_btn, current_question_idx,
-            question_audio  # Output audio for next question
-        ]
-    )
-    
-    # Admin Panel Handlers
-    def admin_login(password):
-        """Verify admin password and show admin content."""
-        if password == ADMIN_PASSWORD:
-            students = get_all_students()
-            total_students = len(students)
-            stats = f"**Total Registered Students:** {total_students}"
-            return (
-                gr.update(value="✅ Login successful!", visible=True),
-                gr.update(visible=True),  # Show admin content
-                stats,
-                students
-            )
-        else:
-            return (
-                gr.update(value="❌ Invalid password. Access denied.", visible=True),
-                gr.update(visible=False),  # Hide admin content
-                "",
-                []
-            )
-    
-    def admin_logout():
-        """Logout from admin panel."""
-        return (
-            gr.update(value=""),  # Clear password
-            gr.update(value=""),  # Clear status
-            gr.update(visible=False),  # Hide admin content
-            "",  # Clear stats
-            []  # Clear table
-        )
-    
-    def refresh_students():
-        """Refresh the students table."""
-        students = get_all_students()
-        total_students = len(students)
-        stats = f"**Total Registered Students:** {total_students}"
-        return stats, students
-    
-    admin_login_btn.click(
-        fn=admin_login,
-        inputs=[admin_password_input],
-        outputs=[admin_status, admin_content, admin_stats, students_table]
-    )
-    
-    admin_password_input.submit(
-        fn=admin_login,
-        inputs=[admin_password_input],
-        outputs=[admin_status, admin_content, admin_stats, students_table]
-    )
-    
-    logout_btn.click(
-        fn=admin_logout,
-        outputs=[admin_password_input, admin_status, admin_content, admin_stats, students_table]
+        fn=lambda: (gr.Tabs(selected="tab_viva"), 0, gr.update(value="Start VIVA", interactive=True)),
+        outputs=[tabs, q_idx, b_to_viva]
     )
-    
-    refresh_btn.click(
-        fn=refresh_students,
-        outputs=[admin_stats, students_table]
+
+    # 5. VIVA Logic
+    v_sub.click(
+        fn=submit_viva_answer_logic,
+        inputs=[v_ans, viva_qs, q_idx, student_name],
+        outputs=[v_q_disp, v_hint, v_ans, v_fb, v_sub, q_idx, v_audio]
     )
 
-    # Start VIVA from Book Mode - Use pre-collected name (Moved here to ensure all columns are defined)
-    start_viva_book_btn.click(
-        fn=lambda name, topic, image: start_viva_with_name(name, topic, image),
-        inputs=[student_name_state, current_book_topic, selected_page_image],
-        outputs=[
-            viva_container, viva_status, viva_image,
-            current_question_display, hint_display,
-            student_answer, feedback_display, submit_answer_btn,
-            viva_questions_state,
-            question_audio, viva_greeting, student_name_state
-        ]
-    ).then(
-        fn=lambda: change_view("viva"),
-        outputs=[learning_col, viva_col, book_col, admin_col]
+    # 6. Book Mode
+    def on_upload(f):
+        data, msg = process_uploaded_book(f)
+        if not data: return [], [], [], gr.update(choices=[]), msg
+        imgs, caps, txts = zip(*data)
+        return imgs, caps, txts, gr.update(choices=list(caps), interactive=True), msg
+
+    bk_file.upload(on_upload, bk_file, [bk_imgs, bk_caps, bk_txts, bk_page_sel, bk_stat])
+
+    def on_page_sel(sel, imgs, caps, txts):
+        if not sel: return None, "", "", gr.update()
+        idx = caps.index(sel)
+        anl = analyze_book_image(imgs[idx], sel, txts[idx])
+        return imgs[idx], anl, f"Textbook: {sel}", gr.update(visible=True)
+
+    bk_page_sel.change(on_page_sel, [bk_page_sel, bk_imgs, bk_caps, bk_txts], [bk_view, bk_anl, cur_book_topic, b_bk_viva])
+
+    # 7. Start VIVA (Book Mode)
+    b_bk_viva.click(
+        fn=start_viva_mode,
+        inputs=[cur_book_topic, bk_view, student_name],
+        outputs=[v_cont, v_status, v_img, v_q_disp, v_hint, v_ans, v_fb, v_sub, viva_qs, v_audio, gr.State()]
     ).then(
-        fn=lambda: 0,
-        outputs=[current_question_idx]
+        fn=lambda: (gr.Tabs(selected="tab_viva"), 0),
+        outputs=[tabs, q_idx]
     )
 
-if __name__ == "__main__":
-    # Check if API keys are configured
-    if not SERPAPI_KEY or SERPAPI_KEY == "your_serpapi_key_here":
-        print("⚠️  WARNING: SERPAPI_KEY not configured in .env file")
-    if not HYPERBOLIC_API_KEY or HYPERBOLIC_API_KEY == "your_hyperbolic_api_key_here":
-        print("⚠️  WARNING: HYPERBOLIC_API_KEY not configured in .env file")
-    
-    # Use environment variable for port, default to 7860 for HF Spaces
-    port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
-    demo.launch(server_name="0.0.0.0", server_port=port)
+    # 8. Admin
+    def do_login(p):
+        if p == ADMIN_PASSWORD:
+            d = get_all_students()
+            return gr.update(visible=True), f"Count: {len(d)}", d
+        return gr.update(visible=False), "❌ Wrong Password", []
 
-# Rebuild trigger
+    b_login.click(do_login, p_in, [adm_panel, adm_stat, tbl])
+    b_refresh.click(lambda: (f"Count: {len(get_all_students())}", get_all_students()), outputs=[adm_stat, tbl])
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)