Update app.py

app.py

@@ -3,86 +3,162 @@ import pandas as pd
 import json
 import os
 import re
-from PyPDF2 import PdfReader
+from PyPDF2 import PdfReader, PdfReadError
 from collections import defaultdict
+from typing import Dict, List, Optional, Tuple, Union
+import html
+from pathlib import Path
 
-# ========== NER MODEL HANDLING FOR SPACES ==========
-try:
-    from transformers import pipeline
-    ner_pipeline = pipeline("ner", model="dslim/bert-base-NER")
-except ImportError:
-    ner_pipeline = None
-    print("NER model not available - continuing without it")
-except Exception as e:
-    ner_pipeline = None
-    print(f"Could not load NER model: {e}")
+# ========== CONFIGURATION ==========
+PROFILES_DIR = "student_profiles"
+ALLOWED_FILE_TYPES = [".pdf"]
+MAX_FILE_SIZE_MB = 5
+MIN_AGE = 5
+MAX_AGE = 120
+
+# ========== NER MODEL HANDLING (DISABLED FOR HF SPACES) ==========
+# Disabled for Hugging Face Spaces compatibility
+ner_pipeline = None
+
+# ========== UTILITY FUNCTIONS ==========
+def sanitize_input(text: str) -> str:
+    """Sanitize user input to prevent XSS and injection attacks."""
+    return html.escape(text.strip())
+
+def validate_age(age: Union[int, float, str]) -> int:
+    """Validate and convert age input."""
+    try:
+        age_int = int(age)
+        if not MIN_AGE <= age_int <= MAX_AGE:
+            raise gr.Error(f"Age must be between {MIN_AGE} and {MAX_AGE}")
+        return age_int
+    except (ValueError, TypeError):
+        raise gr.Error("Please enter a valid age number")
+
+def validate_file(file_obj) -> None:
+    """Validate uploaded file."""
+    if not file_obj:
+        raise gr.Error("No file uploaded")
+    
+    if not any(file_obj.name.endswith(ext) for ext in ALLOWED_FILE_TYPES):
+        raise gr.Error(f"Only {', '.join(ALLOWED_FILE_TYPES)} files are allowed")
+    
+    file_size = os.path.getsize(file_obj.name) / (1024 * 1024)  # MB
+    if file_size > MAX_FILE_SIZE_MB:
+        raise gr.Error(f"File size must be less than {MAX_FILE_SIZE_MB}MB")
 
 # ========== TRANSCRIPT PARSING ==========
-def extract_gpa(text, gpa_type):
+def extract_gpa(text: str, gpa_type: str) -> str:
+    """Extract GPA information from text with validation."""
     pattern = rf'{gpa_type}\s*([\d\.]+)'
     match = re.search(pattern, text)
-    return match.group(1) if match else "N/A"
+    if not match:
+        return "N/A"
+    
+    gpa_value = match.group(1)
+    try:
+        gpa_float = float(gpa_value)
+        if not 0.0 <= gpa_float <= 5.0:  # Assuming 5.0 is max for weighted GPA
+            return "Invalid GPA"
+        return gpa_value
+    except ValueError:
+        return "N/A"
 
-def extract_courses_from_table(text):
-    course_pattern = re.compile(
+def extract_courses_from_table(text: str) -> Dict[str, List[Dict]]:
+    """Extract course information with multiple pattern fallbacks."""
+    # Primary pattern with strict formatting
+    primary_pattern = re.compile(
         r'(\d{4}-\d{4})\s*'  # School year
         r'\|?\s*(\d+)\s*'     # Grade level
         r'\|?\s*([A-Z0-9]+)\s*'  # Course code
-        r'\|?\s*([^\|]+?)\s*'  # Course name (captures until next pipe)
+        r'\|?\s*([^\|]+?)\s*'  # Course name
         r'(?:\|\s*[^\|]*){2}'  # Skip Term and DstNumber
         r'\|\s*([A-FW]?)\s*'   # Grade (FG column)
         r'(?:\|\s*[^\|]*)'     # Skip Incl column
         r'\|\s*([\d\.]+|inProgress)'  # Credits
     )
     
+    # Fallback pattern for less structured data
+    fallback_pattern = re.compile(
+        r'(\d{4}-\d{4})\s+'  # School year
+        r'(\d+)\s+'          # Grade level
+        r'([A-Z0-9]+)\s+'     # Course code
+        r'(.+?)\s+'           # Course name
+        r'([A-FW]?)\s*'       # Grade
+        r'([\d\.]+|inProgress)'  # Credits
+    )
+    
     courses_by_grade = defaultdict(list)
     
-    for match in re.finditer(course_pattern, text):
-        year_range, grade_level, course_code, course_name, grade, credits = match.groups()
-        
-        course_name = course_name.strip()
-        if 'DE:' in course_name:
-            course_name = course_name.replace('DE:', 'Dual Enrollment:')
-        if 'AP' in course_name:
-            course_name = course_name.replace('AP', 'AP ')
-        
-        course_info = {
-            'name': f"{course_code} {course_name}",
-            'year': year_range,
-            'credits': credits
-        }
+    for pattern in [primary_pattern, fallback_pattern]:
+        for match in re.finditer(pattern, text):
+            year_range, grade_level, course_code, course_name, grade, credits = match.groups()
+            
+            # Clean and format course information
+            course_name = course_name.strip()
+            if 'DE:' in course_name:
+                course_name = course_name.replace('DE:', 'Dual Enrollment:')
+            if 'AP' in course_name and 'AP ' not in course_name:
+                course_name = course_name.replace('AP', 'AP ')
+            
+            course_info = {
+                'name': f"{course_code} {course_name}",
+                'year': year_range,
+                'credits': credits if credits != 'inProgress' else 'In Progress'
+            }
+            
+            if grade and grade.strip():
+                course_info['grade'] = grade.strip()
+            
+            courses_by_grade[grade_level].append(course_info)
         
-        if grade and grade.strip():
-            course_info['grade'] = grade.strip()
-        
-        courses_by_grade[grade_level].append(course_info)
+        if courses_by_grade:  # If we found matches with this pattern, stop
+            break
     
     return courses_by_grade
 
-def parse_transcript(file):
-    if file.name.endswith('.pdf'):
+def parse_transcript(file_obj) -> Tuple[str, Optional[Dict]]:
+    """Parse transcript file with robust error handling."""
+    try:
+        validate_file(file_obj)
+        
         text = ''
-        reader = PdfReader(file)
-        for page in reader.pages:
-            text += page.extract_text() + '\n'
+        try:
+            reader = PdfReader(file_obj)
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + '\n'
+        except PdfReadError:
+            raise gr.Error("Failed to read PDF file - may be corrupted")
+        except Exception as e:
+            raise gr.Error(f"Error processing PDF: {str(e)}")
+        
+        if not text.strip():
+            raise gr.Error("No text could be extracted from the PDF")
         
+        # Extract GPA data with validation
         gpa_data = {
             'weighted': extract_gpa(text, 'Weighted GPA'),
             'unweighted': extract_gpa(text, 'Un-weighted GPA')
         }
         
-        grade_match = re.search(r'Current Grade:\s*(\d+)', text)
+        # Extract grade level with fallback
+        grade_match = re.search(r'Current Grade:\s*(\d+)', text) or \
+                     re.search(r'Grade\s*:\s*(\d+)', text) or \
+                     re.search(r'Grade\s+(\d+)', text)
         grade_level = grade_match.group(1) if grade_match else "Unknown"
         
         courses_by_grade = extract_courses_from_table(text)
         
+        # Format output text
         output_text = f"Student Transcript Summary\n{'='*40}\n"
         output_text += f"Current Grade Level: {grade_level}\n"
         output_text += f"Weighted GPA: {gpa_data['weighted']}\n"
         output_text += f"Unweighted GPA: {gpa_data['unweighted']}\n\n"
         output_text += "Course History:\n{'='*40}\n"
         
-        for grade in sorted(courses_by_grade.keys(), key=int):
+        for grade in sorted(courses_by_grade.keys(), key=lambda x: int(x) if x.isdigit() else x):
             output_text += f"\nGrade {grade}:\n{'-'*30}\n"
             for course in courses_by_grade[grade]:
                 output_text += f"- {course['name']}"
@@ -97,355 +173,817 @@ def parse_transcript(file):
             "grade_level": grade_level,
             "courses": dict(courses_by_grade)
         }
-    else:
-        return "Unsupported file format (PDF only for transcript parsing)", None
+    
+    except Exception as e:
+        return f"Error processing transcript: {str(e)}", None
 
 # ========== LEARNING STYLE QUIZ ==========
-learning_style_questions = [
-    "When you study for a test, you prefer to:",
-    "When you need directions to a new place, you prefer:",
-    "When you learn a new skill, you prefer to:",
-    "When you're trying to concentrate, you:",
-    "When you meet new people, you remember them by:",
-    "When you're assembling furniture or a gadget, you:",
-    "When choosing a restaurant, you rely most on:",
-    "When you're in a waiting room, you typically:",
-    "When giving someone instructions, you tend to:",
-    "When you're trying to recall information, you:",
-    "When you're at a museum or exhibit, you:",
-    "When you're learning a new language, you prefer:",
-    "When you're taking notes in class, you:",
-    "When you're explaining something complex, you:",
-    "When you're at a party, you enjoy:",
-    "When you're trying to remember a phone number, you:",
-    "When you're relaxing, you prefer to:",
-    "When you're learning to use new software, you:",
-    "When you're giving a presentation, you rely on:",
-    "When you're solving a difficult problem, you:"
-]
-
-learning_style_options = [
-    ["Read the textbook (Reading/Writing)", "Listen to lectures (Auditory)", "Use diagrams/charts (Visual)", "Practice problems (Kinesthetic)"],
-    ["Look at a map (Visual)", "Have someone tell you (Auditory)", "Write down directions (Reading/Writing)", "Try walking/driving there (Kinesthetic)"],
-    ["Read instructions (Reading/Writing)", "Have someone show you (Visual)", "Listen to explanations (Auditory)", "Try it yourself (Kinesthetic)"],
-    ["Need quiet (Reading/Writing)", "Need background noise (Auditory)", "Need to move around (Kinesthetic)", "Need visual stimulation (Visual)"],
-    ["Their face (Visual)", "Their name (Auditory)", "What you talked about (Reading/Writing)", "What you did together (Kinesthetic)"],
-    ["Read the instructions carefully (Reading/Writing)", "Look at the diagrams (Visual)", "Ask someone to explain (Auditory)", "Start putting pieces together (Kinesthetic)"],
-    ["Online photos of the food (Visual)", "Recommendations from friends (Auditory)", "Reading the menu online (Reading/Writing)", "Remembering how it felt to eat there (Kinesthetic)"],
-    ["Read magazines (Reading/Writing)", "Listen to music (Auditory)", "Watch TV (Visual)", "Fidget or move around (Kinesthetic)"],
-    ["Write them down (Reading/Writing)", "Explain verbally (Auditory)", "Demonstrate (Visual)", "Guide them physically (Kinesthetic)"],
-    ["See written words in your mind (Visual)", "Hear the information in your head (Auditory)", "Write it down to remember (Reading/Writing)", "Associate it with physical actions (Kinesthetic)"],
-    ["Read all the descriptions (Reading/Writing)", "Listen to audio guides (Auditory)", "Look at the displays (Visual)", "Touch interactive exhibits (Kinesthetic)"],
-    ["Study grammar rules (Reading/Writing)", "Listen to native speakers (Auditory)", "Use flashcards with images (Visual)", "Practice conversations (Kinesthetic)"],
-    ["Write detailed paragraphs (Reading/Writing)", "Record the lecture (Auditory)", "Draw diagrams and charts (Visual)", "Doodle while listening (Kinesthetic)"],
-    ["Write detailed steps (Reading/Writing)", "Explain verbally with examples (Auditory)", "Draw diagrams (Visual)", "Use physical objects to demonstrate (Kinesthetic)"],
-    ["Conversations with people (Auditory)", "Watching others or the environment (Visual)", "Writing notes or texting (Reading/Writing)", "Dancing or physical activities (Kinesthetic)"],
-    ["See the numbers in your head (Visual)", "Say them aloud (Auditory)", "Write them down (Reading/Writing)", "Dial them on a keypad (Kinesthetic)"],
-    ["Read a book (Reading/Writing)", "Listen to music (Auditory)", "Watch TV/movies (Visual)", "Do something physical (Kinesthetic)"],
-    ["Read the manual (Reading/Writing)", "Ask someone to show you (Visual)", "Call tech support (Auditory)", "Experiment with the software (Kinesthetic)"],
-    ["Detailed notes (Reading/Writing)", "Verbal explanations (Auditory)", "Visual slides (Visual)", "Physical demonstrations (Kinesthetic)"],
-    ["Write out possible solutions (Reading/Writing)", "Talk through it with someone (Auditory)", "Draw diagrams (Visual)", "Build a model or prototype (Kinesthetic)"]
-]
-
-def learning_style_quiz(*answers):
-    scores = {
-        "Visual": 0,
-        "Auditory": 0,
-        "Reading/Writing": 0,
-        "Kinesthetic": 0
-    }
-    
-    for i, answer in enumerate(answers):
-        if answer == learning_style_options[i][0]:
-            scores["Reading/Writing"] += 1
-        elif answer == learning_style_options[i][1]:
-            scores["Auditory"] += 1
-        elif answer == learning_style_options[i][2]:
-            scores["Visual"] += 1
-        elif answer == learning_style_options[i][3]:
-            scores["Kinesthetic"] += 1
-    
-    max_score = max(scores.values())
-    total_questions = len(learning_style_questions)
-    
-    percentages = {style: (score/total_questions)*100 for style, score in scores.items()}
-    
-    sorted_styles = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-    
-    result = "Your Learning Style Results:\n\n"
-    for style, score in sorted_styles:
-        result += f"{style}: {score}/{total_questions} ({percentages[style]:.1f}%)\n"
-    
-    result += "\n"
-    
-    primary_styles = [style for style, score in scores.items() if score == max_score]
+class LearningStyleQuiz:
+    def __init__(self):
+        self.questions = [
+            "When you study for a test, you prefer to:",
+            "When you need directions to a new place, you prefer:",
+            "When you learn a new skill, you prefer to:",
+            "When you're trying to concentrate, you:",
+            "When you meet new people, you remember them by:",
+            "When you're assembling furniture or a gadget, you:",
+            "When choosing a restaurant, you rely most on:",
+            "When you're in a waiting room, you typically:",
+            "When giving someone instructions, you tend to:",
+            "When you're trying to recall information, you:",
+            "When you're at a museum or exhibit, you:",
+            "When you're learning a new language, you prefer:",
+            "When you're taking notes in class, you:",
+            "When you're explaining something complex, you:",
+            "When you're at a party, you enjoy:",
+            "When you're trying to remember a phone number, you:",
+            "When you're relaxing, you prefer to:",
+            "When you're learning to use new software, you:",
+            "When you're giving a presentation, you rely on:",
+            "When you're solving a difficult problem, you:"
+        ]
+        
+        self.options = [
+            ["Read the textbook (Reading/Writing)", "Listen to lectures (Auditory)", "Use diagrams/charts (Visual)", "Practice problems (Kinesthetic)"],
+            ["Look at a map (Visual)", "Have someone tell you (Auditory)", "Write down directions (Reading/Writing)", "Try walking/driving there (Kinesthetic)"],
+            ["Read instructions (Reading/Writing)", "Have someone show you (Visual)", "Listen to explanations (Auditory)", "Try it yourself (Kinesthetic)"],
+            ["Need quiet (Reading/Writing)", "Need background noise (Auditory)", "Need to move around (Kinesthetic)", "Need visual stimulation (Visual)"],
+            ["Their face (Visual)", "Their name (Auditory)", "What you talked about (Reading/Writing)", "What you did together (Kinesthetic)"],
+            ["Read the instructions carefully (Reading/Writing)", "Look at the diagrams (Visual)", "Ask someone to explain (Auditory)", "Start putting pieces together (Kinesthetic)"],
+            ["Online photos of the food (Visual)", "Recommendations from friends (Auditory)", "Reading the menu online (Reading/Writing)", "Remembering how it felt to eat there (Kinesthetic)"],
+            ["Read magazines (Reading/Writing)", "Listen to music (Auditory)", "Watch TV (Visual)", "Fidget or move around (Kinesthetic)"],
+            ["Write them down (Reading/Writing)", "Explain verbally (Auditory)", "Demonstrate (Visual)", "Guide them physically (Kinesthetic)"],
+            ["See written words in your mind (Visual)", "Hear the information in your head (Auditory)", "Write it down to remember (Reading/Writing)", "Associate it with physical actions (Kinesthetic)"],
+            ["Read all the descriptions (Reading/Writing)", "Listen to audio guides (Auditory)", "Look at the displays (Visual)", "Touch interactive exhibits (Kinesthetic)"],
+            ["Study grammar rules (Reading/Writing)", "Listen to native speakers (Auditory)", "Use flashcards with images (Visual)", "Practice conversations (Kinesthetic)"],
+            ["Write detailed paragraphs (Reading/Writing)", "Record the lecture (Auditory)", "Draw diagrams and charts (Visual)", "Doodle while listening (Kinesthetic)"],
+            ["Write detailed steps (Reading/Writing)", "Explain verbally with examples (Auditory)", "Draw diagrams (Visual)", "Use physical objects to demonstrate (Kinesthetic)"],
+            ["Conversations with people (Auditory)", "Watching others or the environment (Visual)", "Writing notes or texting (Reading/Writing)", "Dancing or physical activities (Kinesthetic)"],
+            ["See the numbers in your head (Visual)", "Say them aloud (Auditory)", "Write them down (Reading/Writing)", "Dial them on a keypad (Kinesthetic)"],
+            ["Read a book (Reading/Writing)", "Listen to music (Auditory)", "Watch TV/movies (Visual)", "Do something physical (Kinesthetic)"],
+            ["Read the manual (Reading/Writing)", "Ask someone to show you (Visual)", "Call tech support (Auditory)", "Experiment with the software (Kinesthetic)"],
+            ["Detailed notes (Reading/Writing)", "Verbal explanations (Auditory)", "Visual slides (Visual)", "Physical demonstrations (Kinesthetic)"],
+            ["Write out possible solutions (Reading/Writing)", "Talk through it with someone (Auditory)", "Draw diagrams (Visual)", "Build a model or prototype (Kinesthetic)"]
+        ]
+        
+        self.learning_styles = {
+            "Visual": {
+                "description": "Visual learners prefer using images, diagrams, and spatial understanding.",
+                "tips": [
+                    "Use color coding in your notes",
+                    "Create mind maps and diagrams",
+                    "Watch educational videos",
+                    "Use flashcards with images",
+                    "Highlight important information in different colors"
+                ]
+            },
+            "Auditory": {
+                "description": "Auditory learners learn best through listening and speaking.",
+                "tips": [
+                    "Record lectures and listen to them",
+                    "Participate in study groups",
+                    "Explain concepts out loud to yourself",
+                    "Use rhymes or songs to remember information",
+                    "Listen to educational podcasts"
+                ]
+            },
+            "Reading/Writing": {
+                "description": "These learners prefer information displayed as words.",
+                "tips": [
+                    "Write detailed notes",
+                    "Create summaries in your own words",
+                    "Read textbooks and articles",
+                    "Make lists to organize information",
+                    "Rewrite your notes to reinforce learning"
+                ]
+            },
+            "Kinesthetic": {
+                "description": "Kinesthetic learners learn through movement and hands-on activities.",
+                "tips": [
+                    "Use hands-on activities",
+                    "Take frequent movement breaks",
+                    "Create physical models",
+                    "Associate information with physical actions",
+                    "Study while walking or pacing"
+                ]
+            }
+        }
     
-    if len(primary_styles) == 1:
-        result += f"Your primary learning style is: {primary_styles[0]}\n\n"
-        if primary_styles[0] == "Visual":
-            result += "Tips for Visual Learners:\n"
-            result += "- Use color coding in your notes\n"
-            result += "- Create mind maps and diagrams\n"
-            result += "- Watch educational videos\n"
-            result += "- Use flashcards with images\n"
-        elif primary_styles[0] == "Auditory":
-            result += "Tips for Auditory Learners:\n"
-            result += "- Record lectures and listen to them\n"
-            result += "- Participate in study groups\n"
-            result += "- Explain concepts out loud to yourself\n"
-            result += "- Use rhymes or songs to remember information\n"
-        elif primary_styles[0] == "Reading/Writing":
-            result += "Tips for Reading/Writing Learners:\n"
-            result += "- Write detailed notes\n"
-            result += "- Create summaries in your own words\n"
-            result += "- Read textbooks and articles\n"
-            result += "- Make lists to organize information\n"
+    def evaluate_quiz(self, answers: List[str]) -> str:
+        """Evaluate quiz answers and generate results."""
+        if len(answers) != len(self.questions):
+            raise gr.Error("Not all questions were answered")
+        
+        scores = {style: 0 for style in self.learning_styles}
+        
+        for i, answer in enumerate(answers):
+            if not answer:
+                continue  # Skip unanswered questions
+                
+            for j, style in enumerate(self.learning_styles):
+                if answer == self.options[i][j]:
+                    scores[style] += 1
+                    break
+        
+        total_answered = sum(1 for ans in answers if ans)
+        if total_answered == 0:
+            raise gr.Error("No answers provided")
+        
+        percentages = {style: (score/total_answered)*100 for style, score in scores.items()}
+        sorted_styles = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+        
+        # Generate results report
+        result = "## Your Learning Style Results\n\n"
+        result += "### Scores:\n"
+        for style, score in sorted_styles:
+            result += f"- **{style}**: {score}/{total_answered} ({percentages[style]:.1f}%)\n"
+        
+        max_score = max(scores.values())
+        primary_styles = [style for style, score in scores.items() if score == max_score]
+        
+        result += "\n### Analysis:\n"
+        if len(primary_styles) == 1:
+            primary_style = primary_styles[0]
+            style_info = self.learning_styles[primary_style]
+            
+            result += f"Your primary learning style is **{primary_style}**\n\n"
+            result += f"**{primary_style} Characteristics**:\n"
+            result += f"{style_info['description']}\n\n"
+            
+            result += "**Recommended Study Strategies**:\n"
+            for tip in style_info['tips']:
+                result += f"- {tip}\n"
+            
+            # Add complementary strategies
+            complementary = [s for s in sorted_styles if s[0] != primary_style][0][0]
+            result += f"\nYou might also benefit from some **{complementary}** strategies:\n"
+            for tip in self.learning_styles[complementary]['tips'][:3]:
+                result += f"- {tip}\n"
         else:
-            result += "Tips for Kinesthetic Learners:\n"
-            result += "- Use hands-on activities\n"
-            result += "- Take frequent movement breaks\n"
-            result += "- Create physical models\n"
-            result += "- Associate information with physical actions\n"
-    else:
-        result += f"You have multiple strong learning styles: {', '.join(primary_styles)}\n\n"
-        result += "You may benefit from combining different learning approaches.\n"
-    
-    return result
+            result += "You have multiple strong learning styles:\n"
+            for style in primary_styles:
+                result += f"- **{style}**\n"
+            
+            result += "\n**Combined Learning Strategies**:\n"
+            result += "You may benefit from combining different learning approaches:\n"
+            for style in primary_styles:
+                result += f"\n**{style}** techniques:\n"
+                for tip in self.learning_styles[style]['tips'][:2]:
+                    result += f"- {tip}\n"
+        
+        return result
+
+# Initialize quiz instance
+learning_style_quiz = LearningStyleQuiz()
 
 # ========== PROFILE MANAGEMENT ==========
-def save_profile(name, age, interests, transcript, learning_style, 
-                movie, movie_reason, show, show_reason, 
-                book, book_reason, character, character_reason, blog):
-    age = int(age) if age else 0
+class ProfileManager:
+    def __init__(self):
+        self.profiles_dir = Path(PROFILES_DIR)
+        self.profiles_dir.mkdir(exist_ok=True)
     
-    favorites = {
-        "movie": movie,
-        "movie_reason": movie_reason,
-        "show": show,
-        "show_reason": show_reason,
-        "book": book,
-        "book_reason": book_reason,
-        "character": character,
-        "character_reason": character_reason
-    }
+    def save_profile(self, name: str, age: Union[int, str], interests: str, 
+                    transcript: Dict, learning_style: str, 
+                    movie: str, movie_reason: str, show: str, show_reason: str, 
+                    book: str, book_reason: str, character: str, character_reason: str, 
+                    blog: str) -> str:
+        """Save student profile with validation."""
+        try:
+            # Validate required fields
+            if not name.strip():
+                raise gr.Error("Name is required")
+            
+            name = sanitize_input(name)
+            age = validate_age(age)
+            interests = sanitize_input(interests)
+            
+            # Prepare favorites data
+            favorites = {
+                "movie": sanitize_input(movie),
+                "movie_reason": sanitize_input(movie_reason),
+                "show": sanitize_input(show),
+                "show_reason": sanitize_input(show_reason),
+                "book": sanitize_input(book),
+                "book_reason": sanitize_input(book_reason),
+                "character": sanitize_input(character),
+                "character_reason": sanitize_input(character_reason)
+            }
+            
+            # Prepare full profile data
+            data = {
+                "name": name,
+                "age": age,
+                "interests": interests,
+                "transcript": transcript if transcript else {},
+                "learning_style": learning_style if learning_style else "Not assessed",
+                "favorites": favorites,
+                "blog": sanitize_input(blog) if blog else ""
+            }
+            
+            # Save to JSON file
+            filename = f"{name.replace(' ', '_')}_profile.json"
+            filepath = self.profiles_dir / filename
+            
+            with open(filepath, "w", encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            
+            return self._generate_profile_summary(data)
+        
+        except Exception as e:
+            raise gr.Error(f"Error saving profile: {str(e)}")
     
-    data = {
-        "name": name,
-        "age": age,
-        "interests": interests,
-        "transcript": transcript,
-        "learning_style": learning_style,
-        "favorites": favorites,
-        "blog": blog
-    }
+    def load_profile(self, name: str = None) -> Dict:
+        """Load profile by name or return the first one found."""
+        try:
+            profiles = list(self.profiles_dir.glob("*.json"))
+            if not profiles:
+                return {}
+            
+            if name:
+                # Find profile by name
+                name = name.replace(" ", "_")
+                profile_file = self.profiles_dir / f"{name}_profile.json"
+                if not profile_file.exists():
+                    raise gr.Error(f"No profile found for {name}")
+            else:
+                # Load the first profile found
+                profile_file = profiles[0]
+            
+            with open(profile_file, "r", encoding='utf-8') as f:
+                return json.load(f)
+        
+        except Exception as e:
+            print(f"Error loading profile: {str(e)}")
+            return {}
     
-    os.makedirs("student_profiles", exist_ok=True)
-    json_path = os.path.join("student_profiles", f"{name.replace(' ', '_')}_profile.json")
-    with open(json_path, "w") as f:
-        json.dump(data, f, indent=2)
+    def list_profiles(self) -> List[str]:
+        """List all available profile names."""
+        profiles = list(self.profiles_dir.glob("*.json"))
+        return [p.stem.replace("_profile", "").replace("_", " ") for p in profiles]
+    
+    def _generate_profile_summary(self, data: Dict) -> str:
+        """Generate markdown summary of the profile."""
+        transcript = data.get("transcript", {})
+        favorites = data.get("favorites", {})
+        
+        markdown = f"""## Student Profile: {data['name']}
 
-    markdown_summary = f"""### Student Profile: {name}
-**Age:** {age}  
-**Interests:** {interests}  
-**Learning Style:** {learning_style}  
-#### Transcript:
-{transcript_display(transcript)}
-#### Favorites:
-- Movie: {favorites['movie']} ({favorites['movie_reason']})
-- Show: {favorites['show']} ({favorites['show_reason']})
-- Book: {favorites['book']} ({favorites['book_reason']})
-- Character: {favorites['character']} ({favorites['character_reason']})
-#### Blog:
-{blog if blog else "_No blog provided_"}
-"""
-    return markdown_summary
+### Basic Information
+- **Age:** {data['age']}
+- **Interests:** {data['interests']}
+- **Learning Style:** {data['learning_style'].split('##')[0].strip()}
 
-def transcript_display(transcript_dict):
-    if not transcript_dict or "courses" not in transcript_dict:
-        return "No course information available"
-    
-    display = "### Detailed Course History\n"
-    courses_by_grade = transcript_dict["courses"]
-    
-    if isinstance(courses_by_grade, dict):
-        for grade in sorted(courses_by_grade.keys(), key=int):
-            display += f"\n**Grade {grade}**\n"
-            for course in courses_by_grade[grade]:
-                display += f"- {course['name']}"
-                if 'grade' in course and course['grade']:
-                    display += f" (Grade: {course['grade']})"
-                if 'credits' in course:
-                    display += f" | Credits: {course['credits']}"
-                display += f" | Year: {course['year']}\n"
-    
-    if 'gpa' in transcript_dict:
-        gpa = transcript_dict['gpa']
-        display += "\n**GPA Information**\n"
-        display += f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
-        display += f"- Weighted: {gpa.get('weighted', 'N/A')}\n"
+### Academic Information
+{self._format_transcript(transcript)}
+
+### Favorites
+- **Movie:** {favorites.get('movie', 'Not specified')}  
+  *Reason:* {favorites.get('movie_reason', 'Not specified')}
+- **TV Show:** {favorites.get('show', 'Not specified')}  
+  *Reason:* {favorites.get('show_reason', 'Not specified')}
+- **Book:** {favorites.get('book', 'Not specified')}  
+  *Reason:* {favorites.get('book_reason', 'Not specified')}
+- **Character:** {favorites.get('character', 'Not specified')}  
+  *Reason:* {favorites.get('character_reason', 'Not specified')}
+
+### Personal Blog
+{data.get('blog', '_No blog provided_')}
+"""
+        return markdown
     
-    return display
+    def _format_transcript(self, transcript: Dict) -> str:
+        """Format transcript data for display."""
+        if not transcript or "courses" not in transcript:
+            return "_No transcript information available_"
+        
+        display = "#### Course History\n"
+        courses_by_grade = transcript["courses"]
+        
+        if isinstance(courses_by_grade, dict):
+            for grade in sorted(courses_by_grade.keys(), key=lambda x: int(x) if x.isdigit() else x):
+                display += f"\n**Grade {grade}**\n"
+                for course in courses_by_grade[grade]:
+                    display += f"- {course.get('name', 'Unnamed course')}"
+                    if 'grade' in course and course['grade']:
+                        display += f" (Grade: {course['grade']})"
+                    if 'credits' in course:
+                        display += f" | Credits: {course['credits']}"
+                    display += f" | Year: {course.get('year', 'N/A')}\n"
+        
+        if 'gpa' in transcript:
+            gpa = transcript['gpa']
+            display += "\n**GPA**\n"
+            display += f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
+            display += f"- Weighted: {gpa.get('weighted', 'N/A')}\n"
+        
+        return display
 
-def load_profile():
-    if not os.path.exists("student_profiles"):
-        return {}
-    files = [f for f in os.listdir("student_profiles") if f.endswith('.json')]
-    if files:
-        with open(os.path.join("student_profiles", files[0]), "r") as f:
-            return json.load(f)
-    return {}
+# Initialize profile manager
+profile_manager = ProfileManager()
 
-def generate_response(message, history):
-    profile = load_profile()
-    if not profile:
-        return "Please complete and save your profile first using the previous tabs."
+# ========== AI TEACHING ASSISTANT ==========
+class TeachingAssistant:
+    def __init__(self):
+        self.context_history = []
+        self.max_context_length = 5  # Keep last 5 exchanges for context
     
-    learning_style = profile.get("learning_style", "")
-    grade_level = profile.get("transcript", {}).get("grade_level", "unknown")
-    gpa = profile.get("transcript", {}).get("gpa", {})
-    interests = profile.get("interests", "")
-    courses = profile.get("transcript", {}).get("courses", {})
+    def generate_response(self, message: str, history: List[Tuple[str, str]]) -> str:
+        """Generate personalized response based on student profile and context."""
+        try:
+            # Load profile (simplified - in real app would handle multiple profiles)
+            profile = profile_manager.load_profile()
+            if not profile:
+                return "Please complete and save your profile first using the previous tabs."
+            
+            # Update context history
+            self._update_context(message, history)
+            
+            # Extract profile information
+            name = profile.get("name", "there")
+            learning_style = profile.get("learning_style", "")
+            grade_level = profile.get("transcript", {}).get("grade_level", "unknown")
+            gpa = profile.get("transcript", {}).get("gpa", {})
+            interests = profile.get("interests", "")
+            courses = profile.get("transcript", {}).get("courses", {})
+            favorites = profile.get("favorites", {})
+            
+            # Process message with context
+            response = self._process_message(message, profile)
+            
+            # Add follow-up suggestions
+            if "study" in message.lower() or "learn" in message.lower():
+                response += "\n\nWould you like me to suggest a study schedule based on your courses?"
+            elif "course" in message.lower() or "class" in message.lower():
+                response += "\n\nWould you like help finding resources for any of these courses?"
+            
+            return response
+        
+        except Exception as e:
+            print(f"Error generating response: {str(e)}")
+            return "I encountered an error processing your request. Please try again."
     
-    greetings = ["hi", "hello", "hey"]
-    study_help = ["study", "learn", "prepare", "exam"]
-    grade_help = ["grade", "gpa", "score"]
-    interest_help = ["interest", "hobby", "passion"]
-    course_help = ["courses", "classes", "transcript", "schedule"]
+    def _update_context(self, message: str, history: List[Tuple[str, str]]) -> None:
+        """Maintain conversation context."""
+        self.context_history.append(("user", message))
+        if history:
+            for h in history[-self.max_context_length:]:
+                self.context_history.append(("user", h[0]))
+                self.context_history.append(("assistant", h[1]))
+        
+        # Trim to maintain max context length
+        self.context_history = self.context_history[-(self.max_context_length*2):]
     
-    if any(greet in message.lower() for greet in greetings):
-        return f"Hello {profile.get('name', 'there')}! How can I help you today?"
+    def _process_message(self, message: str, profile: Dict) -> str:
+        """Process user message with profile context."""
+        message_lower = message.lower()
+        
+        # Greetings
+        if any(greet in message_lower for greet in ["hi", "hello", "hey", "greetings"]):
+            return f"Hello {profile.get('name', 'there')}! How can I help you with your learning today?"
+        
+        # Study help
+        study_words = ["study", "learn", "prepare", "exam", "test", "homework"]
+        if any(word in message_lower for word in study_words):
+            return self._generate_study_advice(profile)
+        
+        # Grade help
+        grade_words = ["grade", "gpa", "score", "marks", "results"]
+        if any(word in message_lower for word in grade_words):
+            return self._generate_grade_advice(profile)
+        
+        # Interest help
+        interest_words = ["interest", "hobby", "passion", "extracurricular"]
+        if any(word in message_lower for word in interest_words):
+            return self._generate_interest_advice(profile)
+        
+        # Course help
+        course_words = ["courses", "classes", "transcript", "schedule", "subject"]
+        if any(word in message_lower for word in course_words):
+            return self._generate_course_advice(profile)
+        
+        # Favorites
+        favorite_words = ["movie", "show", "book", "character", "favorite"]
+        if any(word in message_lower for word in favorite_words):
+            return self._generate_favorites_response(profile)
+        
+        # General help
+        if "help" in message_lower:
+            return self._generate_help_response()
+        
+        # Default response
+        return ("I'm your personalized teaching assistant. I can help with study tips, "
+                "grade information, course advice, and more. Try asking about how to "
+                "study effectively or about your course history.")
     
-    elif any(word in message.lower() for word in study_help):
+    def _generate_study_advice(self, profile: Dict) -> str:
+        """Generate study advice based on learning style."""
+        learning_style = profile.get("learning_style", "")
+        response = ""
+        
         if "Visual" in learning_style:
             response = ("Based on your visual learning style, I recommend:\n"
-                       "- Creating mind maps or diagrams\n"
-                       "- Using color-coded notes\n"
-                       "- Watching educational videos")
+                       "- Creating colorful mind maps or diagrams\n"
+                       "- Using highlighters to color-code your notes\n"
+                       "- Watching educational videos on the topics\n"
+                       "- Creating flashcards with images\n\n")
         elif "Auditory" in learning_style:
             response = ("Based on your auditory learning style, I recommend:\n"
-                       "- Recording lectures and listening to them\n"
-                       "- Participating in study groups\n"
-                       "- Explaining concepts out loud")
+                       "- Recording your notes and listening to them\n"
+                       "- Participating in study groups to discuss concepts\n"
+                       "- Explaining the material out loud to yourself\n"
+                       "- Finding podcasts or audio lectures on the topics\n\n")
         elif "Reading/Writing" in learning_style:
             response = ("Based on your reading/writing learning style, I recommend:\n"
-                       "- Writing detailed notes\n"
-                       "- Creating summaries in your own words\n"
-                       "- Reading textbooks and articles")
+                       "- Writing detailed summaries in your own words\n"
+                       "- Creating organized outlines of the material\n"
+                       "- Reading additional textbooks or articles\n"
+                       "- Rewriting your notes to reinforce learning\n\n")
         elif "Kinesthetic" in learning_style:
             response = ("Based on your kinesthetic learning style, I recommend:\n"
-                       "- Hands-on practice\n"
-                       "- Creating physical models\n"
-                       "- Taking frequent movement breaks")
+                       "- Creating physical models or demonstrations\n"
+                       "- Using hands-on activities to learn concepts\n"
+                       "- Taking frequent movement breaks while studying\n"
+                       "- Associating information with physical actions\n\n")
         else:
             response = ("Here are some general study tips:\n"
-                       "- Break study sessions into 25-minute chunks\n"
-                       "- Review material regularly\n"
-                       "- Teach concepts to someone else")
+                       "- Use the Pomodoro technique (25 min study, 5 min break)\n"
+                       "- Space out your study sessions over time\n"
+                       "- Test yourself with practice questions\n"
+                       "- Teach the material to someone else\n\n")
+        
+        # Add time management advice
+        response += ("**Time Management Tips**:\n"
+                    "- Create a study schedule and stick to it\n"
+                    "- Prioritize difficult subjects when you're most alert\n"
+                    "- Break large tasks into smaller, manageable chunks\n"
+                    "- Set specific goals for each study session")
         
         return response
     
-    elif any(word in message.lower() for word in grade_help):
-        return (f"Your GPA information:\n"
-               f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
-               f"- Weighted: {gpa.get('weighted', 'N/A')}\n\n"
-               "To improve your grades, try:\n"
-               "- Setting specific goals\n"
-               "- Meeting with teachers\n"
-               "- Developing a study schedule")
+    def _generate_grade_advice(self, profile: Dict) -> str:
+        """Generate response about grades and GPA."""
+        gpa = profile.get("transcript", {}).get("gpa", {})
+        courses = profile.get("transcript", {}).get("courses", {})
+        
+        response = (f"Your GPA information:\n"
+                   f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
+                   f"- Weighted: {gpa.get('weighted', 'N/A')}\n\n")
+        
+        # Identify any failing grades
+        weak_subjects = []
+        for grade_level, course_list in courses.items():
+            for course in course_list:
+                if course.get('grade', '').upper() in ['D', 'F']:
+                    weak_subjects.append(course.get('name', 'Unknown course'))
+        
+        if weak_subjects:
+            response += ("**Areas for Improvement**:\n"
+                        f"You might want to focus on these subjects: {', '.join(weak_subjects)}\n\n")
+        
+        response += ("**Grade Improvement Strategies**:\n"
+                    "- Meet with your teachers to discuss your performance\n"
+                    "- Identify specific areas where you lost points\n"
+                    "- Create a targeted study plan for weak areas\n"
+                    "- Practice with past exams or sample questions")
+        
+        return response
     
-    elif any(word in message.lower() for word in interest_help):
-        return (f"I see you're interested in: {interests}\n\n"
-               "You might want to:\n"
-               "- Find clubs or activities related to these interests\n"
-               "- Explore career paths that align with them")
+    def _generate_interest_advice(self, profile: Dict) -> str:
+        """Generate response based on student interests."""
+        interests = profile.get("interests", "")
+        response = f"I see you're interested in: {interests}\n\n"
+        
+        response += ("**Suggestions**:\n"
+                    "- Look for clubs or extracurricular activities related to these interests\n"
+                    "- Explore career paths that align with these interests\n"
+                    "- Find online communities or forums about these topics\n"
+                    "- Consider projects or independent study in these areas")
+        
+        return response
     
-    elif any(word in message.lower() for word in course_help):
+    def _generate_course_advice(self, profile: Dict) -> str:
+        """Generate response about courses."""
+        courses = profile.get("transcript", {}).get("courses", {})
+        grade_level = profile.get("transcript", {}).get("grade_level", "unknown")
+        
         response = "Here's a summary of your courses:\n"
-        for grade in sorted(courses.keys(), key=int):
-            response += f"\nGrade {grade}:\n"
+        for grade in sorted(courses.keys(), key=lambda x: int(x) if x.isdigit() else x):
+            response += f"\n**Grade {grade}**:\n"
             for course in courses[grade]:
-                response += f"- {course['name']}"
+                response += f"- {course.get('name', 'Unnamed course')}"
                 if 'grade' in course:
                     response += f" (Grade: {course['grade']})"
                 response += "\n"
+        
+        response += f"\nAs a grade {grade_level} student, you might want to:\n"
+        if grade_level in ["9", "10"]:
+            response += ("- Focus on building strong foundational skills\n"
+                        "- Explore different subjects to find your interests\n"
+                        "- Start thinking about college/career requirements")
+        elif grade_level in ["11", "12"]:
+            response += ("- Focus on courses relevant to your college/career goals\n"
+                        "- Consider taking AP or advanced courses if available\n"
+                        "- Ensure you're meeting graduation requirements")
+        
         return response
     
-    elif "help" in message.lower():
-        return ("I can help with:\n"
-               "- Study tips based on your learning style\n"
-               "- GPA and grade information\n"
-               "- Course history and schedules\n"
-               "- General academic advice\n\n"
-               "Try asking about study strategies or your grades!")
+    def _generate_favorites_response(self, profile: Dict) -> str:
+        """Generate response about favorite items."""
+        favorites = profile.get("favorites", {})
+        response = "I see you enjoy:\n"
+        
+        if favorites.get('movie'):
+            response += f"- Movie: {favorites['movie']} ({favorites.get('movie_reason', 'no reason provided')})\n"
+        if favorites.get('show'):
+            response += f"- TV Show: {favorites['show']} ({favorites.get('show_reason', 'no reason provided')})\n"
+        if favorites.get('book'):
+            response += f"- Book: {favorites['book']} ({favorites.get('book_reason', 'no reason provided')})\n"
+        if favorites.get('character'):
+            response += f"- Character: {favorites['character']} ({favorites.get('character_reason', 'no reason provided')})\n"
+        
+        response += "\nThese preferences suggest you might enjoy:\n"
+        response += "- Similar books/movies in the same genre\n"
+        response += "- Creative projects related to these stories\n"
+        response += "- Analyzing themes or characters in your schoolwork"
+        
+        return response
     
-    else:
-        return ("I'm your personalized teaching assistant. "
-               "I can help with study tips, grade information, and academic advice. "
-               "Try asking about how to study for your classes!")
+    def _generate_help_response(self) -> str:
+        """Generate help response with available commands."""
+        return ("""I can help with:
+- **Study tips**: "How should I study for math?"
+- **Grade information**: "What's my GPA?"
+- **Course advice**: "Show me my course history"
+- **Interest suggestions**: "What clubs match my interests?"
+- **General advice**: "How can I improve my grades?"
+
+Try asking about any of these topics!""")
+
+# Initialize teaching assistant
+teaching_assistant = TeachingAssistant()
 
 # ========== GRADIO INTERFACE ==========
-with gr.Blocks() as app:
-    with gr.Tab("Step 1: Upload Transcript"):
-        gr.Markdown("### Upload your transcript (PDF recommended for best results)")
-        transcript_file = gr.File(label="Transcript file", file_types=[".pdf"])
-        transcript_output = gr.Textbox(label="Transcript Results", lines=20)
-        transcript_data = gr.State()
-        transcript_file.change(
-            fn=parse_transcript,
-            inputs=transcript_file,
-            outputs=[transcript_output, transcript_data]
+def create_interface():
+    with gr.Blocks(theme=gr.themes.Soft(), title="Student Learning Assistant") as app:
+        # Custom CSS for better styling
+        app.css = """
+        .gradio-container {
+            max-width: 1200px !important;
+            margin: 0 auto;
+        }
+        .tab {
+            padding: 20px;
+            border-radius: 8px;
+            background: white;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        .progress-bar {
+            height: 5px;
+            background: linear-gradient(to right, #4CAF50, #8BC34A);
+            margin-bottom: 15px;
+            border-radius: 3px;
+        }
+        .quiz-question {
+            margin-bottom: 15px;
+            padding: 15px;
+            background: #f5f5f5;
+            border-radius: 5px;
+        }
+        """
+        
+        gr.Markdown("""
+        # Student Learning Assistant
+        **Your personalized education companion**  
+        Complete each step to get customized learning recommendations.
+        """)
+        
+        # Progress tracker
+        with gr.Row():
+            with gr.Column(scale=1):
+                step1 = gr.Button("1. Upload Transcript", variant="primary")
+            with gr.Column(scale=1):
+                step2 = gr.Button("2. Learning Style Quiz")
+            with gr.Column(scale=1):
+                step3 = gr.Button("3. Personal Questions")
+            with gr.Column(scale=1):
+                step4 = gr.Button("4. Save & Review")
+            with gr.Column(scale=1):
+                step5 = gr.Button("5. AI Assistant")
+        
+        # Tab navigation logic
+        def navigate_to_tab(tab_index):
+            return {tab: gr.update(visible=(i == tab_index)) for i, tab in enumerate(tabs)}
+        
+        # Main tabs
+        with gr.Tabs() as tabs:
+            # ===== TAB 1: Transcript Upload =====
+            with gr.Tab("Transcript Upload", id=0) as tab1:
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Step 1: Upload Your Transcript")
+                        gr.Markdown("Upload a PDF of your academic transcript to analyze your courses and GPA.")
+                        
+                        with gr.Group():
+                            transcript_file = gr.File(
+                                label="Transcript PDF",
+                                file_types=ALLOWED_FILE_TYPES,
+                                type="filepath"
+                            )
+                            upload_btn = gr.Button("Upload & Analyze", variant="primary")
+                        
+                        gr.Markdown("**Note**: Your file is processed locally and not stored permanently.")
+                    
+                    with gr.Column(scale=2):
+                        transcript_output = gr.Textbox(
+                            label="Transcript Analysis",
+                            lines=20,
+                            interactive=False
+                        )
+                        transcript_data = gr.State()
+                
+                upload_btn.click(
+                    fn=parse_transcript,
+                    inputs=transcript_file,
+                    outputs=[transcript_output, transcript_data]
+                )
+            
+            # ===== TAB 2: Learning Style Quiz =====
+            with gr.Tab("Learning Style Quiz", id=1) as tab2:
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Step 2: Discover Your Learning Style")
+                        gr.Markdown("Complete this 20-question quiz to identify whether you're a visual, auditory, reading/writing, or kinesthetic learner.")
+                        
+                        progress = gr.HTML("<div class='progress-bar' style='width: 0%'></div>")
+                        quiz_submit = gr.Button("Submit Quiz", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        quiz_components = []
+                        with gr.Accordion("Quiz Questions", open=True):
+                            for i, (question, options) in enumerate(zip(learning_style_quiz.questions, learning_style_quiz.options)):
+                                with gr.Group(elem_classes="quiz-question"):
+                                    q = gr.Radio(
+                                        options,
+                                        label=f"{i+1}. {question}",
+                                        show_label=True
+                                    )
+                                    quiz_components.append(q)
+                        
+                        learning_output = gr.Markdown(
+                            label="Your Learning Style Results",
+                            visible=False
+                        )
+                
+                # Update progress bar as questions are answered
+                for component in quiz_components:
+                    component.change(
+                        fn=lambda *answers: {
+                            progress: gr.HTML(
+                                f"<div class='progress-bar' style='width: {sum(1 for a in answers if a)/len(answers)*100}%'></div>"
+                            )
+                        },
+                        inputs=quiz_components,
+                        outputs=progress
+                    )
+                
+                quiz_submit.click(
+                    fn=learning_style_quiz.evaluate_quiz,
+                    inputs=quiz_components,
+                    outputs=learning_output
+                ).then(
+                    fn=lambda: gr.update(visible=True),
+                    outputs=learning_output
+                )
+            
+            # ===== TAB 3: Personal Questions =====
+            with gr.Tab("Personal Profile", id=2) as tab3:
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Step 3: Tell Us About Yourself")
+                        gr.Markdown("This information helps us provide personalized recommendations.")
+                        
+                        with gr.Group():
+                            name = gr.Textbox(label="Full Name", placeholder="Your name")
+                            age = gr.Number(label="Age", minimum=MIN_AGE, maximum=MAX_AGE, precision=0)
+                            interests = gr.Textbox(
+                                label="Your Interests/Hobbies",
+                                placeholder="e.g., Science, Music, Sports, Art..."
+                            )
+                        
+                        gr.Markdown("### Favorites")
+                        with gr.Group():
+                            movie = gr.Textbox(label="Favorite Movie")
+                            movie_reason = gr.Textbox(label="Why do you like it?", lines=2)
+                            show = gr.Textbox(label="Favorite TV Show")
+                            show_reason = gr.Textbox(label="Why do you like it?", lines=2)
+                            book = gr.Textbox(label="Favorite Book")
+                            book_reason = gr.Textbox(label="Why do you like it?", lines=2)
+                            character = gr.Textbox(label="Favorite Character (from any story)")
+                            character_reason = gr.Textbox(label="Why do you like them?", lines=2)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Additional Information")
+                        
+                        blog_checkbox = gr.Checkbox(
+                            label="Would you like to write a short blog about your learning experiences?",
+                            value=False
+                        )
+                        blog_text = gr.Textbox(
+                            label="Your Learning Blog",
+                            placeholder="Write about your learning journey, challenges, goals...",
+                            lines=8,
+                            visible=False
+                        )
+                        blog_checkbox.change(
+                            lambda x: gr.update(visible=x),
+                            inputs=blog_checkbox,
+                            outputs=blog_text
+                        )
+            
+            # ===== TAB 4: Save & Review =====
+            with gr.Tab("Save Profile", id=3) as tab4:
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Step 4: Review & Save Your Profile")
+                        gr.Markdown("Verify your information before saving. You can return to previous steps to make changes.")
+                        
+                        save_btn = gr.Button("Save Profile", variant="primary")
+                        load_profile_dropdown = gr.Dropdown(
+                            label="Or load existing profile",
+                            choices=profile_manager.list_profiles(),
+                            visible=bool(profile_manager.list_profiles())
+                        )
+                        load_btn = gr.Button("Load Profile", visible=bool(profile_manager.list_profiles()))
+                    
+                    with gr.Column(scale=2):
+                        output_summary = gr.Markdown(
+                            "Your profile summary will appear here after saving.",
+                            label="Profile Summary"
+                        )
+                
+                save_btn.click(
+                    fn=profile_manager.save_profile,
+                    inputs=[
+                        name, age, interests, transcript_data, learning_output,
+                        movie, movie_reason, show, show_reason,
+                        book, book_reason, character, character_reason, blog_text
+                    ],
+                    outputs=output_summary
+                )
+                
+                load_btn.click(
+                    fn=lambda name: profile_manager.load_profile(name),
+                    inputs=load_profile_dropdown,
+                    outputs=output_summary
+                )
+            
+            # ===== TAB 5: AI Teaching Assistant =====
+            with gr.Tab("AI Assistant", id=4) as tab5:
+                gr.Markdown("## Your Personalized Learning Assistant")
+                gr.Markdown("Ask me anything about studying, your courses, grades, or learning strategies.")
+                
+                chatbot = gr.ChatInterface(
+                    fn=teaching_assistant.generate_response,
+                    examples=[
+                        "How should I study for my next math test?",
+                        "What's my current GPA?",
+                        "Show me my course history",
+                        "How can I improve my grades in science?",
+                        "What study methods match my learning style?"
+                    ],
+                    title="",
+                    retry_btn=None,
+                    undo_btn=None
+                )
+        
+        # Tab navigation buttons
+        step1.click(
+            fn=lambda: navigate_to_tab(0),
+            outputs={tab: tab for tab in tabs}
         )
-
-    with gr.Tab("Step 2: Learning Style Quiz"):
-        gr.Markdown("### Learning Style Quiz (20 Questions)")
-        quiz_components = []
-        for i, (question, options) in enumerate(zip(learning_style_questions, learning_style_options)):
-            quiz_components.append(gr.Radio(options, label=f"{i+1}. {question}"))
-        
-        learning_output = gr.Textbox(label="Your Learning Style", lines=15)
-        gr.Button("Submit Quiz").click(
-            fn=learning_style_quiz,
-            inputs=quiz_components,
-            outputs=learning_output
+        step2.click(
+            fn=lambda: navigate_to_tab(1),
+            outputs={tab: tab for tab in tabs}
         )
-
-    with gr.Tab("Step 3: Personal Questions"):
-        name = gr.Textbox(label="What's your name?")
-        age = gr.Number(label="How old are you?", precision=0)
-        interests = gr.Textbox(label="What are your interests?")
-        movie = gr.Textbox(label="Favorite movie?")
-        movie_reason = gr.Textbox(label="Why do you like that movie?")
-        show = gr.Textbox(label="Favorite TV show?")
-        show_reason = gr.Textbox(label="Why do you like that show?")
-        book = gr.Textbox(label="Favorite book?")
-        book_reason = gr.Textbox(label="Why do you like that book?")
-        character = gr.Textbox(label="Favorite character?")
-        character_reason = gr.Textbox(label="Why do you like that character?")
-        blog_checkbox = gr.Checkbox(label="Do you want to write a blog?", value=False)
-        blog_text = gr.Textbox(label="Write your blog here", visible=False, lines=5)
-        blog_checkbox.change(lambda x: gr.update(visible=x), inputs=blog_checkbox, outputs=blog_text)
-
-    with gr.Tab("Step 4: Save & Review"):
-        output_summary = gr.Markdown()
-        save_btn = gr.Button("Save Profile")
-        save_btn.click(
-            fn=save_profile,
-            inputs=[name, age, interests, transcript_data, learning_output,
-                   movie, movie_reason, show, show_reason,
-                   book, book_reason, character, character_reason, blog_text],
-            outputs=output_summary
+        step3.click(
+            fn=lambda: navigate_to_tab(2),
+            outputs={tab: tab for tab in tabs}
         )
-
-    with gr.Tab("🤖 AI Teaching Assistant"):
-        gr.Markdown("## Your Personalized Learning Assistant")
-        chatbot = gr.ChatInterface(
-            fn=generate_response,
-            examples=[
-                "How should I study for my next test?",
-                "What's my GPA information?",
-                "Show me my course history",
-                "How can I improve my grades?"
-            ]
+        step4.click(
+            fn=lambda: navigate_to_tab(3),
+            outputs={tab: tab for tab in tabs}
         )
+        step5.click(
+            fn=lambda: navigate_to_tab(4),
+            outputs={tab: tab for tab in tabs}
+        )
+    
+    return app
+
+# Create and launch the interface
+app = create_interface()
 
-app.launch()
+# For Hugging Face Spaces, we need to call launch() in the script
+if __name__ == "__main__":
+    app.launch()
+