Update app.py

app.py

@@ -3,9 +3,12 @@ import pandas as pd
 import json
 import os
 import re
+import hashlib
+from datetime import datetime
 from PyPDF2 import PdfReader
 from collections import defaultdict
 from transformers import pipeline
+from typing import Dict, List, Optional
 
 # Initialize NER model (will load only if transformers is available)
 try:
@@ -15,12 +18,12 @@ except Exception as e:
     ner_pipeline = None
 
 # ========== IMPROVED TRANSCRIPT PARSING ==========
-def extract_gpa(text, gpa_type):
+def extract_gpa(text: str, gpa_type: str) -> str:
     pattern = rf'{gpa_type}\s*([\d\.]+)'
     match = re.search(pattern, text)
     return match.group(1) if match else "N/A"
 
-def extract_courses_from_table(text):
+def extract_courses_from_table(text: str) -> Dict[str, List[Dict]]:
     # This pattern matches the course table rows in the transcript
     course_pattern = re.compile(
         r'(\d{4}-\d{4})\s*'  # School year
@@ -58,53 +61,56 @@ def extract_courses_from_table(text):
     
     return courses_by_grade
 
-def parse_transcript(file):
-    if file.name.endswith('.pdf'):
-        text = ''
-        reader = PdfReader(file)
-        for page in reader.pages:
-            text += page.extract_text() + '\n'
-        
-        # Extract GPA information
-        gpa_data = {
-            'weighted': extract_gpa(text, 'Weighted GPA'),
-            'unweighted': extract_gpa(text, 'Un-weighted GPA')
-        }
-        
-        # Extract current grade level
-        grade_match = re.search(r'Current Grade:\s*(\d+)', text)
-        grade_level = grade_match.group(1) if grade_match else "Unknown"
-        
-        # Extract all courses with grades and year taken
-        courses_by_grade = extract_courses_from_table(text)
-        
-        # Prepare detailed output
-        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"
-        
-        # Sort grades numerically (09, 10, 11, 12)
-        for grade in sorted(courses_by_grade.keys(), key=int):
-            output_text += f"\nGrade {grade}:\n{'-'*30}\n"
-            for course in courses_by_grade[grade]:
-                output_text += f"- {course['name']}"
-                if 'grade' in course and course['grade']:
-                    output_text += f" (Grade: {course['grade']})"
-                if 'credits' in course:
-                    output_text += f" | Credits: {course['credits']}"
-                output_text += f" | Year: {course['year']}\n"
-        
-        return output_text, {
-            "gpa": gpa_data,
-            "grade_level": grade_level,
-            "courses": dict(courses_by_grade)
-        }
-    else:
-        return "Unsupported file format (PDF only for transcript parsing)", None
+def parse_transcript(file) -> tuple:
+    try:
+        if file.name.endswith('.pdf'):
+            text = ''
+            reader = PdfReader(file)
+            for page in reader.pages:
+                text += page.extract_text() + '\n'
+            
+            # Extract GPA information
+            gpa_data = {
+                'weighted': extract_gpa(text, 'Weighted GPA'),
+                'unweighted': extract_gpa(text, 'Un-weighted GPA')
+            }
+            
+            # Extract current grade level
+            grade_match = re.search(r'Current Grade:\s*(\d+)', text)
+            grade_level = grade_match.group(1) if grade_match else "Unknown"
+            
+            # Extract all courses with grades and year taken
+            courses_by_grade = extract_courses_from_table(text)
+            
+            # Prepare detailed output
+            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"
+            
+            # Sort grades numerically (09, 10, 11, 12)
+            for grade in sorted(courses_by_grade.keys(), key=int):
+                output_text += f"\nGrade {grade}:\n{'-'*30}\n"
+                for course in courses_by_grade[grade]:
+                    output_text += f"- {course['name']}"
+                    if 'grade' in course and course['grade']:
+                        output_text += f" (Grade: {course['grade']})"
+                    if 'credits' in course:
+                        output_text += f" | Credits: {course['credits']}"
+                    output_text += f" | Year: {course['year']}\n"
+            
+            return output_text, {
+                "gpa": gpa_data,
+                "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 ==========
+# ========== ENHANCED 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:",
@@ -151,7 +157,7 @@ learning_style_options = [
     ["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):
+def learning_style_quiz(*answers) -> str:
     scores = {
         "Visual": 0,
         "Auditory": 0,
@@ -197,80 +203,132 @@ def learning_style_quiz(*answers):
             result += "- Create mind maps and diagrams\n"
             result += "- Watch educational videos\n"
             result += "- Use flashcards with images\n"
+            result += "- Highlight key information in different colors\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"
+            result += "- Listen to educational podcasts\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"
+            result += "- Rewrite your notes to reinforce learning\n"
         else:  # Kinesthetic
             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"
+            result += "- Study while walking or using a standing desk\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"
+        result += "You may benefit from combining different learning approaches:\n"
+        if "Visual" in primary_styles:
+            result += "- Create visual representations of what you're learning\n"
+        if "Auditory" in primary_styles:
+            result += "- Discuss concepts with others or record yourself explaining them\n"
+        if "Reading/Writing" in primary_styles:
+            result += "- Write summaries and read additional materials\n"
+        if "Kinesthetic" in primary_styles:
+            result += "- Incorporate physical movement into your study sessions\n"
+    
+    # Add general study tips
+    result += "\nAdditional Study Tips for All Learners:\n"
+    result += "- Use the Pomodoro technique (25 min study, 5 min break)\n"
+    result += "- Teach concepts to someone else to reinforce your understanding\n"
+    result += "- Connect new information to what you already know\n"
+    result += "- Get adequate sleep to consolidate memories\n"
     
     return result
 
-# ========== SAVE STUDENT PROFILE ==========
-def save_profile(name, age, interests, transcript, learning_style, 
-                movie, movie_reason, show, show_reason, 
-                book, book_reason, character, character_reason, blog):
+# ========== ENHANCED STUDENT PROFILE SYSTEM ==========
+def hash_sensitive_data(data: str) -> str:
+    """Hash sensitive data for privacy protection"""
+    return hashlib.sha256(data.encode()).hexdigest()
+
+def get_profile_list() -> List[str]:
+    """Get list of available profiles"""
+    if not os.path.exists("student_profiles"):
+        return []
+    return [f.replace("_profile.json", "").replace("_", " ") 
+            for f in os.listdir("student_profiles") 
+            if f.endswith('_profile.json')]
+
+def save_profile(name: str, age: int, 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, goals: str, study_preferences: str) -> str:
+    """Save student profile with enhanced features"""
     # Convert age to int if it's a numpy number (from gradio Number input)
     age = int(age) if age else 0
     
-    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
-    }
-    
-    data = {
+    # Create profile dictionary
+    profile_data = {
         "name": name,
         "age": age,
         "interests": interests,
         "transcript": transcript,
         "learning_style": learning_style,
-        "favorites": favorites,
-        "blog": blog
+        "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
+        },
+        "blog": blog,
+        "goals": goals,
+        "study_preferences": study_preferences,
+        "last_updated": datetime.now().isoformat(),
+        "security": {
+            "name_hash": hash_sensitive_data(name),
+            "interests_hash": hash_sensitive_data(interests)
+        }
     }
     
+    # Save to file
     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)
+    filename = f"{name.replace(' ', '_')}_profile.json"
+    filepath = os.path.join("student_profiles", filename)
+    
+    with open(filepath, "w") as f:
+        json.dump(profile_data, f, indent=2)
+    
+    return f"Profile saved successfully as {filename}"
 
-    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
+def load_profile(profile_name: str = None) -> Optional[Dict]:
+    """Load student profile with error handling"""
+    if not os.path.exists("student_profiles"):
+        return None
+    
+    if profile_name is None:
+        # Load the first profile if none specified
+        files = [f for f in os.listdir("student_profiles") if f.endswith('.json')]
+        if not files:
+            return None
+        filepath = os.path.join("student_profiles", files[0])
+    else:
+        # Load specific profile
+        filename = f"{profile_name.replace(' ', '_')}_profile.json"
+        filepath = os.path.join("student_profiles", filename)
+    
+    try:
+        with open(filepath, "r") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        print(f"Error loading profile: {e}")
+        return None
 
-def transcript_display(transcript_dict):
+def transcript_display(transcript_dict: dict) -> str:
+    """Format transcript data for display"""
     if not transcript_dict or "courses" not in transcript_dict:
         return "No course information available"
     
@@ -297,169 +355,547 @@ def transcript_display(transcript_dict):
     
     return display
 
-# ========== AI TEACHING ASSISTANT ==========
-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 {}
-
-def generate_response(message, history):
-    profile = load_profile()
+def generate_profile_summary(profile: dict) -> str:
+    """Generate markdown summary of profile"""
     if not profile:
-        return "Please complete and save your profile first using the previous tabs."
-    
-    # Get profile data
-    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", {})
-    
-    # Common responses
-    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"]
-    
-    if any(greet in message.lower() for greet in greetings):
-        return f"Hello {profile.get('name', 'there')}! How can I help you today?"
-    
-    elif any(word in message.lower() for word in study_help):
+        return "No profile data available"
+    
+    name = profile.get("name", "Unknown")
+    age = profile.get("age", "Unknown")
+    interests = profile.get("interests", "Not specified")
+    learning_style = profile.get("learning_style", "Not determined")
+    favorites = profile.get("favorites", {})
+    blog = profile.get("blog", "")
+    goals = profile.get("goals", "")
+    study_preferences = profile.get("study_preferences", "")
+    
+    markdown = f"""## Student Profile: {name}
+**Age:** {age}  
+**Interests:** {interests}  
+**Learning Style:** {learning_style}  
+
+### Academic Information
+{transcript_display(profile.get("transcript", {}))}
+
+### Goals
+{goals if goals else "_No goals specified_"}
+
+### Study Preferences
+{study_preferences if study_preferences else "_No study preferences specified_"}
+
+### Favorites
+- **Movie:** {favorites.get('movie', 'Not specified')} ({favorites.get('movie_reason', 'No reason given')})
+- **TV Show:** {favorites.get('show', 'Not specified')} ({favorites.get('show_reason', 'No reason given')})
+- **Book:** {favorites.get('book', 'Not specified')} ({favorites.get('book_reason', 'No reason given')})
+- **Character:** {favorites.get('character', 'Not specified')} ({favorites.get('character_reason', 'No reason given')})
+
+### Personal Blog
+{blog if blog else "_No blog provided_"}
+"""
+    return markdown
+
+# ========== ENHANCED AI TEACHING ASSISTANT ==========
+class TeachingAssistant:
+    def __init__(self):
+        self.conversation_history = []
+        self.current_profile = None
+    
+    def load_profile(self, profile_name: str = None) -> bool:
+        """Load a student profile"""
+        self.current_profile = load_profile(profile_name)
+        if self.current_profile:
+            self.conversation_history.append(
+                (f"System: Loaded profile for {self.current_profile.get('name', 'unknown student')}", None)
+            )
+            return True
+        return False
+    
+    def generate_response(self, message: str, history: List[tuple]) -> str:
+        """Generate response based on message and history"""
+        # Add to conversation history
+        self.conversation_history.append((f"Student: {message}", None))
+        
+        if not self.current_profile:
+            return "Please complete and save your profile first using the previous tabs."
+        
+        # Get profile data
+        name = self.current_profile.get("name", "")
+        learning_style = self.current_profile.get("learning_style", "")
+        grade_level = self.current_profile.get("transcript", {}).get("grade_level", "unknown")
+        gpa = self.current_profile.get("transcript", {}).get("gpa", {})
+        interests = self.current_profile.get("interests", "")
+        courses = self.current_profile.get("transcript", {}).get("courses", {})
+        goals = self.current_profile.get("goals", "")
+        study_preferences = self.current_profile.get("study_preferences", "")
+        
+        # Contextual understanding
+        message_lower = message.lower()
+        
+        # Greetings
+        if any(greet in message_lower for greet in ["hi", "hello", "hey"]):
+            return f"Hello {name}! How can I help you with your learning today?"
+        
+        # Study help
+        elif any(word in message_lower for word in ["study", "learn", "prepare", "exam"]):
+            return self._generate_study_tips(learning_style, courses, study_preferences)
+        
+        # Grade help
+        elif any(word in message_lower for word in ["grade", "gpa", "score"]):
+            return self._generate_grade_info(gpa, grade_level)
+        
+        # Course help
+        elif any(word in message_lower for word in ["course", "class", "schedule", "transcript"]):
+            return self._generate_course_info(courses)
+        
+        # Goal tracking
+        elif any(word in message_lower for word in ["goal", "target", "objective"]):
+            return self._handle_goals(message, goals)
+        
+        # Resource recommendations
+        elif any(word in message_lower for word in ["resource", "material", "book", "video"]):
+            return self._recommend_resources(interests, learning_style)
+        
+        # General help
+        elif "help" in message_lower:
+            return self._generate_help_message()
+        
+        # Unknown query
+        else:
+            return ("I'm your personalized teaching assistant. I can help with:\n"
+                   "- Study strategies based on your learning style\n"
+                   "- Academic performance analysis\n"
+                   "- Course planning and recommendations\n"
+                   "- Goal setting and tracking\n\n"
+                   "Try asking about how to study for your classes or about your academic progress!")
+    
+    def _generate_study_tips(self, learning_style: str, courses: dict, study_preferences: str) -> str:
+        """Generate personalized study tips"""
+        response = "Here are personalized study recommendations:\n\n"
+        
+        # Learning style based tips
         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")
-        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")
-        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")
-        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")
+            response += ("**Visual Learner Tips:**\n"
+                       "- Create colorful mind maps\n"
+                       "- Use diagrams and charts\n"
+                       "- Watch educational videos\n"
+                       "- Highlight key information\n\n")
+        if "Auditory" in learning_style:
+            response += ("**Auditory Learner Tips:**\n"
+                       "- Record and listen to lectures\n"
+                       "- Participate in study groups\n"
+                       "- Explain concepts out loud\n"
+                       "- Use mnemonic devices\n\n")
+        if "Reading/Writing" in learning_style:
+            response += ("**Reading/Writing Learner Tips:**\n"
+                       "- Write detailed notes\n"
+                       "- Create summaries\n"
+                       "- Read additional materials\n"
+                       "- Make lists and outlines\n\n")
+        if "Kinesthetic" in learning_style:
+            response += ("**Kinesthetic Learner Tips:**\n"
+                       "- Use hands-on activities\n"
+                       "- Take movement breaks\n"
+                       "- Create physical models\n"
+                       "- Study while walking\n\n")
+        
+        # Course-specific tips
+        if courses:
+            response += "\n**Course-Specific Suggestions:**\n"
+            for grade, course_list in courses.items():
+                for course in course_list:
+                    course_name = course.get('name', '')
+                    if 'math' in course_name.lower():
+                        response += f"- For {course_name}: Practice problems daily\n"
+                    elif 'science' in course_name.lower():
+                        response += f"- For {course_name}: Focus on concepts and applications\n"
+                    elif 'history' in course_name.lower():
+                        response += f"- For {course_name}: Create timelines and context maps\n"
+                    elif 'english' in course_name.lower():
+                        response += f"- For {course_name}: Read actively and annotate texts\n"
+        
+        # Study preferences
+        if study_preferences:
+            response += f"\n**Your Study Preferences:**\n{study_preferences}\n"
+        
+        # General tips
+        response += ("\n**General Study Strategies:**\n"
+                    "- Use the Pomodoro technique (25 min study, 5 min break)\n"
+                    "- Space out your study sessions\n"
+                    "- Test yourself regularly\n"
+                    "- Teach concepts to someone else\n")
+        
+        return response
+    
+    def _generate_grade_info(self, gpa: dict, grade_level: str) -> str:
+        """Generate grade information response"""
+        response = (f"Your Academic Performance Summary:\n"
+                   f"- Current Grade Level: {grade_level}\n"
+                   f"- Unweighted GPA: {gpa.get('unweighted', 'N/A')}\n"
+                   f"- Weighted GPA: {gpa.get('weighted', 'N/A')}\n\n")
+        
+        # Add improvement suggestions
+        unweighted = float(gpa.get('unweighted', 0)) if gpa.get('unweighted', 'N/A') != 'N/A' else 0
+        if unweighted < 2.0:
+            response += ("**Recommendations for Improvement:**\n"
+                       "- Meet with teachers to identify weak areas\n"
+                       "- Establish a regular study schedule\n"
+                       "- Focus on foundational concepts\n")
+        elif unweighted < 3.0:
+            response += ("**Recommendations for Enhancement:**\n"
+                       "- Identify your strongest subjects to build confidence\n"
+                       "- Set specific grade improvement goals\n"
+                       "- Develop better study habits\n")
+        elif unweighted < 3.5:
+            response += ("**Recommendations for Advancement:**\n"
+                       "- Challenge yourself with honors/AP courses\n"
+                       "- Develop deeper understanding in your strongest areas\n"
+                       "- Focus on consistent performance\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")
+            response += ("**Recommendations for Excellence:**\n"
+                       "- Pursue advanced coursework\n"
+                       "- Develop independent research projects\n"
+                       "- Mentor other students to reinforce your knowledge\n")
         
         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")
-    
-    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")
-    
-    elif any(word in message.lower() for word in course_help):
-        response = "Here's a summary of your courses:\n"
+    def _generate_course_info(self, courses: dict) -> str:
+        """Generate course information response"""
+        if not courses:
+            return "No course information available in your profile."
+        
+        response = "Your Course History:\n"
         for grade in sorted(courses.keys(), key=int):
-            response += f"\nGrade {grade}:\n"
+            response += f"\n**Grade {grade}:**\n"
             for course in courses[grade]:
-                response += f"- {course['name']}"
+                response += f"- {course.get('name', 'Unknown')}"
                 if 'grade' in course:
-                    response += f" (Grade: {course['grade']})"
+                    response += f" (Grade: {course.get('grade', '')})"
                 response += "\n"
+        
+        # Add recommendations
+        response += "\n**Course Recommendations:**\n"
+        highest_grade = max(courses.keys(), key=int) if courses else "0"
+        
+        if highest_grade == "09":
+            response += "- Consider exploring different subjects to find your interests\n"
+            response += "- Build strong foundational skills in math and language arts\n"
+        elif highest_grade == "10":
+            response += "- Start focusing on your academic strengths\n"
+            response += "- Consider honors or AP courses in your strong subjects\n"
+        elif highest_grade == "11":
+            response += "- Focus on college preparatory courses\n"
+            response += "- Consider AP or dual enrollment courses\n"
+        elif highest_grade == "12":
+            response += "- Complete any remaining graduation requirements\n"
+            response += "- Consider advanced courses in your intended major\n"
+        
         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 _handle_goals(self, message: str, current_goals: str) -> str:
+        """Handle goal-related queries"""
+        if "set" in message.lower() or "new" in message.lower():
+            return ("To set new goals, please update your profile with your academic goals. "
+                   "You can include:\n"
+                   "- Short-term goals (weekly/monthly)\n"
+                   "- Long-term goals (semester/yearly)\n"
+                   "- Career or college preparation goals\n")
+        elif current_goals:
+            return f"Your current goals:\n{current_goals}\n\nWould you like to update them?"
+        else:
+            return ("You haven't set any goals yet. Setting clear academic goals can help you "
+                   "stay focused and motivated. Would you like to set some goals now?")
     
-    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 _recommend_resources(self, interests: str, learning_style: str) -> str:
+        """Recommend learning resources"""
+        response = "Based on your profile, here are some resource recommendations:\n\n"
+        
+        # Interest-based recommendations
+        if "science" in interests.lower():
+            response += ("**Science Resources:**\n"
+                        "- Khan Academy Science courses\n"
+                        "- Crash Course YouTube channel\n"
+                        "- Science Journal app for experiments\n\n")
+        if "math" in interests.lower():
+            response += ("**Math Resources:**\n"
+                        "- Brilliant.org interactive math\n"
+                        "- 3Blue1Brown YouTube channel\n"
+                        "- Wolfram Alpha for problem solving\n\n")
+        if "history" in interests.lower():
+            response += ("**History Resources:**\n"
+                        "- Hardcore History podcast\n"
+                        "- Timeline apps for historical events\n"
+                        "- Historical fiction books\n\n")
+        if "art" in interests.lower() or "music" in interests.lower():
+            response += ("**Arts Resources:**\n"
+                        "- Skillshare art classes\n"
+                        "- Google Arts & Culture app\n"
+                        "- Local museum virtual tours\n\n")
+        
+        # Learning style based recommendations
+        if "Visual" in learning_style:
+            response += ("**Visual Learning Resources:**\n"
+                        "- MindMeister for mind mapping\n"
+                        "- Canva for creating visual notes\n"
+                        "- YouTube educational channels\n\n")
+        if "Auditory" in learning_style:
+            response += ("**Auditory Learning Resources:**\n"
+                        "- Audible for audiobooks\n"
+                        "- Podcasts like TED Talks Education\n"
+                        "- Text-to-speech tools\n\n")
+        if "Reading/Writing" in learning_style:
+            response += ("**Reading/Writing Resources:**\n"
+                        "- Evernote for note-taking\n"
+                        "- Project Gutenberg for free books\n"
+                        "- Grammarly for writing help\n\n")
+        if "Kinesthetic" in learning_style:
+            response += ("**Kinesthetic Learning Resources:**\n"
+                        "- Labster virtual labs\n"
+                        "- DIY science experiment kits\n"
+                        "- Standing desk or exercise ball chair\n\n")
+        
+        return response
+    
+    def _generate_help_message(self) -> str:
+        """Generate help message with capabilities"""
+        return ("""I can help you with:
+1. **Study Strategies** - Get personalized study tips based on your learning style
+2. **Academic Performance** - Check your GPA and get improvement suggestions
+3. **Course Planning** - View your course history and get recommendations
+4. **Goal Setting** - Set and track your academic goals
+5. **Resource Recommendations** - Get suggested learning materials
+
+Try asking:
+- "How should I study for my math class?"
+- "What's my current GPA?"
+- "What courses should I take next year?"
+- "Can you recommend some science resources?"
+- "Help me set some academic goals"
+""")
+
+# Initialize teaching assistant
+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()
+with gr.Blocks(title="Personalized Learning Assistant", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎓 Personalized Learning Assistant")
+    gr.Markdown("This tool helps students understand their learning style, track academic progress, and get personalized study recommendations.")
+    
+    with gr.Tab("📄 Step 1: Upload Transcript"):
+        gr.Markdown("### Upload your academic transcript")
+        gr.Markdown("For best results, upload a PDF of your official transcript.")
+        with gr.Row():
+            with gr.Column():
+                transcript_file = gr.File(
+                    label="Transcript file",
+                    file_types=[".pdf"],
+                    info="PDF format recommended"
+                )
+                clear_btn = gr.Button("Clear")
+            with gr.Column():
+                transcript_output = gr.Textbox(
+                    label="Transcript Results",
+                    lines=20,
+                    interactive=False
+                )
+                transcript_data = gr.State()
+        
         transcript_file.change(
             fn=parse_transcript,
             inputs=transcript_file,
             outputs=[transcript_output, transcript_data]
         )
-
-    with gr.Tab("Step 2: Learning Style Quiz"):
-        gr.Markdown("### Learning Style Quiz (20 Questions)")
+        clear_btn.click(
+            lambda: [None, "", None],
+            outputs=[transcript_file, transcript_output, transcript_data]
+        )
+    
+    with gr.Tab("📝 Step 2: Learning Style Quiz"):
+        gr.Markdown("### Discover Your Learning Style")
+        gr.Markdown("Complete this 20-question quiz to understand how you learn best.")
+        
+        with gr.Accordion("About Learning Styles", open=False):
+            gr.Markdown("""
+            **Visual Learners** prefer using images, diagrams, and spatial understanding.  
+            **Auditory Learners** learn best through listening and speaking.  
+            **Reading/Writing Learners** prefer information displayed as words.  
+            **Kinesthetic Learners** learn through movement and hands-on activities.
+            """)
+        
         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}"))
+        with gr.Column():
+            for i, (question, options) in enumerate(zip(learning_style_questions, learning_style_options)):
+                quiz_components.append(
+                    gr.Radio(
+                        options,
+                        label=f"{i+1}. {question}",
+                        interactive=True
+                    )
+                )
+        
+        with gr.Row():
+            submit_quiz = gr.Button("Submit Quiz", variant="primary")
+            reset_quiz = gr.Button("Reset Quiz")
+        
+        learning_output = gr.Textbox(
+            label="Your Learning Style Results",
+            lines=15,
+            interactive=False
+        )
         
-        learning_output = gr.Textbox(label="Your Learning Style", lines=15)
-        gr.Button("Submit Quiz").click(
+        submit_quiz.click(
             fn=learning_style_quiz,
             inputs=quiz_components,
             outputs=learning_output
         )
-
-    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"):
+        reset_quiz.click(
+            lambda: [None]*len(quiz_components),
+            outputs=quiz_components
+        )
+    
+    with gr.Tab("👤 Step 3: Personal Profile"):
+        gr.Markdown("### Create Your Personal Profile")
+        gr.Markdown("This information helps personalize your learning experience.")
+        
+        with gr.Row():
+            with gr.Column():
+                name = gr.Textbox(label="Full Name", placeholder="Enter your name")
+                age = gr.Number(label="Age", precision=0, minimum=10, maximum=25)
+                interests = gr.Textbox(
+                    label="Interests/Hobbies",
+                    placeholder="e.g., Science, Music, Sports"
+                )
+                goals = gr.Textbox(
+                    label="Academic Goals",
+                    placeholder="What do you want to achieve?",
+                    lines=3
+                )
+                study_preferences = gr.Textbox(
+                    label="Study Preferences",
+                    placeholder="When/where/how do you prefer to study?",
+                    lines=3
+                )
+            
+            with gr.Column():
+                gr.Markdown("#### Favorites")
+                movie = gr.Textbox(label="Favorite Movie")
+                movie_reason = gr.Textbox(label="Why do you like it?")
+                show = gr.Textbox(label="Favorite TV Show")
+                show_reason = gr.Textbox(label="Why do you like it?")
+                book = gr.Textbox(label="Favorite Book")
+                book_reason = gr.Textbox(label="Why do you like it?")
+                character = gr.Textbox(label="Favorite Character (book/movie/show)")
+                character_reason = gr.Textbox(label="Why do you like them?")
+        
+        with gr.Row():
+            blog_checkbox = gr.Checkbox(label="Include a personal blog/journal entry?", value=False)
+            blog_text = gr.Textbox(
+                label="Your Blog/Journal",
+                visible=False,
+                lines=5,
+                placeholder="Write about your learning experiences, challenges, or thoughts..."
+            )
+        
+        blog_checkbox.change(
+            lambda x: gr.update(visible=x),
+            inputs=blog_checkbox,
+            outputs=blog_text
+        )
+    
+    with gr.Tab("💾 Step 4: Save & Review"):
+        gr.Markdown("### Review and Save Your Profile")
+        
+        with gr.Row():
+            profile_selector = gr.Dropdown(
+                label="Select Profile to Load",
+                choices=get_profile_list(),
+                interactive=True,
+                allow_custom_value=False
+            )
+            refresh_profiles = gr.Button("🔄 Refresh List")
+        
+        with gr.Row():
+            save_btn = gr.Button("💾 Save Profile", variant="primary")
+            load_btn = gr.Button("📂 Load Profile")
+            clear_btn = gr.Button("🧹 Clear Form")
+        
         output_summary = gr.Markdown()
-        save_btn = gr.Button("Save Profile")
+        
+        # Profile management functions
+        refresh_profiles.click(
+            lambda: gr.update(choices=get_profile_list()),
+            outputs=profile_selector
+        )
+        
         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],
+            inputs=[
+                name, age, interests, transcript_data, learning_output,
+                movie, movie_reason, show, show_reason,
+                book, book_reason, character, character_reason,
+                blog_text, goals, study_preferences
+            ],
             outputs=output_summary
+        ).then(
+            lambda: gr.update(choices=get_profile_list()),
+            outputs=profile_selector
         )
-
+        
+        load_btn.click(
+            fn=lambda name: generate_profile_summary(load_profile(name)),
+            inputs=profile_selector,
+            outputs=output_summary
+        )
+        
+        clear_btn.click(
+            lambda: [""]*15 + [None, False, ""],
+            outputs=[
+                name, age, interests, goals, study_preferences,
+                movie, movie_reason, show, show_reason,
+                book, book_reason, character, character_reason,
+                blog_text, blog_checkbox, output_summary
+            ]
+        )
+    
     with gr.Tab("🤖 AI Teaching Assistant"):
         gr.Markdown("## Your Personalized Learning Assistant")
+        gr.Markdown("Chat with your AI assistant to get personalized learning advice based on your profile.")
+        
+        # Profile selection for assistant
+        with gr.Row():
+            assistant_profile_selector = gr.Dropdown(
+                label="Select Your Profile",
+                choices=get_profile_list(),
+                interactive=True
+            )
+            load_assistant_profile = gr.Button("Load Profile")
+            refresh_assistant_profiles = gr.Button("🔄 Refresh")
+        
+        # Chat interface
         chatbot = gr.ChatInterface(
-            fn=generate_response,
+            fn=assistant.generate_response,
             examples=[
-                "How should I study for my next test?",
-                "What's my GPA information?",
+                "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?"
-            ]
+                "Recommend some science resources",
+                "Help me set academic goals"
+            ],
+            title="Chat with Your Teaching Assistant",
+            retry_btn=None,
+            undo_btn=None,
+            clear_btn="Clear Chat"
+        )
+        
+        # Profile management for assistant
+        load_assistant_profile.click(
+            fn=lambda name: assistant.load_profile(name) or f"Loaded profile for {name}",
+            inputs=assistant_profile_selector,
+            outputs=chatbot.chatbot
+        )
+        
+        refresh_assistant_profiles.click(
+            lambda: gr.update(choices=get_profile_list()),
+            outputs=assistant_profile_selector
         )
 
 if __name__ == "__main__":