app.py

# ========== DEPENDENCY MANAGEMENT ==========
import sys
import subprocess
import importlib

# List of required packages
required_packages = {
    'gradio': 'gradio>=3.0',
    'pandas': 'pandas',
    'PyPDF2': 'PyPDF2',
    'transformers': 'transformers',
    'pdfplumber': 'pdfplumber',
    'typing_extensions': 'typing_extensions'
}

def check_and_install_packages():
    missing_packages = []
    for import_name, pkg_name in required_packages.items():
        try:
            importlib.import_module(import_name)
        except ImportError:
            missing_packages.append(pkg_name)

    if missing_packages:
        print(f"Missing packages: {', '.join(missing_packages)}")
        print("Attempting to install...")
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", *missing_packages])
            print("Installation successful.")
        except subprocess.CalledProcessError as e:
            print(f"Failed to install packages. Error: {e}")

check_and_install_packages()

# ========== MAIN IMPORTS ==========
import gradio as gr
import pandas as pd
import json
import os
import re
from PyPDF2 import PdfReader
from collections import defaultdict
from transformers import pipeline
from typing import List, Dict, Union
import pdfplumber

# ========== TRANSCRIPT PARSING ==========
class UniversalTranscriptParser:
    def __init__(self):
        self.patterns = {
            'miami_dade': self._compile_miami_dade_patterns(),
            'homeschool': self._compile_homeschool_patterns(),
            'doral_academy': self._compile_doral_academy_patterns()
        }
        
        self.grade_level_map = {
            '09': '9th Grade', '10': '10th Grade', '11': '11th Grade', '12': '12th Grade',
            '07': '7th Grade', '08': '8th Grade', 'MA': 'Middle School'
        }
    
    def parse_transcript(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
        transcript_type = self._identify_transcript_type(text)
        
        if transcript_type == 'homeschool':
            return self._parse_homeschool(text)
        elif transcript_type == 'doral_academy':
            return self._parse_doral_academy(text)
        else:
            return self._parse_miami_dade(text)
    
    def _identify_transcript_type(self, text: str) -> str:
        if re.search(r'Sample OFFICIAL HIGH SCHOOL TRANSCRIPT', text):
            return 'homeschool'
        elif re.search(r'DORAL ACADEMY HIGH SCHOOL', text):
            return 'doral_academy'
        return 'miami_dade'
    
    def _parse_homeschool(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
        courses = []
        current_grade = None
        current_year = None
        
        student_info = {}
        name_match = re.search(r'Student Name:\s*(.+)\s*SSN:', text)
        if name_match:
            student_info['name'] = name_match.group(1).strip()
        
        for line in text.split('\n'):
            grade_match = re.match(r'^\|?\s*(\d+th Grade)\s*\|.*(\d{4}-\d{4})', line)
            if grade_match:
                current_grade = grade_match.group(1)
                current_year = grade_match.group(2)
                continue
            
            course_match = re.match(
                r'^\|?\s*([^\|]+?)\s*\|\s*([A-Z][+*]?)\s*\|\s*([^\|]+)\s*\|\s*(\d+\.?\d*)\s*\|\s*(\d+)',
                line
            )
            
            if course_match and current_grade:
                course_name = course_match.group(1).strip()
                course_name = re.sub(r'^\|?\s*', '', course_name)
                
                courses.append({
                    'name': course_name,
                    'grade_level': current_grade,
                    'school_year': current_year,
                    'grade': course_match.group(2),
                    'credit_type': course_match.group(3).strip(),
                    'credits': float(course_match.group(4)),
                    'quality_points': int(course_match.group(5)),
                    'transcript_type': 'homeschool'
                })
        
        gpa_data = {}
        gpa_match = re.search(r'Cum\. GPA\s*\|\s*([\d\.]+)', text)
        if gpa_match:
            gpa_data['unweighted'] = gpa_match.group(1)
            gpa_data['weighted'] = gpa_match.group(1)
        
        return {
            'student_info': student_info,
            'courses': {'All': courses},
            'gpa': gpa_data,
            'grade_level': current_grade.replace('th Grade', '') if current_grade else "Unknown"
        }
    
    def _parse_doral_academy(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
        courses = []
        student_info = {}
        name_match = re.search(r'LEGAL NAME:\s*([^\n]+)', text)
        if name_match:
            student_info['name'] = name_match.group(1).strip()
        
        year_pattern = re.compile(r'YEAR:\s*(\d{4}-\d{4})\s*GRADE LEVEL:\s*(\d{2})', re.MULTILINE)
        year_matches = year_pattern.finditer(text)
        
        grade_year_map = {}
        for match in year_matches:
            grade_year_map[match.group(2)] = match.group(1)
        
        course_pattern = re.compile(
            r'(\d)\s+(\d{7})\s+([^\n]+?)\s+([A-Z]{2})\s+([A-Z])\s+([A-Z])\s+([A-Z])\s+(\d\.\d{2})\s+(\d\.\d{2})',
            re.MULTILINE
        )
        
        courses_by_grade = defaultdict(list)
        for match in course_pattern.finditer(text):
            grade_level_num = match.group(1)
            grade_level = self.grade_level_map.get(grade_level_num, f"Grade {grade_level_num}")
            school_year = grade_year_map.get(grade_level_num, "Unknown")
            
            course_info = {
                'course_code': match.group(2),
                'name': match.group(3).strip(),
                'subject_area': match.group(4),
                'grade': match.group(5),
                'inclusion_status': match.group(6),
                'credit_status': match.group(7),
                'credits_attempted': float(match.group(8)),
                'credits': float(match.group(9)),
                'grade_level': grade_level,
                'school_year': school_year,
                'transcript_type': 'doral_academy'
            }
            
            courses_by_grade[grade_level_num].append(course_info)
        
        gpa_data = {}
        unweighted_match = re.search(r'Un-weighted GPA\s*([\d\.]+)', text)
        weighted_match = re.search(r'Weighted GPA\s*([\d\.]+)', text)
        
        if unweighted_match:
            gpa_data['unweighted'] = unweighted_match.group(1)
        if weighted_match:
            gpa_data['weighted'] = weighted_match.group(1)
        
        grade_level = "12" if re.search(r'GRADE LEVEL:\s*12', text) else "Unknown"
        
        return {
            'student_info': student_info,
            'courses': dict(courses_by_grade),
            'gpa': gpa_data,
            'grade_level': grade_level
        }
    
    def _parse_miami_dade(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
        courses = []
        courses_by_grade = defaultdict(list)
        
        student_info = {}
        name_match = re.search(r'0783977 - ([^,]+),\s*([^\n]+)', text)
        if name_match:
            student_info['name'] = f"{name_match.group(2)} {name_match.group(1)}"
        
        course_pattern = re.compile(
            r'([A-Z]-[A-Za-z\s&]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([A-Z]?)\s*\|\s*([A-Z]?)\s*\|\s*([^\|]+)',
            re.MULTILINE
        )
        
        for match in course_pattern.finditer(text):
            grade_level = self.grade_level_map.get(match.group(3), match.group(3))
            credits = match.group(10).strip()
            
            course_info = {
                'requirement_category': match.group(1).strip(),
                'school_year': match.group(2),
                'grade_level': grade_level if isinstance(grade_level, str) else f"Grade {match.group(3)}",
                'course_code': match.group(4).strip(),
                'name': match.group(5).strip(),
                'term': match.group(6).strip(),
                'district_number': match.group(7).strip(),
                'grade': match.group(8),
                'inclusion_status': match.group(9),
                'credits': 0.0 if 'inProgress' in credits else float(credits.replace(' ', '')),
                'transcript_type': 'miami_dade'
            }
            
            courses_by_grade[match.group(3)].append(course_info)
        
        gpa_data = {
            'weighted': extract_gpa(text, 'Weighted GPA'),
            'unweighted': extract_gpa(text, 'Un-weighted GPA')
        }
        
        grade_level = re.search(r'Current Grade:\s*(\d+)', text).group(1) if re.search(r'Current Grade:\s*(\d+)', text) else "Unknown"
        
        return {
            'student_info': student_info,
            'courses': dict(courses_by_grade),
            'gpa': gpa_data,
            'grade_level': grade_level
        }

    def _compile_miami_dade_patterns(self):
        return {
            'student': re.compile(r'Current Grade:\s*(\d+).*YOG\s*(\d{4})'),
            'course': re.compile(
                r'([A-Z]-[A-Za-z\s&]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([A-Z]?)\s*\|\s*([A-Z]?)\s*\|\s*([^\|]+)',
                re.MULTILINE
            )
        }

    def _compile_homeschool_patterns(self):
        return {
            'student': re.compile(r'Student Name:\s*(.+)\s*SSN:'),
            'course': re.compile(
                r'^\|?\s*([^\|]+?)\s*\|\s*([A-Z][+*]?)\s*\|\s*([^\|]+)\s*\|\s*(\d+\.?\d*)\s*\|\s*(\d+)'
            )
        }

    def _compile_doral_academy_patterns(self):
        return {
            'student': re.compile(r'LEGAL NAME:\s*([^\n]+)'),
            'course': re.compile(
                r'(\d)\s+(\d{7})\s+([^\n]+?)\s+([A-Z]{2})\s+([A-Z])\s+([A-Z])\s+([A-Z])\s+(\d\.\d{2})\s+(\d\.\d{2})',
                re.MULTILINE
            )
        }

def extract_gpa(text, gpa_type):
    pattern = rf'{gpa_type}\s*([\d\.]+)'
    match = re.search(pattern, text)
    return match.group(1) if match else "N/A"

def parse_transcript(file):
    parser = UniversalTranscriptParser()
    
    if file.name.endswith('.pdf'):
        text = ''
        with pdfplumber.open(file.name) as pdf:
            for page in pdf.pages:
                text += page.extract_text() or '' + '\n'
        
        parsed_data = parser.parse_transcript(text)
        
        output_text = f"Student Transcript Summary\n{'='*40}\n"
        
        if 'student_info' in parsed_data and 'name' in parsed_data['student_info']:
            output_text += f"Student: {parsed_data['student_info']['name']}\n"
        
        output_text += f"Current Grade Level: {parsed_data.get('grade_level', 'Unknown')}\n"
        
        if 'gpa' in parsed_data:
            gpa = parsed_data['gpa']
            output_text += f"Weighted GPA: {gpa.get('weighted', 'N/A')}\n"
            output_text += f"Unweighted GPA: {gpa.get('unweighted', 'N/A')}\n\n"
        
        output_text += "Course History:\n{'='*40}\n"
        
        if 'courses' in parsed_data:
            courses_by_grade = parsed_data['courses']
            
            def grade_sort_key(grade):
                try:
                    num = int(re.search(r'\d+', grade).group())
                    return num
                except (AttributeError, ValueError):
                    return float('inf')
            
            grades_sorted = sorted(courses_by_grade.keys(), key=grade_sort_key)
            
            for grade in grades_sorted:
                output_text += f"\nGrade {grade}:\n{'-'*30}\n"
                for course in courses_by_grade[grade]:
                    output_text += f"- {course.get('name', 'Unnamed Course')}"
                    if 'grade' in course and course['grade']:
                        output_text += f" (Grade: {course['grade']})"
                    if 'credits' in course:
                        output_text += f" | Credits: {course['credits']}"
                    if 'school_year' in course:
                        output_text += f" | Year: {course['school_year']}"
                    output_text += "\n"
        
        return output_text, parsed_data
    else:
        return "Unsupported file format (PDF only for transcript parsing)", None

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):
        def grade_sort_key(grade):
            try:
                num = int(re.search(r'\d+', grade).group())
                return num
            except (AttributeError, ValueError):
                return float('inf')
        
        grades_sorted = sorted(courses_by_grade.keys(), key=grade_sort_key)
        
        for grade in grades_sorted:
            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']}"
                if 'school_year' in course:
                    display += f" | Year: {course['school_year']}"
                display += "\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"
    
    return display

# ========== 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 mind (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]
    
    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"
        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

# ========== 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):
    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 = {
        "name": name,
        "age": age,
        "interests": interests,
        "transcript": transcript,
        "learning_style": learning_style,
        "favorites": favorites,
        "blog": blog
    }
    
    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)

    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

# ========== 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()
    if not profile:
        return "Please complete and save your profile first using the previous tabs."
    
    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", {})
    
    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):
        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")
        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")
        
        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"
        if isinstance(courses, dict):
            def grade_sort_key(grade):
                try:
                    num = int(re.search(r'\d+', grade).group())
                    return num
                except (AttributeError, ValueError):
                    return float('inf')
            
            grades_sorted = sorted(courses.keys(), key=grade_sort_key)
            
            for grade in grades_sorted:
                response += f"\nGrade {grade}:\n"
                for course in courses[grade]:
                    response += f"- {course.get('name', 'Unnamed Course')}"
                    if 'grade' in course:
                        response += f" (Grade: {course['grade']})"
                    response += "\n"
        else:
            response += "No detailed course information available."
        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!")
    
    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!")

# ========== GRADIO INTERFACE ==========
with gr.Blocks() as app:
    with gr.Tab("Step 1: Upload Transcript"):
        gr.Markdown("### Upload your transcript (PDF recommended)")
        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]
        )

    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
        )

    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
        )

    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?"
            ]
        )

# ========== RUN APPLICATION ==========
if __name__ == "__main__":
    app.launch()