app.py

import gradio as gr
import os
import json
import uuid
from datetime import datetime
from groq import Groq

# Set up Groq API key
GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
if not GROQ_API_KEY:
    raise ValueError("GROQ_API_KEY environment variable not set.")

client = Groq(api_key=GROQ_API_KEY)

# Default system prompt
SYSTEM_PROMPT = (
    "You are an intelligent, friendly, and highly adaptable Teaching Assistant Chatbot. "
    "Your mission is to help users of all ages and skill levels—from complete beginners to seasoned professionals—learn Python, Data Science, and Artificial Intelligence. "
    "You explain concepts clearly using real-world analogies, examples, and interactive exercises. "
    "You ask questions to assess the learner's level, adapt accordingly, and provide learning paths tailored to their pace and goals. "
    "Your responses are structured, engaging, and supportive. "
    "You can explain code snippets, generate exercises and quizzes, and recommend projects. "
    "You never overwhelm users with jargon. Instead, you scaffold complex concepts in simple, digestible steps."
)

# Define learning paths
LEARNING_PATHS = {
    "python_beginner": {
        "title": "Python Fundamentals",
        "description": "Learn Python basics from variables to functions",
        "modules": [
            "Variables & Data Types", 
            "Control Flow", 
            "Functions", 
            "Data Structures", 
            "File I/O"
        ]
    },
    "python_intermediate": {
        "title": "Intermediate Python",
        "description": "Advance your Python skills with OOP and more",
        "modules": [
            "Object-Oriented Programming", 
            "Modules & Packages", 
            "Error Handling", 
            "List Comprehensions", 
            "Decorators & Generators"
        ]
    },
    "data_science_beginner": {
        "title": "Data Science Foundations",
        "description": "Begin your data science journey",
        "modules": [
            "Numpy Basics", 
            "Pandas Fundamentals", 
            "Data Visualization", 
            "Basic Statistics", 
            "Intro to Machine Learning"
        ]
    },
    "data_science_advanced": {
        "title": "Advanced Data Science",
        "description": "Master complex data science concepts",
        "modules": [
            "Advanced ML Algorithms", 
            "Feature Engineering", 
            "Time Series Analysis", 
            "Natural Language Processing", 
            "Deep Learning Basics"
        ]
    },
    "ai_specialization": {
        "title": "AI Specialization",
        "description": "Focus on artificial intelligence concepts",
        "modules": [
            "Neural Networks", 
            "Computer Vision", 
            "Advanced NLP", 
            "Reinforcement Learning", 
            "AI Ethics"
        ]
    },
    "generative_ai": {
        "title": "Generative AI",
        "description": "Learn how to build and work with generative AI systems",
        "modules": [
            "Generative Models Overview", 
            "GANs & Diffusion Models", 
            "Large Language Models", 
            "Prompt Engineering", 
            "Fine-tuning & RLHF"
        ]
    },
    "agentic_ai": {
        "title": "Agentic AI Systems",
        "description": "Explore AI systems that can act autonomously",
        "modules": [
            "Foundations of AI Agents", 
            "Planning & Decision Making", 
            "Tool-using AI Systems", 
            "Multi-agent Architectures", 
            "Human-AI Collaboration"
        ]
    }
}

# Learning resources organized by learning style
LEARNING_RESOURCES = {
    "Visual": {
        "python_beginner": [
            {"title": "Python Crash Course Visual Guide", "url": "https://nostarch.com/pythoncrashcourse2e"},
            {"title": "Video Course: Python for Everybody", "url": "https://www.py4e.com/"},
            {"title": "Python Visualizations and Infographics", "url": "https://python-graph-gallery.com/"},
            {"title": "Visual Studio Code Python Tutorial", "url": "https://code.visualstudio.com/docs/python/python-tutorial"}
        ],
        "python_intermediate": [
            {"title": "Fluent Python with Visual Examples", "url": "https://www.oreilly.com/library/view/fluent-python-2nd/9781492056348/"},
            {"title": "Python Design Patterns Visualized", "url": "https://refactoring.guru/design-patterns/python"},
            {"title": "Interactive Python Visualizer", "url": "https://pythontutor.com/"},
            {"title": "Visual Guide to Python Testing", "url": "https://pragprog.com/titles/bopytest/python-testing-with-pytest/"}
        ],
        "data_science_beginner": [
            {"title": "Data Visualization with Python and Seaborn", "url": "https://seaborn.pydata.org/tutorial.html"},
            {"title": "Kaggle Learn: Data Visualization", "url": "https://www.kaggle.com/learn/data-visualization"},
            {"title": "DataCamp Python Data Visualization", "url": "https://www.datacamp.com/courses/introduction-to-data-visualization-with-python"},
            {"title": "Plotly Python Graphing Library", "url": "https://plotly.com/python/"}
        ],
        "data_science_advanced": [
            {"title": "Visualization in Machine Learning", "url": "https://machinelearningmastery.com/data-visualization-for-machine-learning/"},
            {"title": "Visual Hands-On Machine Learning", "url": "https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/"},
            {"title": "Stanford ML: Visual Guide to Neural Networks", "url": "https://see.stanford.edu/Course/CS229"},
            {"title": "Animated ML Algorithm Visualizations", "url": "https://www.youtube.com/c/3blue1brown"}
        ],
        "ai_specialization": [
            {"title": "DeepLearning.AI Video Courses", "url": "https://www.deeplearning.ai/"},
            {"title": "TensorFlow Playground", "url": "https://playground.tensorflow.org/"},
            {"title": "Visual Guide to Neural Networks", "url": "https://pytorch.org/tutorials/"},
            {"title": "GANs Explained Visually", "url": "https://poloclub.github.io/ganlab/"}
        ],
        "generative_ai": [
            {"title": "Visualizing Large Language Models", "url": "https://karpathy.ai/zero-to-hero.html"},
            {"title": "Diffusion Models Visual Guide", "url": "https://huggingface.co/learn/diffusion-models/"},
            {"title": "Visual Prompt Engineering Guide", "url": "https://www.promptingguide.ai/"},
            {"title": "Stable Diffusion Visual Tutorial", "url": "https://stability.ai/learn"}
        ],
        "agentic_ai": [
            {"title": "Visual Guide to LangChain", "url": "https://python.langchain.com/docs/get_started/introduction"},
            {"title": "Illustrated AutoGen Guide", "url": "https://microsoft.github.io/autogen/"},
            {"title": "Visual Multi-Agent Simulations", "url": "https://www.anthropic.com/research/debate"},
            {"title": "Animated Reinforcement Learning", "url": "https://rail.eecs.berkeley.edu/deeprlcourse/"}
        ]
    },
    "Reading/Writing": {
        "python_beginner": [
            {"title": "Python Documentation", "url": "https://docs.python.org/3/"},
            {"title": "Real Python Text Tutorials", "url": "https://realpython.com/"},
            {"title": "Automate the Boring Stuff with Python", "url": "https://automatetheboringstuff.com/"},
            {"title": "Think Python (Free eBook)", "url": "https://greenteapress.com/wp/think-python-2e/"}
        ],
        "python_intermediate": [
            {"title": "Fluent Python (Book)", "url": "https://www.oreilly.com/library/view/fluent-python-2nd/9781492056348/"},
            {"title": "Effective Python (Book)", "url": "https://effectivepython.com/"},
            {"title": "Python Cookbook (Book)", "url": "https://www.oreilly.com/library/view/python-cookbook-3rd/9781449357337/"},
            {"title": "Full Stack Python (Text Tutorials)", "url": "https://www.fullstackpython.com/"}
        ],
        "data_science_beginner": [
            {"title": "Python Data Science Handbook", "url": "https://jakevdp.github.io/PythonDataScienceHandbook/"},
            {"title": "Towards Data Science (Articles)", "url": "https://towardsdatascience.com/"},
            {"title": "Introduction to Statistical Learning", "url": "https://www.statlearning.com/"},
            {"title": "Data Science from Scratch (Book)", "url": "https://www.oreilly.com/library/view/data-science-from/9781492041122/"}
        ],
        "data_science_advanced": [
            {"title": "Machine Learning Mastery (Text Tutorials)", "url": "https://machinelearningmastery.com/"},
            {"title": "Deep Learning Book", "url": "https://www.deeplearningbook.org/"},
            {"title": "Elements of Statistical Learning", "url": "https://web.stanford.edu/~hastie/ElemStatLearn/"},
            {"title": "Dive into Deep Learning", "url": "https://d2l.ai/"}
        ],
        "ai_specialization": [
            {"title": "Artificial Intelligence: A Modern Approach", "url": "http://aima.cs.berkeley.edu/"},
            {"title": "Deep Learning (Book)", "url": "https://www.deeplearningbook.org/"},
            {"title": "Stanford ML Course Notes", "url": "https://see.stanford.edu/Course/CS229"},
            {"title": "ArXiv Machine Learning Papers", "url": "https://arxiv.org/list/cs.LG/recent"}
        ],
        "generative_ai": [
            {"title": "LLM Introduction Paper", "url": "https://arxiv.org/abs/2303.18223"},
            {"title": "Generative AI Guide (eBook)", "url": "https://www.oreilly.com/library/view/generative-deep-learning/9781492041931/"},
            {"title": "Prompt Engineering Guide", "url": "https://www.promptingguide.ai/"},
            {"title": "Stanford CS324: LLM Course Notes", "url": "https://stanford-cs324.github.io/winter2022/"}
        ],
        "agentic_ai": [
            {"title": "LangChain Documentation", "url": "https://python.langchain.com/docs/get_started/introduction"},
            {"title": "Agentic AI Papers Collection", "url": "https://arxiv.org/abs/2304.03442"},
            {"title": "Multi-Agent Debate Research", "url": "https://www.anthropic.com/research/debate"},
            {"title": "Reinforcement Learning: An Introduction", "url": "http://incompleteideas.net/book/the-book-2nd.html"}
        ]
    },
    "Hands-on Projects": {
        "python_beginner": [
            {"title": "Project-Based Python Tutorial", "url": "https://projectbasedpython.com/"},
            {"title": "Exercism: Python Track", "url": "https://exercism.org/tracks/python"},
            {"title": "Python Project Ideas with Code", "url": "https://github.com/topics/python-projects"},
            {"title": "Build 5 Mini Python Projects", "url": "https://www.freecodecamp.org/news/python-projects-for-beginners/"}
        ],
        "python_intermediate": [
            {"title": "Django Project Tutorial", "url": "https://docs.djangoproject.com/en/stable/intro/tutorial01/"},
            {"title": "Flask Mega-Tutorial", "url": "https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world"},
            {"title": "Python Project Cookbook", "url": "https://pythonprojectcookbook.com/"},
            {"title": "Real-world Python Projects", "url": "https://realpython.com/tutorials/projects/"}
        ],
        "data_science_beginner": [
            {"title": "Kaggle: Intro to Machine Learning", "url": "https://www.kaggle.com/learn/intro-to-machine-learning"},
            {"title": "Data Science Projects with Python", "url": "https://github.com/PacktPublishing/Data-Science-Projects-with-Python"},
            {"title": "DataCamp Projects", "url": "https://www.datacamp.com/projects"},
            {"title": "Practical Data Analysis Projects", "url": "https://www.dataquest.io/data-science-projects/"}
        ],
        "data_science_advanced": [
            {"title": "Applied Machine Learning Projects", "url": "https://github.com/practical-tutorials/project-based-learning#python"},
            {"title": "Kaggle Competitions", "url": "https://www.kaggle.com/competitions"},
            {"title": "Building ML Pipelines", "url": "https://www.oreilly.com/library/view/building-machine-learning/9781492053187/"},
            {"title": "ML Project Walkthroughs", "url": "https://machinelearningmastery.com/start-here/#projects"}
        ],
        "ai_specialization": [
            {"title": "TensorFlow Tutorials & Projects", "url": "https://www.tensorflow.org/tutorials"},
            {"title": "PyTorch Projects Collection", "url": "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html"},
            {"title": "Hugging Face Project Walkthroughs", "url": "https://huggingface.co/learn"},
            {"title": "Computer Vision Projects", "url": "https://www.pyimagesearch.com/"}
        ],
        "generative_ai": [
            {"title": "Build Your Own LLM Application", "url": "https://buildyourowngpt.com/"},
            {"title": "Generative Art Projects", "url": "https://genart.tech/"},
            {"title": "LangChain Project Tutorials", "url": "https://python.langchain.com/docs/get_started/introduction"},
            {"title": "Fine-tuning LLMs: Hands-on Guide", "url": "https://huggingface.co/blog/how-to-train"}
        ],
        "agentic_ai": [
            {"title": "Build an AI Agent with LangChain", "url": "https://python.langchain.com/docs/use_cases/autonomous_agents"},
            {"title": "AutoGen Projects", "url": "https://microsoft.github.io/autogen/docs/examples/"},
            {"title": "Building Autonomous AI Systems", "url": "https://github.com/yoheinakajima/babyagi"},
            {"title": "Tool-using AI Projects", "url": "https://github.com/hwchase17/langchain-experiments"}
        ]
    },
    "Video Tutorials": {
        "python_beginner": [
            {"title": "Python Full Course for Beginners", "url": "https://www.youtube.com/watch?v=_uQrJ0TkZlc"},
            {"title": "CS50's Introduction to Programming with Python", "url": "https://cs50.harvard.edu/python/"},
            {"title": "Python Tutorial - Python for Beginners", "url": "https://www.youtube.com/watch?v=_uQrJ0TkZlc"},
            {"title": "freeCodeCamp Python Course", "url": "https://www.freecodecamp.org/learn/scientific-computing-with-python/"}
        ],
        "python_intermediate": [
            {"title": "Corey Schafer Python Tutorials", "url": "https://www.youtube.com/user/schafer5"},
            {"title": "Advanced Python Features", "url": "https://www.youtube.com/playlist?list=PLP8GkvaIxJP0VAXF3USi9U4JnpxnHjT_"},
            {"title": "Python OOP Tutorials", "url": "https://www.youtube.com/playlist?list=PLzMcBGfZo4-l1MqB1zoYfqzlj_HH-ZzXt"},
            {"title": "MIT OpenCourseWare: Python", "url": "https://ocw.mit.edu/courses/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/"}
        ],
        "data_science_beginner": [
            {"title": "Python for Data Science Course", "url": "https://www.youtube.com/watch?v=LHBE6Q9XlzI"},
            {"title": "Data Analysis with Python - Full Course", "url": "https://www.youtube.com/watch?v=r-uOLxNrNk8"},
            {"title": "Statistics Fundamentals", "url": "https://www.youtube.com/playlist?list=PLblh5JKOoLUK0FLuzwntyYI10UQFUhsY9"},
            {"title": "freeCodeCamp Data Analysis Course", "url": "https://www.freecodecamp.org/learn/data-analysis-with-python/"}
        ],
        "data_science_advanced": [
            {"title": "StatQuest: Machine Learning", "url": "https://www.youtube.com/playlist?list=PLblh5JKOoLUIcdlgu78MnlATeyx4cEVeR"},
            {"title": "Machine Learning Course by Andrew Ng", "url": "https://www.coursera.org/learn/machine-learning"},
            {"title": "Deep Learning Specialization", "url": "https://www.deeplearning.ai/deep-learning-specialization/"},
            {"title": "Data Science Full Course", "url": "https://www.youtube.com/watch?v=ua-CiDNNj30"}
        ],
        "ai_specialization": [
            {"title": "Stanford CS231n: CNN for Visual Recognition", "url": "https://www.youtube.com/playlist?list=PL3FW7Lu3i5JvHM8ljYj-zLfQRF3EO8sYv"},
            {"title": "Deep Learning Lectures by Lex Fridman", "url": "https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf"},
            {"title": "MIT 6.S191: Introduction to Deep Learning", "url": "http://introtodeeplearning.com/"},
            {"title": "Stanford CS224N: NLP with Deep Learning", "url": "https://www.youtube.com/playlist?list=PLoROMvodv4rOhcuXMZkNm7j3fVwBBY42z"}
        ],
        "generative_ai": [
            {"title": "Neural Networks: Zero to Hero", "url": "https://karpathy.ai/zero-to-hero.html"},
            {"title": "LLM Bootcamp", "url": "https://www.youtube.com/watch?v=twHxmU9OxDU"},
            {"title": "Diffusion Models Explained", "url": "https://www.youtube.com/watch?v=fbLgFrlTnGU"},
            {"title": "Prompt Engineering for LLMs", "url": "https://www.deeplearning.ai/short-courses/chatgpt-prompt-engineering-for-developers/"}
        ],
        "agentic_ai": [
            {"title": "Building AI Agents with LangChain", "url": "https://www.youtube.com/watch?v=iw2Wcw7qPuE"},
            {"title": "LLM Agents Tutorial", "url": "https://www.youtube.com/watch?v=RUzgloRlHIc"},
            {"title": "Reinforcement Learning Course", "url": "https://www.youtube.com/playlist?list=PLqYmG7hTraZDM-OYHWgPebj2MfCFzFObQ"},
            {"title": "AutoGPT and Multi-Agent Systems", "url": "https://www.youtube.com/watch?v=4YaILFaUXTo"}
        ]
    },
    "Interactive Exercises": {
        "python_beginner": [
            {"title": "CodeCademy Python Course", "url": "https://www.codecademy.com/learn/learn-python-3"},
            {"title": "CheckiO Python Challenges", "url": "https://py.checkio.org/"},
            {"title": "Python Tutor", "url": "https://pythontutor.com/"},
            {"title": "HackerRank Python Practice", "url": "https://www.hackerrank.com/domains/python"}
        ],
        "python_intermediate": [
            {"title": "Exercism Python Track", "url": "https://exercism.org/tracks/python"},
            {"title": "CodeWars Python Challenges", "url": "https://www.codewars.com/?language=python"},
            {"title": "LeetCode Python Problems", "url": "https://leetcode.com/problemset/all/?difficulty=EASY&page=1&languageTags=python"},
            {"title": "Project Euler", "url": "https://projecteuler.net/"}
        ],
        "data_science_beginner": [
            {"title": "DataCamp Interactive Courses", "url": "https://www.datacamp.com/courses/free-introduction-to-r"},
            {"title": "Kaggle Learn Interactive Tutorials", "url": "https://www.kaggle.com/learn/overview"},
            {"title": "DataQuest Interactive Data Science", "url": "https://www.dataquest.io/"},
            {"title": "Google's Data Analytics Course", "url": "https://www.coursera.org/professional-certificates/google-data-analytics"}
        ],
        "data_science_advanced": [
            {"title": "Interactive ML Course", "url": "https://www.coursera.org/learn/machine-learning"},
            {"title": "Kaggle Interactive Competitions", "url": "https://www.kaggle.com/competitions"},
            {"title": "Interactive Deep Learning", "url": "https://www.deeplearning.ai/courses/"},
            {"title": "Machine Learning Playground", "url": "https://ml-playground.com/"}
        ],
        "ai_specialization": [
            {"title": "TensorFlow Playground", "url": "https://playground.tensorflow.org/"},
            {"title": "Interactive Neural Network Builder", "url": "https://alexlenail.me/NN-SVG/"},
            {"title": "AI Experiments with Google", "url": "https://experiments.withgoogle.com/collection/ai"},
            {"title": "OpenAI Gym", "url": "https://www.gymlibrary.dev/"}
        ],
        "generative_ai": [
            {"title": "Hugging Face Spaces", "url": "https://huggingface.co/spaces"},
            {"title": "Interactive LLM Playground", "url": "https://platform.openai.com/playground"},
            {"title": "Interactive Stable Diffusion", "url": "https://huggingface.co/spaces/stabilityai/stable-diffusion"},
            {"title": "GPT-4 Interactive Demos", "url": "https://chat.openai.com/"}
        ],
        "agentic_ai": [
            {"title": "LangChain Interactive Tutorials", "url": "https://python.langchain.com/docs/get_started/introduction"},
            {"title": "Interactive AI Agent Builder", "url": "https://github.com/microsoft/TaskMatrix"},
            {"title": "AutoGen Playground", "url": "https://microsoft.github.io/autogen/"},
            {"title": "Reinforcement Learning Interactive Course", "url": "https://www.coursera.org/specializations/reinforcement-learning"}
        ]
    },
    "Combination": {
        "python_beginner": [
            {"title": "Python Documentation", "url": "https://docs.python.org/3/"},
            {"title": "Real Python", "url": "https://realpython.com/"},
            {"title": "Python for Everybody", "url": "https://www.py4e.com/"},
            {"title": "Automate the Boring Stuff with Python", "url": "https://automatetheboringstuff.com/"}
        ],
        "python_intermediate": [
            {"title": "Fluent Python", "url": "https://www.oreilly.com/library/view/fluent-python-2nd/9781492056348/"},
            {"title": "Python Design Patterns", "url": "https://refactoring.guru/design-patterns/python"},
            {"title": "Full Stack Python", "url": "https://www.fullstackpython.com/"},
            {"title": "Python Testing with pytest", "url": "https://pragprog.com/titles/bopytest/python-testing-with-pytest/"}
        ],
        "data_science_beginner": [
            {"title": "Kaggle Learn", "url": "https://www.kaggle.com/learn"},
            {"title": "Towards Data Science", "url": "https://towardsdatascience.com/"},
            {"title": "DataCamp", "url": "https://www.datacamp.com/"},
            {"title": "Python Data Science Handbook", "url": "https://jakevdp.github.io/PythonDataScienceHandbook/"}
        ],
        "data_science_advanced": [
            {"title": "Machine Learning Mastery", "url": "https://machinelearningmastery.com/"},
            {"title": "Hands-On Machine Learning with Scikit-Learn", "url": "https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/"},
            {"title": "Fast.ai", "url": "https://www.fast.ai/"},
            {"title": "Stanford CS229: Machine Learning", "url": "https://see.stanford.edu/Course/CS229"}
        ],
        "ai_specialization": [
            {"title": "DeepLearning.AI", "url": "https://www.deeplearning.ai/"},
            {"title": "TensorFlow Tutorials", "url": "https://www.tensorflow.org/tutorials"},
            {"title": "PyTorch Tutorials", "url": "https://pytorch.org/tutorials/"},
            {"title": "Hugging Face Course", "url": "https://huggingface.co/learn"}
        ],
        "generative_ai": [
            {"title": "Andrej Karpathy's Neural Networks Course", "url": "https://karpathy.ai/zero-to-hero.html"},
            {"title": "Hugging Face Diffusion Models Course", "url": "https://huggingface.co/learn/diffusion-models/"},
            {"title": "Prompt Engineering Guide", "url": "https://www.promptingguide.ai/"},
            {"title": "Stanford CS324: Large Language Models", "url": "https://stanford-cs324.github.io/winter2022/"}
        ],
        "agentic_ai": [
            {"title": "LangChain Documentation", "url": "https://python.langchain.com/docs/get_started/introduction"},
            {"title": "Microsoft AutoGen", "url": "https://microsoft.github.io/autogen/"},
            {"title": "Multi-Agent Debate by Anthropic", "url": "https://www.anthropic.com/research/debate"},
            {"title": "Berkeley CS285: Deep Reinforcement Learning", "url": "https://rail.eecs.berkeley.edu/deeprlcourse/"}
        ]
    }
}

PROJECT_IDEAS = {
    "Visual": {
        "python_beginner": [
            "Data Visualization Dashboard with Matplotlib",
            "Interactive Game with Pygame",
            "Visual Timer Application with Tkinter",
            "Color Palette Generator",
            "Image Processing Tool"
        ],
        "python_intermediate": [
            "Data Visualization Web App with Flask and D3.js",
            "Interactive Map Application",
            "Animated Data Dashboard",
            "Custom Visualization Library",
            "Image Recognition System"
        ],
        "data_science_beginner": [
            "Interactive Data Dashboard with Plotly",
            "Visual Exploratory Data Analysis Tool",
            "Chart Comparison Application",
            "Geographic Data Visualization",
            "Statistical Visualization Gallery"
        ],
        "data_science_advanced": [
            "Real-time Visual Analytics Dashboard",
            "Machine Learning Model Visualizer",
            "Neural Network Visualization Tool",
            "Computer Vision Project",
            "Interactive Data Storytelling Platform"
        ],
        "ai_specialization": [
            "Neural Network Architecture Visualizer",
            "Interactive AI Learning Environment",
            "Computer Vision Object Detector",
            "Visual Pattern Recognition System",
            "Brain-Computer Interface Visualization"
        ],
        "generative_ai": [
            "Style Transfer Art Generator",
            "Visual AI Art Gallery",
            "Image Generation Dashboard",
            "Interactive Text-to-Image System",
            "Visual Prompt Engineering Tool"
        ],
        "agentic_ai": [
            "Visual Agent Environment Simulator",
            "Agent Decision Tree Visualizer",
            "Multi-Agent Interaction Visualization",
            "Visual Reinforcement Learning Playground",
            "Interactive Agent Behavior Explorer"
        ]
    },
    "Reading/Writing": {
        "python_beginner": [
            "Text File Processing Tool",
            "Personal Journal Application",
            "Notes Organization System",
            "Simple Blog Platform",
            "Document Analyzer"
        ],
        "python_intermediate": [
            "Advanced Text Editor",
            "Markdown Documentation Generator",
            "Content Management System",
            "Personal Wiki Platform",
            "Technical Documentation Tool"
        ],
        "data_science_beginner": [
            "Text Data Analysis Tool",
            "Literature Review Database",
            "Research Paper Summarizer",
            "Study Notes Organizer",
            "Data Analysis Report Generator"
        ],
        "data_science_advanced": [
            "Research Paper Recommendation System",
            "Advanced NLP Analysis Tool",
            "Automated Report Generator",
            "Literature Review AI Assistant",
            "Technical Writing Assistant"
        ],
        "ai_specialization": [
            "Text Summarization System",
            "AI-Powered Document Analysis",
            "Scientific Paper Classification Tool",
            "Sentiment Analysis for Literature",
            "Technical Writing Enhancement System"
        ],
        "generative_ai": [
            "AI Writing Assistant",
            "Creative Story Generator",
            "Academic Paper Generator",
            "LLM-Powered Documentation Tool",
            "Custom Prompt Engineering Workbook"
        ],
        "agentic_ai": [
            "AI Research Assistant Agent",
            "Technical Documentation Generator",
            "Writing Style Analyzer",
            "Text-Based Agent Environment",
            "AI-Powered Knowledge Management System"
        ]
    },
    "Hands-on Projects": {
        "python_beginner": [
            "Weather App with API Integration",
            "To-Do List Application",
            "Simple Calculator",
            "Basic Web Scraper",
            "File Organizer Tool"
        ],
        "python_intermediate": [
            "REST API with Flask or Django",
            "Web Application with User Authentication",
            "Automated Testing Framework",
            "Command-Line Tool with Click",
            "Desktop Application with PyQt"
        ],
        "data_science_beginner": [
            "Exploratory Data Analysis Project",
            "Basic Machine Learning Model",
            "Data Cleaning Pipeline",
            "Simple Predictive Model",
            "Dataset Visualization Tool"
        ],
        "data_science_advanced": [
            "End-to-End Machine Learning Pipeline",
            "Model Deployment with Flask/FastAPI",
            "Time Series Forecasting Application",
            "Natural Language Processing Tool",
            "Recommendation System"
        ],
        "ai_specialization": [
            "Custom Neural Network Implementation",
            "Image Classification Application",
            "NLP Chatbot",
            "Reinforcement Learning Environment",
            "Computer Vision Project"
        ],
        "generative_ai": [
            "Fine-tuned LLM Application",
            "Text-to-Image Generation Tool",
            "Music Generation System",
            "Creative Writing AI Assistant",
            "Voice Synthesis Application"
        ],
        "agentic_ai": [
            "Autonomous Task Execution Agent",
            "Multi-Agent Simulation",
            "Tool-Using AI Assistant",
            "AI Agent for Data Analysis",
            "Agent-Based Decision Support System"
        ]
    },
    "Video Tutorials": {
        "python_beginner": [
            "Educational Python Basics Series",
            "Interactive Coding Tutorial Videos",
            "Python Concept Explanation Screencast",
            "Code-Along Project Videos",
            "Python Tips and Tricks Channel"
        ],
        "python_intermediate": [
            "Advanced Python Features Tutorial Series",
            "Framework Deep-Dive Videos",
            "Performance Optimization Screencasts",
            "Design Patterns in Python Series",
            "Testing and Debugging Tutorials"
        ],
        "data_science_beginner": [
            "Data Analysis Walkthrough Series",
            "Statistics Visualization Tutorials",
            "Data Cleaning Process Videos",
            "Basic Machine Learning Model Tutorials",
            "Data Visualization Guide Videos"
        ],
        "data_science_advanced": [
            "Advanced ML Algorithm Explanations",
            "Feature Engineering Masterclass",
            "Model Optimization Techniques Series",
            "ML Pipeline Development Videos",
            "Model Deployment Tutorials"
        ],
        "ai_specialization": [
            "Neural Network Architecture Explanations",
            "Deep Learning Framework Tutorials",
            "Computer Vision Project Series",
            "NLP Implementation Videos",
            "AI Ethics Discussion Series"
        ],
        "generative_ai": [
            "LLM Implementation Tutorials",
            "Diffusion Model Training Guide",
            "Prompt Engineering Masterclass",
            "Fine-tuning Walkthrough Videos",
            "Generative AI Application Tutorials"
        ],
        "agentic_ai": [
            "AI Agent Development Series",
            "Multi-Agent System Tutorials",
            "LangChain Implementation Videos",
            "Tool-Using AI Development Guide",
            "Agent Communication Protocol Tutorials"
        ]
    },
    "Interactive Exercises": {
        "python_beginner": [
            "Python Syntax Practice Platform",
            "Interactive Coding Challenge Website",
            "Function Implementation Exercises",
            "Python Puzzle Game",
            "Basic Algorithm Challenge Series"
        ],
        "python_intermediate": [
            "Object-Oriented Programming Exercises",
            "Advanced Data Structure Challenges",
            "Algorithm Optimization Problems",
            "Design Pattern Implementation Tasks",
            "Testing Framework Exercise Platform"
        ],
        "data_science_beginner": [
            "Data Cleaning Exercise Platform",
            "Statistical Analysis Practice Problems",
            "Basic ML Model Implementation Challenges",
            "Data Visualization Exercise Series",
            "Exploratory Data Analysis Worksheets"
        ],
        "data_science_advanced": [
            "Advanced ML Algorithm Implementation",
            "Feature Engineering Challenge Platform",
            "Model Optimization Exercises",
            "NLP Processing Tasks",
            "Time Series Analysis Problems"
        ],
        "ai_specialization": [
            "Neural Network Implementation Exercises",
            "Deep Learning Framework Challenges",
            "Computer Vision Task Series",
            "NLP Model Building Problems",
            "AI Ethics Case Studies"
        ],
        "generative_ai": [
            "Prompt Engineering Practice Platform",
            "LLM Fine-tuning Exercise Suite",
            "Diffusion Model Parameter Tuning",
            "Generative Model Evaluation Tasks",
            "Text-to-Image Generation Challenges"
        ],
        "agentic_ai": [
            "Agent Development Exercise Platform",
            "Multi-Agent System Building Tasks",
            "Tool-Using AI Implementation Challenges",
            "Reinforcement Learning Problems",
            "Agent Communication Protocol Exercises"
        ]
    },
    "Combination": {
        "python_beginner": [
            "Multi-format Python Learning Platform",
            "Integrated Code and Video Tutorial Project",
            "Interactive Documentation System",
            "Visual and Written Tutorial Combination",
            "Exercise-Based Learning Environment"
        ],
        "python_intermediate": [
            "Full-Stack Python Development Course",
            "Project-Based Learning Platform",
            "Video and Interactive Exercise Combination",
            "Visual Programming Environment",
            "Code Review and Mentoring System"
        ],
        "data_science_beginner": [
            "Data Science Learning Path Platform",
            "Interactive Data Analysis Environment",
            "Video and Exercise-Based Statistics Course",
            "Visual Data Science Notebook System",
            "Hands-on Data Project Platform"
        ],
        "data_science_advanced": [
            "Advanced ML Project Portfolio",
            "Interactive Research Implementation Platform",
            "Video and Code-Based ML Framework",
            "Visual ML Pipeline Development System",
            "Experimental ML Environment"
        ],
        "ai_specialization": [
            "AI Research and Implementation Platform",
            "Deep Learning Visual Learning System",
            "Interactive Neural Network Builder",
            "Video and Code-Based AI Framework",
            "Hands-on AI Ethics Learning Environment"
        ],
        "generative_ai": [
            "Generative AI Development Platform",
            "Interactive LLM Training Environment",
            "Visual Prompt Engineering System",
            "Model Fine-tuning Learning Path",
            "Creative AI Implementation Framework"
        ],
        "agentic_ai": [
            "Agent Development Environment",
            "Multi-Agent Simulation Platform",
            "Interactive Tool-Using AI Builder",
            "Video and Code-Based Agent Framework",
            "Experimental Agent Testing System"
        ]
    }
}

# User session data store
SESSION_DATA = {}

def save_session(session_id, data):
    """Save session data to SESSION_DATA global dictionary"""
    if session_id in SESSION_DATA:
        SESSION_DATA[session_id].update(data)
    else:
        SESSION_DATA[session_id] = data
    
    # Add timestamp for session tracking
    SESSION_DATA[session_id]["last_activity"] = datetime.now().isoformat()

def load_session(session_id):
    """Load session data from SESSION_DATA global dictionary"""
    return SESSION_DATA.get(session_id, {})

def recommend_learning_path(age, goals, knowledge_level, interests):
    """Recommend personalized learning paths based on user profile"""
    paths = []
    
    # Simple recommendation logic based on profile
    if "beginner" in knowledge_level.lower():
        if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
            paths.append("python_beginner")
        if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
            paths.append("data_science_beginner")
    elif "intermediate" in knowledge_level.lower():
        if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
            paths.append("python_intermediate")
        if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
            paths.append("data_science_advanced")
        if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
            paths.append("ai_specialization")
        if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
            paths.append("generative_ai")
    elif "advanced" in knowledge_level.lower() or "expert" in knowledge_level.lower():
        if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
            paths.append("ai_specialization")
        if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
            paths.append("generative_ai")
        if any(topic in interests.lower() for topic in ["agent", "autonomous", "planning"]):
            paths.append("agentic_ai")
    
    # Check for specific mentions of generative or agentic AI regardless of level
    if any(topic in interests.lower() for topic in ["generative", "gpt", "llm", "diffusion"]):
        if "generative_ai" not in paths:
            paths.append("generative_ai")
            
    if any(topic in interests.lower() for topic in ["agent", "autonomous", "planning"]):
        if "agentic_ai" not in paths:
            paths.append("agentic_ai")
    
    # Default path if no matches
    if not paths:
        paths = ["python_beginner"]
    
    return [LEARNING_PATHS[path] for path in paths if path in LEARNING_PATHS]

def get_recommended_resources(interests, knowledge_level, recommended_paths):
    """Get recommended learning resources based on interests and recommended paths"""
    resources = []
    
    # Get path IDs from recommended paths
    path_ids = []
    for path in recommended_paths:
        path_id = next((k for k, v in LEARNING_PATHS.items() if v["title"] == path["title"]), None)
        if path_id:
            path_ids.append(path_id)
    
    # Add resources for each recommended path
    for path_id in path_ids:
        if path_id in LEARNING_RESOURCES:
            resources.extend(LEARNING_RESOURCES[path_id])
    
    # If no specific paths match, provide resources based on interests and level
    if not resources:
        if "beginner" in knowledge_level.lower():
            if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
                resources.extend(LEARNING_RESOURCES["python_beginner"])
            if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
                resources.extend(LEARNING_RESOURCES["data_science_beginner"])
        elif "intermediate" in knowledge_level.lower():
            if any(topic in interests.lower() for topic in ["python", "programming", "coding"]):
                resources.extend(LEARNING_RESOURCES["python_intermediate"])
            if any(topic in interests.lower() for topic in ["data", "analysis", "statistics"]):
                resources.extend(LEARNING_RESOURCES["data_science_advanced"])
        elif "advanced" in knowledge_level.lower() or "expert" in knowledge_level.lower():
            if any(topic in interests.lower() for topic in ["ai", "machine learning", "deep learning"]):
                resources.extend(LEARNING_RESOURCES["ai_specialization"])
    
    # If still no resources, provide general resources
    if not resources:
        for category in ["python_beginner", "data_science_beginner"]:
            resources.extend(LEARNING_RESOURCES[category][:2])
    
    # Remove duplicates while preserving order
    unique_resources = []
    seen_titles = set()
    for resource in resources:
        if resource["title"] not in seen_titles:
            seen_titles.add(resource["title"])
            unique_resources.append(resource)
    
    return unique_resources

def get_project_ideas(recommended_paths):
    """Get project ideas based on recommended learning paths"""
    ideas = []
    
    # Get project ideas for each recommended path
    for path in recommended_paths:
        path_id = next((k for k, v in LEARNING_PATHS.items() if v["title"] == path["title"]), None)
        if path_id and path_id in PROJECT_IDEAS:
            ideas.extend(PROJECT_IDEAS[path_id])
    
    # If no specific paths match, provide some general project ideas
    if not ideas:
        ideas = PROJECT_IDEAS["python_beginner"][:2] + PROJECT_IDEAS["data_science_beginner"][:2]
    
    # Remove duplicates while preserving order
    unique_ideas = []
    seen_ideas = set()
    for idea in ideas:
        if idea not in seen_ideas:
            seen_ideas.add(idea)
            unique_ideas.append(idea)
    
    return unique_ideas[:5]  # Return up to 5 project ideas

def generate_quiz(topic, difficulty):
    """Generate a quiz based on the topic and difficulty"""
    # In a real application, you might use the LLM to generate quizzes
    # Here we're using a template approach for simplicity
    quiz_prompt = f"""
    Generate a {difficulty} level quiz on {topic} with 3 multiple-choice questions.
    For each question, provide 4 options and indicate the correct answer.
    Format the quiz nicely with clear question numbering and option lettering.
    """
    
    # Use Groq to generate the quiz
    quiz_messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": quiz_prompt}
    ]
    
    quiz_response = client.chat.completions.create(
        messages=quiz_messages,
        model="llama-3.3-70b-versatile",
        stream=False
    )
    
    return quiz_response.choices[0].message.content

def create_study_plan(topic, time_available, goals, knowledge_level):
    """Create a personalized study plan"""
    plan_prompt = f"""
    Create a structured study plan for learning {topic} with {time_available} hours per week available for study.
    The learner's goal is: {goals}
    The learner's knowledge level is: {knowledge_level}
    
    Include:
    1. Weekly breakdown of topics
    2. Time allocation for theory vs practice
    3. Recommended resources for each week
    4. Milestone projects or assessments
    5. Tips for effective learning
    
    Make this plan specific, actionable, and tailored to the knowledge level.
    """
    
    # Use Groq to generate the study plan
    plan_messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": plan_prompt}
    ]
    
    plan_response = client.chat.completions.create(
        messages=plan_messages,
        model="llama-3.3-70b-versatile",
        stream=False
    )
    
    return plan_response.choices[0].message.content

def chat_with_groq(user_input, session_id):
    """Chat with Groq LLM using session context"""
    user_data = load_session(session_id)
    
    # Build context from session data if available
    context = ""
    if user_data:
        context = f"""
        User Profile:
        - Age: {user_data.get('age', 'Unknown')}
        - Knowledge Level: {user_data.get('knowledge_level', 'Unknown')}
        - Learning Goals: {user_data.get('goals', 'Unknown')}
        - Interests: {user_data.get('interests', 'Unknown')}
        - Available Study Time: {user_data.get('study_time', 'Unknown')} hours per week
        - Preferred Learning Style: {user_data.get('learning_style', 'Unknown')}
        
        Based on this profile, tailor your response appropriately.
        """
    
    # Add chat history context if available
    chat_history = user_data.get('chat_history', [])
    if chat_history:
        context += "\n\nRecent conversation context (most recent first):\n"
        # Include up to 3 most recent exchanges
        for i, (q, a) in enumerate(reversed(chat_history[-3:])):
            context += f"User: {q}\nYou: {a}\n\n"
    
    # Combine everything for the LLM
    full_prompt = f"{context}\n\nUser's current question: {user_input}"
    
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": full_prompt}
    ]
    
    chat_completion = client.chat.completions.create(
        messages=messages,
        model="llama-3.3-70b-versatile",
        stream=False
    )
    
    response = chat_completion.choices[0].message.content
    
    # Update chat history
    if 'chat_history' not in user_data:
        user_data['chat_history'] = []
    user_data['chat_history'].append((user_input, response))
    save_session(session_id, user_data)
    
    return response

def format_learning_paths(paths):
    """Format learning paths for display"""
    if not paths:
        return "No specific learning paths recommended yet. Please complete your profile."
    
    result = "### Recommended Learning Paths\n\n"
    for i, path in enumerate(paths, 1):
        result += f"**{i}. {path['title']}**\n"
        result += f"{path['description']}\n\n"
        result += "**Modules:**\n"
        for module in path['modules']:
            result += f"- {module}\n"
        result += "\n"
    
    return result

def format_resources(resources):
    """Format resources for display"""
    if not resources:
        return "No resources recommended yet. Please complete your profile."
    
    result = "### Recommended Learning Resources\n\n"
    for i, resource in enumerate(resources, 1):
        result += f"{i}. [{resource['title']}]({resource['url']})\n"
    
    return result

def format_project_ideas(ideas):
    """Format project ideas for display"""
    if not ideas:
        return "No project ideas recommended yet. Please complete your profile."
    
    result = "### Recommended Practice Projects\n\n"
    for i, idea in enumerate(ideas, 1):
        result += f"{i}. {idea}\n"
    
    return result

def user_onboarding(session_id, age, goals, knowledge_level, interests, study_time, learning_style):
    """Process user profile and provide initial recommendations"""
    # Save user profile data
    user_data = {
        'age': age,
        'goals': goals,
        'knowledge_level': knowledge_level,
        'interests': interests,
        'study_time': study_time,
        'learning_style': learning_style
    }
    save_session(session_id, user_data)
    
    # Generate recommendations
    learning_paths = recommend_learning_path(age, goals, knowledge_level, interests)
    resources = get_recommended_resources(interests, knowledge_level, learning_paths)
    project_ideas = get_project_ideas(learning_paths)
    
    # Save recommendations to session
    user_data.update({
        'recommended_paths': learning_paths,
        'recommended_resources': resources,
        'recommended_projects': project_ideas
    })
    save_session(session_id, user_data)
    
    # Format welcome message with personalized recommendations
    welcome_message = f"""
    # Welcome to Your Personalized Learning Journey!

    Thank you for providing your profile. Based on your information, I've prepared some tailored recommendations to start your learning journey.
    
    ## Your Profile Summary:
    - **Age:** {age}
    - **Knowledge Level:** {knowledge_level}
    - **Learning Goals:** {goals}
    - **Interests:** {interests}
    - **Available Study Time:** {study_time} hours per week
    - **Preferred Learning Style:** {learning_style}
    
    {format_learning_paths(learning_paths)}
    
    {format_resources(resources)}
    
    {format_project_ideas(project_ideas)}
    
    ## Next Steps:
    1. Browse through the recommended learning paths and resources
    2. Ask me any questions about the topics you're interested in
    3. Request exercises, explanations, or code samples
    4. Try one of the project ideas to apply your knowledge
    
    I'm here to help you every step of the way! What would you like to explore first?
    """
    
    return welcome_message

def chatbot_interface(session_id, user_message):
    """Main chatbot interface function"""
    user_data = load_session(session_id)
    
    if not user_data or not user_data.get('age'):
        return "Please complete your profile first by going to the Profile tab."
    
    response = chat_with_groq(user_message, session_id)
    return response

def generate_recommendations(session_id):
    """Generate or refresh recommendations based on current profile"""
    user_data = load_session(session_id)
    
    if not user_data or not user_data.get('age'):
        return "Please complete your profile first by going to the Profile tab."
    
    # Generate fresh recommendations
    learning_paths = recommend_learning_path(
        user_data.get('age', ''), 
        user_data.get('goals', ''), 
        user_data.get('knowledge_level', ''),
        user_data.get('interests', '')
    )
    resources = get_recommended_resources(
        user_data.get('interests', ''),
        user_data.get('knowledge_level', ''),
        learning_paths
    )
    project_ideas = get_project_ideas(learning_paths)
    
    # Save recommendations to session
    user_data.update({
        'recommended_paths': learning_paths,
        'recommended_resources': resources,
        'recommended_projects': project_ideas
    })
    save_session(session_id, user_data)
    
    # Format recommendations
    recommendations = f"""
    # Your Personalized Learning Recommendations
    
    {format_learning_paths(learning_paths)}
    
    {format_resources(resources)}
    
    {format_project_ideas(project_ideas)}
    """
    
    return recommendations

def handle_quiz_request(session_id, topic, difficulty):
    """Handle quiz generation request"""
    user_data = load_session(session_id)
    
    if not user_data or not user_data.get('age'):
        return "Please complete your profile first by going to the Profile tab."
    
    quiz = generate_quiz(topic, difficulty)
    return quiz

def handle_study_plan_request(session_id, topic, time_available):
    """Handle study plan generation request"""
    user_data = load_session(session_id)
    
    if not user_data or not user_data.get('age'):
        return "Please complete your profile first by going to the Profile tab."
    
    goals = user_data.get('goals', 'improving skills')
    knowledge_level = user_data.get('knowledge_level', 'Beginner')
    study_plan = create_study_plan(topic, time_available, goals, knowledge_level)
    
    # Save the generated study plan to the session
    if 'study_plans' not in user_data:
        user_data['study_plans'] = {}
    
    study_plan_id = f"{topic}_{time_available}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
    user_data['study_plans'][study_plan_id] = {
        'topic': topic,
        'time_available': time_available,
        'plan': study_plan,
        'created_at': datetime.now().isoformat()
    }
    save_session(session_id, user_data)
    
    return study_plan

def add_generative_ai_info():
    """Return information about Generative AI"""
    return """
    ## What is Generative AI?
    
    Generative AI refers to artificial intelligence systems that can create new content, such as text, images, code, audio, video, or 3D models. Unlike traditional AI systems that are designed to recognize patterns or make predictions, generative AI creates original outputs based on the patterns it has learned during training.
    
    ### Key Concepts in Generative AI:
    
    - **Large Language Models (LLMs)**: Text generation systems like GPT-4, LLaMA, Claude, etc.
    - **Diffusion Models**: For image generation (DALL-E, Midjourney, Stable Diffusion)
    - **Prompt Engineering**: The art of crafting inputs to get desired outputs
    - **Fine-tuning**: Adapting pre-trained models for specific domains or tasks
    - **RLHF (Reinforcement Learning from Human Feedback)**: Method for aligning AI with human preferences
    
    Learning generative AI involves understanding these foundation models, how they work, and how to effectively use and customize them for various applications.
    """

def add_agentic_ai_info():
    """Return information about Agentic AI"""
    return """
    ## What is Agentic AI?
    
    Agentic AI refers to AI systems that can act autonomously to achieve specified goals. Unlike passive AI systems that respond only when prompted, agentic AI can take initiative, make decisions, use tools, and perform sequences of actions to accomplish tasks.
    
    ### Key Concepts in Agentic AI:
    
    - **Planning & Decision Making**: AI systems that can formulate and execute plans
    - **Tool Use**: AI that can leverage external tools and APIs
    - **Autonomous Execution**: Systems that can work without constant human supervision
    - **Multi-agent Systems**: Multiple AI agents collaborating or competing
    - **Memory & Context Management**: How agents maintain state across interactions
    
    Agentic AI represents an evolution from AI as a passive tool to AI as an active collaborator that can work independently while remaining aligned with human goals and values.
    """

def create_chatbot():
    """Create the Gradio interface for the chatbot"""
    # Generate a random session ID for the user
    session_id = str(uuid.uuid4())
    
    # Define theme colors and styling
    primary_color = "#4a6fa5"
    secondary_color = "#6c757d"
    success_color = "#28a745"
    light_color = "#f8f9fa"
    dark_color = "#343a40"
    
    custom_css = f"""
        :root {{
            --primary-color: {primary_color};
            --secondary-color: {secondary_color};
            --success-color: {success_color};
            --light-color: {light_color};
            --dark-color: {dark_color};
        }}
        .gradio-container {{ 
            background-color: var(--light-color); 
            font-family: 'Inter', 'Segoe UI', sans-serif; 
        }}
        #title {{ 
            font-size: 32px; 
            font-weight: bold; 
            text-align: center; 
            padding-top: 20px; 
            color: var(--primary-color);
            margin-bottom: 0;
        }}
        #subtitle {{ 
            font-size: 18px; 
            text-align: center; 
            margin-bottom: 20px; 
            color: var(--secondary-color); 
        }}
        .card {{
            background-color: white;
            padding: 20px;
            border-radius: 12px;
            box-shadow: 0 4px 10px rgba(0,0,0,0.08);
            margin-bottom: 20px;
        }}
        .tabs {{
            margin-top: 20px;
        }}
        .gr-button-primary {{ 
            background-color: var(--primary-color) !important; 
        }}
        .gr-button-secondary {{ 
            background-color: var(--secondary-color) !important; 
        }}
        .gr-button-success {{ 
            background-color: var(--success-color) !important; 
        }}
        .footer {{
            text-align: center;
            margin-top: 30px;
            padding: 10px;
            font-size: 14px;
            color: var(--secondary-color);
        }}
        .progress-module {{
            padding: 10px;
            margin: 5px 0;
            border-radius: 5px;
            background-color: #e9ecef;
        }}
        .progress-module.completed {{
            background-color: #d4edda;
        }}
        .info-box {{
            background-color: #e7f5fe;
            border-left: 4px solid var(--primary-color);
            padding: 15px;
            margin: 15px 0;
            border-radius: 4px;
        }}
    """
    
    with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="blue")) as demo:
        gr.HTML("<div id='title'>🎓 AI Teaching Assistant</div>")
        gr.HTML("<div id='subtitle'>Your personalized learning companion for Python, Data Science & AI</div>")
        
        # Tabs for different sections
        with gr.Tabs(elem_classes=["tabs"]) as tabs:
            # Profile Tab
            with gr.Tab("Profile & Goals"):
                with gr.Column(elem_classes=["card"]):
                    gr.HTML("<h3>Complete Your Learning Profile</h3>")
                    
                    with gr.Row():
                        with gr.Column(scale=1):
                            age_input = gr.Textbox(
                                label="Age", 
                                placeholder="e.g. 20",
                                lines=1
                            )
                        with gr.Column(scale=2):
                            knowledge_level_input = gr.Dropdown(
                                choices=["Beginner", "Intermediate", "Advanced", "Expert"],
                                label="Knowledge Level",
                                value="Beginner"
                            )
                    
                    goals_input = gr.Textbox(
                        label="Learning Goals", 
                        placeholder="e.g. I want to become a data scientist and work with machine learning models",
                        lines=2
                    )
                    
                    interests_input = gr.Textbox(
                        label="Specific Interests", 
                        placeholder="e.g. Python, data visualization, neural networks",
                        lines=2
                    )
                    
                    with gr.Row():
                        with gr.Column(scale=1):
                            study_time_input = gr.Dropdown(
                                choices=["1-3", "4-6", "7-10", "10+"],
                                label="Hours Available Weekly",
                                value="4-6"
                            )
                        with gr.Column(scale=2):
                            learning_style_input = gr.Dropdown(
                                choices=["Visual", "Reading/Writing", "Hands-on Projects", "Video Tutorials", "Interactive Exercises", "Combination"],
                                label="Preferred Learning Style",
                                value="Combination"
                            )
                    
                    profile_submit_btn = gr.Button("Save Profile & Generate Recommendations", variant="primary")
                    profile_output = gr.Markdown(label="Personalized Recommendations")
            
            # Chat Tab
            with gr.Tab("Learning Assistant"):
                with gr.Row():
                    with gr.Column(elem_classes=["card"]):
                        chat_input = gr.Textbox(
                            label="Ask a Question",
                            placeholder="Ask anything about Python, Data Science, AI...",
                            lines=3
                        )
                        
                        with gr.Row():
                            chat_submit_btn = gr.Button("Send Message", variant="primary")
                            chat_clear_btn = gr.Button("Clear Chat", variant="secondary")
                        
                        chat_output = gr.Markdown(label="Assistant Response")
            
            # Resources Tab
            with gr.Tab("Resources & Recommendations"):
                with gr.Column(elem_classes=["card"]):
                    gr.HTML("<h3>Your Learning Resources</h3>")
                    refresh_recommendations_btn = gr.Button("Refresh Recommendations", variant="primary")
                    recommendations_output = gr.Markdown(label="Personalized Recommendations")
            
            # Practice Tab
            with gr.Tab("Practice & Assessment"):
                with gr.Column(elem_classes=["card"]):
                    gr.HTML("<h3>Generate a Quiz</h3>")
                    
                    with gr.Row():
                        quiz_topic_input = gr.Textbox(
                            label="Quiz Topic", 
                            placeholder="e.g. Python Lists",
                            lines=1
                        )
                        quiz_difficulty_input = gr.Dropdown(
                            choices=["Beginner", "Intermediate", "Advanced"],
                            label="Difficulty Level",
                            value="Beginner"
                        )
                    
                    generate_quiz_btn = gr.Button("Generate Quiz", variant="primary")
                    quiz_output = gr.Markdown(label="Quiz")
            
            # Study Plan Tab
            with gr.Tab("Study Plan"):
                with gr.Column(elem_classes=["card"]):
                    gr.HTML("<h3>Generate a Personalized Study Plan</h3>")
                    
                    with gr.Row():
                        plan_topic_input = gr.Textbox(
                            label="Study Topic", 
                            placeholder="e.g. Data Science",
                            lines=1
                        )
                        plan_time_input = gr.Dropdown(
                            choices=["1-3", "4-6", "7-10", "10+"],
                            label="Hours Available Weekly",
                            value="4-6"
                        )
                    
                    generate_plan_btn = gr.Button("Generate Study Plan", variant="primary")
                    plan_output = gr.Markdown(label="Personalized Study Plan")
        
        gr.HTML("""<div class="footer">
            AI Teaching Assistant | Version 2.0 | © 2025 | Powered by Groq AI
        </div>""")
        
        # Event handlers
        profile_submit_btn.click(
            user_onboarding,
            inputs=[
                gr.State(session_id), 
                age_input, 
                goals_input, 
                knowledge_level_input,
                interests_input,
                study_time_input,
                learning_style_input
            ],
            outputs=profile_output
        )
        
        chat_submit_btn.click(
            chatbot_interface,
            inputs=[gr.State(session_id), chat_input],
            outputs=chat_output
        )
        
        chat_clear_btn.click(
            lambda: "",
            inputs=[],
            outputs=[chat_output, chat_input]
        )
        
        refresh_recommendations_btn.click(
            generate_recommendations,
            inputs=[gr.State(session_id)],
            outputs=recommendations_output
        )
        
        generate_quiz_btn.click(
            handle_quiz_request,
            inputs=[gr.State(session_id), quiz_topic_input, quiz_difficulty_input],
            outputs=quiz_output
        )
        
        generate_plan_btn.click(
            handle_study_plan_request,
            inputs=[gr.State(session_id), plan_topic_input, plan_time_input],
            outputs=plan_output
        )
    
    return demo

# Run the chatbot
if __name__ == "__main__":
    app = create_chatbot()
    app.launch()