app.py

import pandas as pd
import numpy as np
import json
from typing import Dict, List, Optional, Union, Any
import os
import requests
from dotenv import load_dotenv
from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich.tree import Tree
from rich import box
import time
from tqdm import tqdm
import openai
import gradio as gr
from huggingface_hub import HfApi, HfFolder

# Load environment variables from .env file
load_dotenv()

class BaseRecommender:
    def __init__(self):
        self.console = Console()
        
        # Initialize OpenAI client
        api_key = os.getenv("OPENAI_API_KEY")
        self.ai_enabled = bool(api_key)
        if self.ai_enabled:
            self.openai_client = openai.OpenAI(api_key=api_key)
        else:
            self.console.print("[yellow]Warning: OpenAI API key not found. AI-enhanced features will be disabled.[/yellow]")

class CourseRecommender(BaseRecommender):
    def __init__(self, dataframe: pd.DataFrame):
        """
        Initialize the course recommender with course data
        """
        super().__init__()
        self.courses = dataframe.drop(columns=['Unnamed: 1', 'Unnamed: 5'], errors='ignore')
        self._preprocess_data()

    def _preprocess_data(self):
        """
        Preprocess the course data for better recommendations
        """
        # Convert text columns to lowercase
        text_columns = ['Course Name', 'Description', 'Skills', 'Difficulty Level']
        for col in text_columns:
            if col in self.courses.columns:
                self.courses[col] = self.courses[col].astype(str).str.lower()

        # Handle numeric values
        self.courses['Course Rating'] = pd.to_numeric(self.courses['Course Rating'], errors='coerce').fillna(0)
        self.courses['keyword_match_score'] = 0

        # Add course ID for easy reference
        self.courses['Course ID'] = range(1, len(self.courses) + 1)

    def recommend_courses(self, topic: Optional[str] = None, skill_level: Optional[str] = None,
                          top_n: int = 5, personalized: bool = False, user_goals: Optional[str] = None) -> pd.DataFrame:
        """
        Recommend courses based on topic, skill level, and optional user goals
        """
        filtered_courses = self.courses.copy()

        # Show processing indicator
        with self.console.status("[bold green]Finding the best courses for you...", spinner="dots"):
            time.sleep(1)  # Simulate processing time

            # Filter by topic if provided
            if topic:
                topic = topic.lower()
                # Calculate keyword match score
                filtered_courses['keyword_match_score'] = (
                    filtered_courses['Course Name'].str.contains(topic).astype(int) * 3 +
                    filtered_courses['Description'].str.contains(topic).astype(int) * 2 +
                    filtered_courses['Skills'].str.contains(topic).astype(int)
                )
                filtered_courses = filtered_courses[filtered_courses['keyword_match_score'] > 0]

            # Filter by skill level if provided
            if skill_level:
                skill_level = skill_level.lower()
                difficulty_map = {
                    'beginner': ['beginner', 'intro', 'basic', 'level 1', 'fundamentals'],
                    'intermediate': ['intermediate', 'mid-level', 'level 2', 'advanced beginner'],
                    'advanced': ['advanced', 'expert', 'professional', 'level 3', 'master']
                }
                filtered_courses = filtered_courses[
                    filtered_courses['Difficulty Level'].apply(
                        lambda x: any(diff in str(x) for diff in difficulty_map.get(skill_level, [skill_level]))
                    )
                ]

            # Add AI relevance scoring if enabled
            filtered_courses['ai_relevance_score'] = 0
            if personalized and user_goals and self.ai_enabled:
                for idx, course in filtered_courses.iterrows():
                    relevance_score = self._get_ai_relevance_score(course, topic, user_goals)
                    filtered_courses.at[idx, 'ai_relevance_score'] = relevance_score

            # Calculate final recommendation score
            if not filtered_courses.empty:
                filtered_courses['recommendation_score'] = (
                    filtered_courses['Course Rating'] * 0.4 +
                    filtered_courses['keyword_match_score'] * 0.3 +
                    filtered_courses['ai_relevance_score'] * 0.2 +
                    np.random.rand(len(filtered_courses)) * 0.1
                )
                filtered_courses = filtered_courses.sort_values('recommendation_score', ascending=False)

        return filtered_courses.head(top_n)

    def _get_ai_relevance_score(self, course: pd.Series, topic: str, user_goals: str) -> float:
        """
        Use AI to determine how relevant a course is to user's specific goals
        """
        if not self.ai_enabled:
            return 0.5
            
        try:
            prompt = f"""
            Rate how relevant this course is to a learner with these goals on a scale of 0-10:

            Topic of interest: {topic}
            User's learning goals: {user_goals}

            Course details:
            - Name: {course['Course Name']}
            - Description: {course['Description']}
            - Skills taught: {course['Skills']}
            - Difficulty: {course['Difficulty Level']}

            Return only a number from 0-10.
            """

            response = self.openai_client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": "You are an educational advisor helping match courses to learner goals."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=10,
                temperature=0.3
            )

            try:
                score = float(response.choices[0].message.content.strip())
                return min(max(score, 0), 10) / 10  # Normalize to 0-1 range
            except ValueError:
                return 0.5  # Default value if parsing fails

        except Exception as e:
            self.console.print(f"[red]Error getting AI relevance score: {e}[/red]")
            return 0.5

    def generate_roadmap(self, topic: str, skill_level: Optional[str] = None,
                         user_goals: Optional[str] = None, detailed: bool = False) -> Dict:
        """
        Generate a personalized learning roadmap based on the topic and user goals
        """
        self.console.print(Panel(f"[bold cyan]Generating your personalized learning roadmap for [green]{topic}[/green]...[/bold cyan]"))

        # Display a progress bar for visual effect
        for _ in tqdm(range(5), desc="Processing roadmap data"):
            time.sleep(0.3)

        # Generate roadmap using AI if enabled and requested, otherwise use default
        if detailed and self.ai_enabled and user_goals:
            return self._generate_ai_roadmap(topic, skill_level, user_goals)
        else:
            return self._generate_default_roadmap(topic)

    def _generate_ai_roadmap(self, topic: str, skill_level: str, user_goals: str) -> Dict:
        """
        Use AI to generate a personalized and detailed learning roadmap
        """
        try:
            # Enhanced prompt with specific structure and guidance
            prompt = f"""
            Create a comprehensive learning roadmap for someone wanting to master {topic}.

            Learner information:
            - Current skill level: {skill_level}
            - Learning goals: {user_goals}

            The roadmap should be detailed, actionable, and specifically tailored to the learner's
            skill level and goals. Provide a clear progression path that breaks down the journey 
            into logical stages with specific concepts to learn at each stage.

            Format the response as a JSON object with exactly this structure:
            {{
                "learningPath": [
                    {{
                        "step": "Step name (be specific)",
                        "difficulty": "Beginner/Intermediate/Advanced",
                        "description": "Detailed description of this learning stage (2-3 sentences)",
                        "time_estimate": "Estimated completion time (weeks/months)",
                        "key_concepts": ["Specific concept 1", "Specific concept 2", "Specific concept 3"],
                        "milestones": ["Practical milestone 1", "Practical milestone 2"],
                        "practice_activities": ["Activity 1", "Activity 2"]
                    }},
                    // 3-5 steps total, progressing from fundamentals to mastery
                ],
                "projectSuggestions": [
                    {{
                        "name": "Project name (be specific to {topic})",
                        "description": "Detailed project description (2-3 sentences)",
                        "complexity": "Low/Medium/High",
                        "skills_practiced": ["Skill 1", "Skill 2", "Skill 3"],
                        "resources": ["Specific resource 1", "Specific resource 2"],
                        "estimated_time": "Project completion time estimate"
                    }},
                    // 3-4 projects of increasing complexity
                ],
                "resources": {{
                    "books": ["Specific book title 1", "Specific book title 2", "Specific book title 3"],
                    "online_courses": ["Specific course 1", "Specific course 2"],
                    "communities": ["Specific community 1", "Specific community 2"],
                    "tools": ["Specific tool 1", "Specific tool 2", "Specific tool 3"],
                    "practice_platforms": ["Specific platform 1", "Specific platform 2"]
                }},
                "career_insights": [
                    "Specific insight about {topic} career opportunities",
                    "Skill demand information",
                    "Industry application of {topic} skills"
                ]
            }}

            Ensure all content is specific to {topic} (not generic) and appropriate for a {skill_level} 
            with these goals: {user_goals}. Focus on practical, actionable advice.
            """

            response = self.openai_client.chat.completions.create(
                model="gpt-4o",  # Using more capable model for better roadmaps
                messages=[
                    {"role": "system", "content": "You are an expert educational curriculum designer with deep knowledge across technical and non-technical subjects. You create detailed, actionable learning plans that are practical and tailored to individual needs."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=2500,
                temperature=0.5,
                response_format={"type": "json_object"}  # Enforce JSON response
            )

            try:
                roadmap_text = response.choices[0].message.content
                return json.loads(roadmap_text)
            except json.JSONDecodeError as e:
                self.console.print(f"[yellow]Warning: Could not parse AI response as JSON: {e}. Using default roadmap.[/yellow]")
                return self._generate_default_roadmap(topic)

        except Exception as e:
            self.console.print(f"[red]Error generating AI roadmap: {e}[/red]")
            return self._generate_default_roadmap(topic)

    def _generate_default_roadmap(self, topic: str) -> Dict:
        """
        Generate a default roadmap when AI generation fails or is not available
        """
        return {
            "learningPath": [
                {
                    "step": f"Foundations of {topic}",
                    "difficulty": "Beginner",
                    "description": f"Build core knowledge and fundamental skills in {topic}. Focus on understanding basic principles and becoming familiar with essential tools.",
                    "time_estimate": "4-6 weeks",
                    "key_concepts": [f"{topic} basics", "Core principles", "Fundamental tools and techniques"],
                    "milestones": [f"Complete first {topic} exercise", f"Build simple {topic} project"],
                    "practice_activities": [f"Daily {topic} exercises", "Follow beginner tutorials"]
                },
                {
                    "step": f"{topic} Skill Development",
                    "difficulty": "Intermediate",
                    "description": f"Deepen understanding of {topic} and apply more advanced concepts. Focus on building practical skills through hands-on projects and implementation.",
                    "time_estimate": "8-12 weeks",
                    "key_concepts": [f"Advanced {topic} techniques", "Applied projects", "Specialized tools"],
                    "milestones": [f"Complete medium complexity {topic} project", "Solve real-world problems"],
                    "practice_activities": ["Implement sample projects", "Participate in forums/discussions"]
                },
                {
                    "step": f"{topic} Mastery & Specialization",
                    "difficulty": "Advanced",
                    "description": f"Develop expert-level skills in {topic} with focus on real-world application. Specialize in specific areas and build a professional portfolio.",
                    "time_estimate": "12-16 weeks",
                    "key_concepts": ["Industry best practices", "Complex problem-solving", "Portfolio development"],
                    "milestones": ["Create capstone project", "Contribute to community"],
                    "practice_activities": ["Build complex projects", "Mentor beginners"]
                }
            ],
            "projectSuggestions": [
                {
                    "name": f"Beginner Project: {topic} Fundamentals Application",
                    "description": f"Apply basic {topic} concepts in a simple project to practice fundamentals and gain confidence.",
                    "complexity": "Low",
                    "skills_practiced": [f"Basic {topic} principles", "Problem-solving", "Tool familiarity"],
                    "resources": ["Online tutorials", "Documentation", "Starter templates"],
                    "estimated_time": "1-2 weeks"
                },
                {
                    "name": f"Intermediate Project: Interactive {topic} Application",
                    "description": f"Create a more complex application using intermediate {topic} skills with greater functionality and sophistication.",
                    "complexity": "Medium",
                    "skills_practiced": [f"Intermediate {topic} techniques", "Code organization", "Testing"],
                    "resources": ["GitHub repositories", "Online coding platforms", "Community forums"],
                    "estimated_time": "3-4 weeks"
                },
                {
                    "name": f"Capstone Project: Advanced {topic} Implementation",
                    "description": f"Apply all learned skills in a comprehensive {topic} project that showcases mastery and solves a real-world problem.",
                    "complexity": "High",
                    "skills_practiced": [f"Advanced {topic} mastery", "System design", "Optimization"],
                    "resources": ["Industry case studies", "Research papers", "Expert communities"],
                    "estimated_time": "6-8 weeks"
                }
            ],
            "resources": {
                "books": [f"Introduction to {topic}", f"Advanced {topic} Techniques", f"Mastering {topic}"],
                "online_courses": [f"{topic} for Beginners", f"Professional {topic} Masterclass"],
                "communities": ["Stack Overflow", "Reddit", f"{topic} Discord Servers"],
                "tools": [f"{topic} Development Environment", "Version Control", "Testing Frameworks"],
                "practice_platforms": ["Codecademy", "Exercism", "LeetCode"]
            },
            "career_insights": [
                f"Proficiency in {topic} is valuable for roles in software development, data science, and IT operations",
                f"Entry-level {topic} positions typically require demonstrated project experience",
                f"{topic} specialists can pursue careers in consulting, education, or product development"
            ]
        }

    def get_course_details(self, course: pd.Series) -> Dict[str, str]:
        """
        Get detailed course information
        """
        return {
            "name": course.get('Course Name', 'N/A'),
            "difficulty": course.get('Difficulty Level', 'N/A'),
            "rating": str(course.get('Course Rating', 'N/A')),
            "url": course.get('Course URL', '#'),
            "skills": course.get('Skills', 'N/A'),
            "description": course.get('Description', 'No description available'),
            "id": str(course.get('Course ID', '0'))
        }

    def display_roadmap(self, roadmap: Dict):
        """
        Display the learning roadmap in a beautiful format using rich
        """
        self.console.print("\n")
        self.console.print(Panel("[bold cyan]YOUR PERSONALIZED LEARNING JOURNEY[/bold cyan]",
                               box=box.DOUBLE, expand=False))

        # Create a tree for learning path
        learning_tree = Tree("[bold yellow]Learning Path[/bold yellow]")
        for stage in roadmap["learningPath"]:
            stage_node = learning_tree.add(f"[bold green]{stage['step']}[/bold green] ({stage['difficulty']}) - {stage['time_estimate']}")
            stage_node.add(f"[italic]{stage['description']}[/italic]")

            concepts_node = stage_node.add("[bold blue]Key Concepts:[/bold blue]")
            for concept in stage.get("key_concepts", []):
                concepts_node.add(concept)

            if "milestones" in stage:
                milestones_node = stage_node.add("[bold magenta]Milestones:[/bold magenta]")
                for milestone in stage["milestones"]:
                    milestones_node.add(milestone)
                    
            if "practice_activities" in stage:
                activities_node = stage_node.add("[bold cyan]Practice Activities:[/bold cyan]")
                for activity in stage["practice_activities"]:
                    activities_node.add(activity)

        self.console.print(learning_tree)
        self.console.print("\n")

        # Project suggestions table
        project_table = Table(title="Recommended Projects", box=box.ROUNDED)
        project_table.add_column("Project Name", style="cyan", no_wrap=True)
        project_table.add_column("Description", style="white")
        project_table.add_column("Complexity", style="magenta")
        project_table.add_column("Est. Time", style="yellow")

        for project in roadmap["projectSuggestions"]:
            project_table.add_row(
                project["name"],
                project["description"],
                project["complexity"],
                project.get("estimated_time", "N/A")
            )

        self.console.print(project_table)
        self.console.print("\n")

        # Resources panel
        resources = roadmap.get("resources", {})
        resources_text = ""

        resource_categories = {
            "books": "Recommended Books",
            "online_courses": "Online Courses",
            "communities": "Communities",
            "tools": "Essential Tools",
            "practice_platforms": "Practice Platforms"
        }
        
        for category, title in resource_categories.items():
            if category in resources and resources[category]:
                resources_text += f"[bold yellow]{title}:[/bold yellow]\n"
                for item in resources[category]:
                    resources_text += f"• {item}\n"
                resources_text += "\n"

        self.console.print(Panel(resources_text, title="[bold cyan]Learning Resources[/bold cyan]",
                               box=box.ROUNDED, expand=False))
                               
        # Career insights
        if "career_insights" in roadmap and roadmap["career_insights"]:
            career_text = "[bold yellow]Career Insights:[/bold yellow]\n"
            for insight in roadmap["career_insights"]:
                career_text += f"• {insight}\n"
                
            self.console.print(Panel(career_text, title="[bold cyan]Career Opportunities[/bold cyan]",
                               box=box.ROUNDED, expand=False))

    def display_recommended_courses(self, courses: pd.DataFrame):
        """
        Display recommended courses in a beautiful format
        """
        if courses.empty:
            self.console.print("[yellow]No courses match your criteria. Try broader search terms.[/yellow]")
            return

        table = Table(title="Recommended Courses", box=box.ROUNDED)
        table.add_column("ID", style="dim")
        table.add_column("Course Name", style="cyan")
        table.add_column("Rating", style="yellow")
        table.add_column("Difficulty", style="green")

        for _, course in courses.iterrows():
            table.add_row(
                str(course.get('Course ID', 'N/A')),
                course.get('Course Name', 'N/A').title(),
                f"{course.get('Course Rating', 0):.1f} ★",
                course.get('Difficulty Level', 'N/A').title()
            )

        self.console.print(table)
        self.console.print("\n[dim]Use the course ID to get more details about a specific course.[/dim]")
        
    def roadmap_to_markdown(self, roadmap: Dict, topic: str, skill_level: str) -> str:
        """
        Convert a roadmap to markdown format for export or display
        """
        markdown = f"# Personalized Learning Roadmap: {topic.title()}\n\n"
        markdown += f"*Skill Level: {skill_level.title()}*\n\n"
        
        # Learning Path
        markdown += "## Learning Path\n\n"
        for i, stage in enumerate(roadmap["learningPath"]):
            markdown += f"### {i+1}. {stage['step']} ({stage['difficulty']}) - {stage['time_estimate']}\n\n"
            markdown += f"{stage['description']}\n\n"
            
            markdown += "**Key Concepts:**\n"
            for concept in stage.get("key_concepts", []):
                markdown += f"- {concept}\n"
            markdown += "\n"
            
            if "milestones" in stage:
                markdown += "**Milestones:**\n"
                for milestone in stage["milestones"]:
                    markdown += f"- {milestone}\n"
                markdown += "\n"
                
            if "practice_activities" in stage:
                markdown += "**Practice Activities:**\n"
                for activity in stage["practice_activities"]:
                    markdown += f"- {activity}\n"
                markdown += "\n"
        
        # Project Suggestions
        markdown += "## Recommended Projects\n\n"
        for i, project in enumerate(roadmap["projectSuggestions"]):
            markdown += f"### {i+1}. {project['name']} ({project['complexity']})\n\n"
            markdown += f"{project['description']}\n\n"
            
            if "skills_practiced" in project:
                markdown += "**Skills Practiced:**\n"
                for skill in project["skills_practiced"]:
                    markdown += f"- {skill}\n"
                markdown += "\n"
                
            markdown += "**Resources:**\n"
            for resource in project.get("resources", []):
                markdown += f"- {resource}\n"
            markdown += "\n"
            
            if "estimated_time" in project:
                markdown += f"**Estimated Time:** {project['estimated_time']}\n\n"
        
        # Resources
        markdown += "## Learning Resources\n\n"
        resources = roadmap.get("resources", {})
        
        resource_categories = {
            "books": "Recommended Books",
            "online_courses": "Online Courses",
            "communities": "Communities",
            "tools": "Essential Tools",
            "practice_platforms": "Practice Platforms"
        }
        
        for category, title in resource_categories.items():
            if category in resources and resources[category]:
                markdown += f"### {title}\n"
                for item in resources[category]:
                    markdown += f"- {item}\n"
                markdown += "\n"
        
        # Career Insights
        if "career_insights" in roadmap and roadmap["career_insights"]:
            markdown += "## Career Opportunities\n\n"
            for insight in roadmap["career_insights"]:
                markdown += f"- {insight}\n"
                
        return markdown

class TeacherRecommender(BaseRecommender):
    def __init__(self, teachers_data: List[Dict[str, Any]]):
        """
        Initialize the teacher recommender with teacher data
        """
        super().__init__()
        self.teachers = pd.DataFrame(teachers_data)
        self._preprocess_data()
        
    def _preprocess_data(self):
        """
        Preprocess the teacher data for better recommendations
        """
        # Convert text columns to lowercase for easier matching
        text_columns = ['name', 'location', 'subject', 'description', 'preferredMode']
        for col in text_columns:
            if col in self.teachers.columns:
                self.teachers[col] = self.teachers[col].astype(str).str.lower()
                
        # Convert any legacy "in-person" to "offline"
        if 'preferredMode' in self.teachers.columns:
            self.teachers['preferredMode'] = self.teachers['preferredMode'].str.replace('in-person', 'offline').str.replace('inperson', 'offline')
                
        # Ensure numeric columns are properly formatted
        self.teachers['rating'] = pd.to_numeric(self.teachers['rating'], errors='coerce').fillna(0)
        self.teachers['fees'] = pd.to_numeric(self.teachers['fees'], errors='coerce').fillna(0)
        self.teachers['experience'] = pd.to_numeric(self.teachers['experience'], errors='coerce').fillna(0)
        
        # Add teacher ID for easy reference
        self.teachers['Teacher ID'] = range(1, len(self.teachers) + 1)
    
    def recommend_teachers(self, 
                          subject: Optional[str] = None,
                          location: Optional[str] = None,
                          preferred_mode: Optional[str] = None,
                          max_fees: Optional[float] = None,
                          min_experience: Optional[int] = None,
                          min_rating: Optional[float] = None,
                          top_n: int = 5) -> pd.DataFrame:
        """
        Recommend teachers based on criteria
        """
        filtered_teachers = self.teachers.copy()
        
        # Show processing indicator
        with self.console.status("[bold green]Finding the best teachers for you...", spinner="dots"):
            # Filter by subject if provided
            if subject:
                subject = subject.lower()
                # Calculate keyword match score for subject
                filtered_teachers['subject_match'] = filtered_teachers['subject'].str.contains(subject).astype(int)
                filtered_teachers = filtered_teachers[filtered_teachers['subject_match'] > 0]
            
            # Filter by location if provided
            if location and not filtered_teachers.empty:
                location = location.lower()
                filtered_teachers = filtered_teachers[filtered_teachers['location'].str.contains(location)]
            
            # Filter by preferred mode if provided
            if preferred_mode and not filtered_teachers.empty:
                preferred_mode = preferred_mode.lower().replace('in-person', 'offline')
                if preferred_mode != 'both':
                    filtered_teachers = filtered_teachers[
                        filtered_teachers['preferredMode'] == preferred_mode
                    ]
            
            # Filter by maximum fees if provided
            if max_fees is not None and not filtered_teachers.empty:
                filtered_teachers = filtered_teachers[filtered_teachers['fees'] <= max_fees]
            
            # Filter by minimum experience if provided
            if min_experience is not None and not filtered_teachers.empty:
                filtered_teachers = filtered_teachers[filtered_teachers['experience'] >= min_experience]
            
            # Filter by minimum rating if provided
            if min_rating is not None and not filtered_teachers.empty:
                filtered_teachers = filtered_teachers[filtered_teachers['rating'] >= min_rating]
            
            # Calculate recommendation score
            if not filtered_teachers.empty:
                filtered_teachers['recommendation_score'] = (
                    filtered_teachers['rating'] * 0.4 +
                    filtered_teachers['experience'] * 0.3 -
                    (filtered_teachers['fees'] / 1000) * 0.2  # Normalize fees impact
                )
                
                # Sort by recommendation score
                filtered_teachers = filtered_teachers.sort_values('recommendation_score', ascending=False)
        
        return filtered_teachers.head(top_n)
    
    def get_teacher_details(self, teacher: pd.Series) -> Dict[str, str]:
        """
        Get detailed teacher information
        """
        mode = teacher.get('preferredMode', 'N/A').title()
        mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline")
        
        return {
            "name": teacher.get('name', 'N/A').title(),
            "email": teacher.get('email', 'N/A'),
            "location": teacher.get('location', 'N/A').title(),
            "subject": teacher.get('subject', 'N/A').title(),
            "rating": str(teacher.get('rating', 'N/A')),
            "preferredMode": mode,
            "fees": str(teacher.get('fees', 'N/A')),
            "description": teacher.get('description', 'No description available'),
            "experience": str(teacher.get('experience', 'N/A')),
            "id": str(teacher.get('Teacher ID', '0'))
        }
    
    def display_recommended_teachers(self, teachers: pd.DataFrame):
        """
        Display recommended teachers in a beautiful format
        """
        if teachers.empty:
            self.console.print("[yellow]No teachers match your criteria. Try broader search terms.[/yellow]")
            return
        
        table = Table(title="Recommended Teachers", box=box.ROUNDED)
        table.add_column("ID", style="dim")
        table.add_column("Name", style="cyan")
        table.add_column("Subject", style="green")
        table.add_column("Rating", style="yellow")
        table.add_column("Experience", style="magenta")
        table.add_column("Fees", style="blue")
        table.add_column("Mode", style="cyan")
        
        for _, teacher in teachers.iterrows():
            mode = teacher.get('preferredMode', 'N/A').title()
            mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline")
            
            table.add_row(
                str(teacher.get('Teacher ID', 'N/A')),
                teacher.get('name', 'N/A').title(),
                teacher.get('subject', 'N/A').title(),
                f"{teacher.get('rating', 0):.1f} ★",
                f"{teacher.get('experience', 0)} years",
                f"${teacher.get('fees', 0):.2f}",
                mode
            )
        
        self.console.print(table)
        self.console.print("\n[dim]Use the teacher ID to get more details about a specific teacher.[/dim]")
    
    def teachers_to_markdown(self, recommended_teachers: pd.DataFrame) -> str:
        """
        Format teacher recommendations as markdown
        """
        teachers_md = "# Recommended Teachers\n\n"
        for i, (_, teacher) in enumerate(recommended_teachers.iterrows()):
            mode = teacher.get('preferredMode', 'N/A').title()
            mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline")
            
            teachers_md += f"## {i+1}. {teacher.get('name', 'N/A').title()}\n\n"
            teachers_md += f"**Subject:** {teacher.get('subject', 'N/A').title()}\n\n"
            teachers_md += f"**Rating:** {teacher.get('rating', 0):.1f} ★\n\n"
            teachers_md += f"**Experience:** {teacher.get('experience', 0)} years\n\n"
            teachers_md += f"**Location:** {teacher.get('location', 'N/A').title()}\n\n"
            teachers_md += f"**Preferred Mode:** {mode}\n\n"
            teachers_md += f"**Fees:** ${teacher.get('fees', 0):.2f}\n\n"
            teachers_md += f"**Description:**\n{teacher.get('description', 'No description available')}\n\n"
            teachers_md += f"**Contact:** {teacher.get('email', 'N/A')}\n\n"
            teachers_md += "---\n\n"
        return teachers_md

def load_teachers(file_path: str = 'teachers.json') -> Optional[TeacherRecommender]:
    """
    Load teachers from JSON and create a TeacherRecommender instance
    """
    console = Console()
    
    try:
        with console.status("[bold green]Loading teacher data...", spinner="dots"):
            with open(file_path, 'r') as f:
                teachers_data = json.load(f)
                
            # Check if it's a list of teachers or a single teacher
            if not isinstance(teachers_data, list):
                teachers_data = [teachers_data]
            
            # Clean and validate teacher data
            validated_teachers = []
            for teacher in teachers_data:
                # Ensure required fields exist
                teacher.setdefault('rating', 0)
                teacher.setdefault('fees', 0)
                teacher.setdefault('experience', 0)
                teacher.setdefault('preferredMode', 'both')
                
                # Convert any legacy modes to offline
                if 'preferredMode' in teacher:
                    teacher['preferredMode'] = teacher['preferredMode'].lower().replace('in-person', 'offline').replace('inperson', 'offline')
                
                validated_teachers.append(teacher)
                
            console.print(f"[green]Successfully loaded {len(validated_teachers)} teachers![/green]")
            return TeacherRecommender(validated_teachers)
    except FileNotFoundError:
        console.print(f"[red]Error: {file_path} file not found.[/red]")
        return None
    except Exception as e:
        console.print(f"[red]An error occurred while reading the JSON: {e}[/red]")
        return None

def create_gradio_interface(course_recommender: CourseRecommender, teacher_recommender: TeacherRecommender):
    """
    Create a Gradio interface that includes both course and teacher recommendations
    """
    def recommend_all(topic, skill_level, goals, use_ai, location, preferred_mode, max_fees, min_experience, min_rating):
        try:
            # Generate roadmap
            roadmap = course_recommender.generate_roadmap(
                topic=topic, 
                skill_level=skill_level, 
                user_goals=goals if goals else None, 
                detailed=use_ai
            )
            
            # Get course recommendations
            recommended_courses = course_recommender.recommend_courses(
                topic=topic, 
                skill_level=skill_level, 
                personalized=use_ai, 
                user_goals=goals if goals else None
            )
            
            # Get teacher recommendations
            recommended_teachers = teacher_recommender.recommend_teachers(
                subject=topic,
                location=location if location else None,
                preferred_mode=preferred_mode if preferred_mode else None,
                max_fees=float(max_fees) if max_fees else None,
                min_experience=int(min_experience) if min_experience else None,
                min_rating=float(min_rating) if min_rating else None
            )
            
            # Convert roadmap to markdown
            roadmap_md = course_recommender.roadmap_to_markdown(roadmap, topic, skill_level)
            
            # Format course recommendations as markdown
            courses_md = format_courses_as_markdown(recommended_courses)
            
            # Format teacher recommendations as markdown
            teachers_md = teacher_recommender.teachers_to_markdown(recommended_teachers)
            
            return roadmap_md, courses_md, teachers_md
        except Exception as e:
            return f"Error: {str(e)}", "Could not generate recommendations", "Could not generate teacher recommendations"
    
    with gr.Blocks(title="Complete Learning Platform") as demo:
        gr.Markdown("# 🎓 Complete Learning Platform")
        gr.Markdown("Generate a personalized learning roadmap, course recommendations, and find expert teachers.")
        
        with gr.Tabs():
            with gr.TabItem("Learning Journey"):
                with gr.Row():
                    with gr.Column():
                        topic_input = gr.Textbox(label="Topic you want to learn", placeholder="e.g. Python, Data Science, Machine Learning")
                        skill_level = gr.Dropdown(
                            ["Beginner", "Intermediate", "Advanced"], 
                            label="Your current skill level"
                        )
                        goals_input = gr.Textbox(
                            label="Your learning goals (optional)", 
                            placeholder="e.g. Career change, specific project, skill enhancement",
                            lines=3
                        )
                        use_ai = gr.Checkbox(label="Use AI-enhanced personalization")
                    
                    with gr.Column():
                        location_input = gr.Textbox(label="Preferred location (optional)", placeholder="e.g. Bangalore, Remote")
                        mode_input = gr.Radio(["online", "offline", "both"], label="Preferred teaching mode", value="both")
                        max_fees_input = gr.Number(label="Maximum budget for teacher fees (optional)")
                        min_exp_input = gr.Number(label="Minimum years of experience (optional)", precision=0)
                        min_rating_input = gr.Slider(minimum=1, maximum=5, value=3, step=0.5, label="Minimum teacher rating")
                
                generate_btn = gr.Button("Generate Complete Learning Plan")
            
            with gr.TabItem("Results"):
                roadmap_output = gr.Markdown(label="Your Personalized Learning Roadmap")
                courses_output = gr.Markdown(label="Recommended Courses")
                teachers_output = gr.Markdown(label="Recommended Teachers")
        
        generate_btn.click(
            recommend_all,
            inputs=[topic_input, skill_level, goals_input, use_ai, 
                   location_input, mode_input, max_fees_input, min_exp_input, min_rating_input],
            outputs=[roadmap_output, courses_output, teachers_output]
        )
    
    return demo

if __name__ == "__main__":
    # Check if being run on Hugging Face Spaces
    if os.getenv("SPACE_ID"):
        # Initialize with the data files that should be included in the Space
        course_recommender = load_courses("Coursera.csv")
        teacher_recommender = load_teachers("teachers.json")
        
        if course_recommender and teacher_recommender:
            # Deploy as a Gradio app
            app = create_gradio_interface(course_recommender, teacher_recommender)
            app.launch()
    else:
        # Run as CLI application
        main()