app.py

# -*- coding: utf-8 -*-
"""app.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1e_M_kKgA4L3dmmiCjbOrNT3hBfnny_9P

#Core system
"""

# core_system.py - Modified with fixed exam functionality

import os
import json
import datetime
import time
from datetime import timedelta
from typing import List, Dict, Any, Optional

# LLM Integration using LangChain
class LLMService:
    def __init__(self, api_key):
        self.api_key = api_key
        # Changed from ChatOpenAI to ChatGroq
        try:
            from langchain_groq import ChatGroq
            self.chat_model = ChatGroq(
                model="llama3-70b-8192",  # Using a Groq compatible model
                temperature=0.2,
                groq_api_key=api_key
            )
        except ImportError:
            # Fallback to direct API calls if langchain_groq is not available
            import requests
            self.chat_model = None

    def create_chain(self, template: str, output_key: str = "result"):
        if self.chat_model:
            from langchain.prompts import ChatPromptTemplate
            from langchain.chains import LLMChain

            chat_prompt = ChatPromptTemplate.from_template(template)
            return LLMChain(
                llm=self.chat_model,
                prompt=chat_prompt,
                output_key=output_key,
                verbose=True
            )
        return None

    def get_completion(self, prompt: str) -> str:
        if self.chat_model:
            chain = self.create_chain(prompt)
            response = chain.invoke({"input": ""})
            return response["result"]
        else:
            # Direct API call if langchain is not available
            import requests
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            data = {
                "model": "llama3-70b-8192",
                "messages": [{"role": "user", "content": prompt}],
                "temperature": 0.7,
                "max_tokens": 2048
            }
            response = requests.post(
                "https://api.groq.com/openai/v1/chat/completions",
                headers=headers,
                json=data
            )

            if response.status_code == 200:
                return response.json()["choices"][0]["message"]["content"]
            else:
                raise Exception(f"API Error: {response.status_code} - {response.text}")

    def generate_module_content(self, day: int, topic: str) -> str:
        prompt = f"""
        Create a comprehensive Python programming module for Day {day} covering {topic}.
        The module should follow this structure in Markdown format:

        # [Module Title]

        ## Introduction
        [A brief introduction to the day's topics]

        ## Section 1: [Section Title]
        [Detailed explanation of concepts]

        ### Code Examples
        ```python
        # Example code with comments
        ```

        ### Practice Exercises
        [2-3 exercises with clear instructions]

        ## Section 2: [Section Title]
        [Repeat the pattern for all relevant topics]

        Make sure the content is:
        - Comprehensive but focused on the day's topic
        - Includes clear examples with comments
        - Has practice exercises that build skills progressively
        - Uses proper Markdown formatting
        """
        return self.get_completion(prompt)

    def generate_exam_questions(self, day: int, topic: str, previous_mistakes: List[Dict] = None) -> List[Dict]:
        mistake_context = ""
        if previous_mistakes and len(previous_mistakes) > 0:
            mistakes = "\n".join([
                f"- Question: {m['question']}\n  Wrong Answer: {m['user_answer']}\n  Correct Answer: {m['correct_answer']}"
                for m in previous_mistakes[:3]
            ])
            mistake_context = f"""
            Include variations of questions related to these previous mistakes:
            {mistakes}
            """

        prompt = f"""
        Create a 1-hour Python exam for Day {day} covering {topic}.
        {mistake_context}

        Include 5 questions with a mix of:
        - Multiple-choice (4 options each)
        - Short-answer (requiring 1-3 lines of text)
        - Coding exercises (simple functions or snippets)

        Return your response as a JSON array where each question is an object with these fields:
        - question_type: "multiple-choice", "short-answer", or "coding"
        - question_text: The full question text
        - options: Array of options (for multiple-choice only)
        - correct_answer: The correct answer or solution
        - explanation: Detailed explanation of the correct answer
        - difficulty: Number from 1 (easiest) to 5 (hardest)

        Example:
        [
          {{
            "question_type": "multiple-choice",
            "question_text": "What is the output of print(3 * '4' + '5')?",
            "options": ["12", "445", "4445", "Error"],
            "correct_answer": "4445",
            "explanation": "The * operator with a string repeats it, and + concatenates strings",
            "difficulty": 2
          }},
          {{
            "question_type": "coding",
            "question_text": "Write a function that returns the sum of all even numbers in a list.",
            "options": null,
            "correct_answer": "def sum_even(numbers):\\n    return sum(x for x in numbers if x % 2 == 0)",
            "explanation": "This solution uses a generator expression with the sum function to add only even numbers",
            "difficulty": 3
          }}
        ]

        ONLY return the valid JSON array. Do NOT include any explanatory text or code fences.
        """

        result = self.get_completion(prompt)

        # Clean up potential formatting issues
        result = result.strip()
        if result.startswith("```json"):
            result = result.split("```json")[1]
        if result.endswith("```"):
            result = result.rsplit("```", 1)[0]

        try:
            return json.loads(result)
        except json.JSONDecodeError as e:
            print(f"JSON decode error: {e}")
            print(f"Raw response: {result}")
            # Fall back to creating a minimal structure
            return [{"question_type": "short-answer",
                     "question_text": "There was an error generating questions. Please describe what you've learned today.",
                     "options": None,
                     "correct_answer": "Any reasonable summary",
                     "explanation": "This is a backup question",
                     "difficulty": 1}]

    def evaluate_answer(self, question: Dict, user_answer: str) -> Dict:
        prompt = f"""
        Grade this response to a Python programming question:

        Question Type: {question["question_type"]}
        Question: {question["question_text"]}
        Correct Answer: {question["correct_answer"]}
        Student's Answer: {user_answer}

        Return your evaluation as a JSON object with these fields:
        - is_correct: boolean (true/false)
        - feedback: detailed explanation of what was correct/incorrect
        - correct_solution: the correct solution with explanation if the answer was wrong

        For coding questions, be somewhat lenient - focus on logic correctness rather than exact syntax matching.
        For multiple choice, it must match the correct option.
        For short answer, assess if the key concepts are present and correct.

        ONLY return the valid JSON object. Do NOT include any explanatory text.
        """

        result = self.get_completion(prompt)

        # Clean up potential formatting issues
        result = result.strip()
        if result.startswith("```json"):
            result = result.split("```json")[1]
        if result.endswith("```"):
            result = result.rsplit("```", 1)[0]

        try:
            return json.loads(result)
        except json.JSONDecodeError as e:
            print(f"JSON decode error: {e}")
            print(f"Raw response: {result}")
            # Return a fallback response
            return {
                "is_correct": False,
                "feedback": "There was an error evaluating your answer. Please try again.",
                "correct_solution": question["correct_answer"]
            }

    def answer_student_question(self, question: str, context: Optional[str] = None) -> str:
        context_text = f"Context from previous questions: {context}\n\n" if context else ""

        prompt = f"""
        {context_text}You are an expert Python tutor. Answer this student's question clearly with explanations and examples:

        {question}

        - Use code examples where appropriate
        - Break down complex concepts step by step
        - Be comprehensive but concise
        - Use proper Markdown formatting for code
        """

        return self.get_completion(prompt)

# Content Generator with simplified storage
class ContentGenerator:
    def __init__(self, api_key):
        self.llm_service = LLMService(api_key)
        # Simplified in-memory storage
        self.modules = []
        self.questions = []
        self.responses = []
        self.chat_logs = []

    def generate_module(self, day: int) -> tuple:
        day_topics = {
            1: "Python fundamentals (variables, data types, control structures)",
            2: "Intermediate Python (functions, modules, error handling)",
            3: "Advanced Python (file I/O, object-oriented programming, key libraries)"
        }
        topic = day_topics.get(day, "Python programming")

        content = self.llm_service.generate_module_content(day, topic)

        # Extract title from content
        title = f"Day {day} Python Module"
        if content.startswith("# "):
            title_line = content.split("\n", 1)[0]
            title = title_line.replace("# ", "").strip()

        # Save to in-memory storage
        module_id = len(self.modules) + 1
        self.modules.append({
            "id": module_id,
            "day": day,
            "title": title,
            "content": content,
            "created_at": datetime.datetime.utcnow()
        })

        return content, module_id

    def generate_exam(self, day: int, module_id: int, previous_mistakes: List = None) -> tuple:
        day_topics = {
            1: "Python fundamentals (variables, data types, control structures)",
            2: "Intermediate Python (functions, modules, error handling)",
            3: "Advanced Python (file I/O, object-oriented programming, key libraries)"
        }
        topic = day_topics.get(day, "Python programming")

        # Generate questions for this day's topics
        try:
            questions_data = self.llm_service.generate_exam_questions(day, topic, previous_mistakes)

            if not questions_data:
                raise ValueError("Failed to generate exam questions")

            saved_questions = []
            for q_data in questions_data:
                question_id = len(self.questions) + 1

                question = {
                    "id": question_id,
                    "module_id": module_id,
                    "question_type": q_data["question_type"],
                    "question_text": q_data["question_text"],
                    "options": q_data.get("options"),
                    "correct_answer": q_data["correct_answer"],
                    "explanation": q_data["explanation"],
                    "difficulty": q_data.get("difficulty", 3)
                }

                self.questions.append(question)
                saved_questions.append(question)

            return questions_data, saved_questions
        except Exception as e:
            print(f"Error generating exam: {str(e)}")
            # Create a simple fallback question
            fallback_question = {
                "question_type": "short-answer",
                "question_text": f"Explain a key concept you learned in Day {day} about {topic}.",
                "options": None,
                "correct_answer": "Any reasonable explanation",
                "explanation": "This is a fallback question due to an error in question generation",
                "difficulty": 2
            }

            question_id = len(self.questions) + 1
            question = {
                "id": question_id,
                "module_id": module_id,
                "question_type": fallback_question["question_type"],
                "question_text": fallback_question["question_text"],
                "options": fallback_question.get("options"),
                "correct_answer": fallback_question["correct_answer"],
                "explanation": fallback_question["explanation"],
                "difficulty": fallback_question["difficulty"]
            }

            self.questions.append(question)
            return [fallback_question], [question]

    def grade_response(self, question_id: int, user_answer: str) -> Dict:
        # Find question in memory
        question = next((q for q in self.questions if q["id"] == question_id), None)

        if not question:
            return {"error": "Question not found"}

        try:
            feedback_data = self.llm_service.evaluate_answer(question, user_answer)

            # Save response to in-memory storage
            response_id = len(self.responses) + 1
            response = {
                "id": response_id,
                "question_id": question_id,
                "user_answer": user_answer,
                "is_correct": feedback_data.get("is_correct", False),
                "feedback": feedback_data.get("feedback", ""),
                "timestamp": datetime.datetime.utcnow()
            }
            self.responses.append(response)

            return feedback_data
        except Exception as e:
            print(f"Error grading response: {str(e)}")
            # Create a fallback response
            response_id = len(self.responses) + 1
            response = {
                "id": response_id,
                "question_id": question_id,
                "user_answer": user_answer,
                "is_correct": False,
                "feedback": f"Error evaluating answer: {str(e)}",
                "timestamp": datetime.datetime.utcnow()
            }
            self.responses.append(response)

            return {
                "is_correct": False,
                "feedback": f"Error evaluating answer: {str(e)}",
                "correct_solution": question["correct_answer"]
            }

    def get_previous_mistakes(self, day: int) -> List:
        """Get mistakes from previous days to inform adaptive content"""
        if day <= 1:
            return []

        previous_day = day - 1

        # Find modules from previous day
        previous_modules = [m for m in self.modules if m["day"] == previous_day]

        if not previous_modules:
            return []

        module_ids = [module["id"] for module in previous_modules]
        questions = [q for q in self.questions if q["module_id"] in module_ids]

        if not questions:
            return []

        question_ids = [question["id"] for question in questions]
        incorrect_responses = [r for r in self.responses if r["question_id"] in question_ids and not r["is_correct"]]

        mistakes = []
        for response in incorrect_responses:
            question = next((q for q in self.questions if q["id"] == response["question_id"]), None)
            if question:
                mistakes.append({
                    "question": question["question_text"],
                    "user_answer": response["user_answer"],
                    "correct_answer": question["correct_answer"]
                })

        return mistakes

    def answer_question(self, user_question: str, related_question_id: Optional[int] = None) -> str:
        # Get context from related question if available
        context = None
        if related_question_id:
            question = next((q for q in self.questions if q["id"] == related_question_id), None)
            if question:
                context = f"Question: {question['question_text']}\nCorrect Answer: {question['correct_answer']}\nExplanation: {question['explanation']}"

        response = self.llm_service.answer_student_question(user_question, context)

        # Log the interaction
        chat_log_id = len(self.chat_logs) + 1
        chat_log = {
            "id": chat_log_id,
            "user_question": user_question,
            "ai_response": response,
            "related_question_id": related_question_id,
            "timestamp": datetime.datetime.utcnow()
        }
        self.chat_logs.append(chat_log)

        return response

# Learning System Class
class LearningSystem:
    def __init__(self, api_key):
        self.content_generator = ContentGenerator(api_key)
        self.current_day = 1
        self.current_module_id = None
        self.exam_start_time = None
        self.exam_in_progress = False
        self.exam_questions = []
        self.questions_data = []  # Store the questions data for display

    def generate_day_content(self):
        content, module_id = self.content_generator.generate_module(self.current_day)
        self.current_module_id = module_id
        return content

    def start_exam(self):
        try:
            if not self.current_module_id:
                # Check if we already have a module for this day
                existing_module = next((m for m in self.content_generator.modules if m["day"] == self.current_day), None)
                if existing_module:
                    self.current_module_id = existing_module["id"]
                else:
                    # Generate content for the day if not already done
                    content, module_id = self.content_generator.generate_module(self.current_day)
                    self.current_module_id = module_id

            # Get previous mistakes for adaptive learning
            previous_mistakes = self.content_generator.get_previous_mistakes(self.current_day)

            # Generate exam questions
            self.questions_data, self.exam_questions = self.content_generator.generate_exam(
                self.current_day,
                self.current_module_id,
                previous_mistakes
            )

            if not self.questions_data or not self.exam_questions:
                return "Failed to generate exam questions. Please try again."

            self.exam_start_time = datetime.datetime.now()
            self.exam_in_progress = True

            # Format the exam for display
            exam_text = f"# Day {self.current_day} Python Exam\n\n"
            exam_text += f"**Time Limit:** 1 hour\n"
            exam_text += f"**Start Time:** {self.exam_start_time.strftime('%H:%M:%S')}\n"
            exam_text += f"**End Time:** {(self.exam_start_time + timedelta(hours=1)).strftime('%H:%M:%S')}\n\n"

            # Add adaptive learning notice if applicable
            if previous_mistakes and len(previous_mistakes) > 0:
                exam_text += f"**Note:** This exam includes questions based on topics you had difficulty with previously.\n\n"

            for i, question in enumerate(self.questions_data):
                exam_text += f"## Question {i+1}: {question['question_type'].title()}\n\n"
                exam_text += f"{question['question_text']}\n\n"

                if question['question_type'] == "multiple-choice" and question.get('options'):
                    for j, option in enumerate(question['options']):
                        exam_text += f"- {chr(65+j)}. {option}\n"

                exam_text += "\n"

            exam_text += "## Instructions for submitting answers:\n\n"
            exam_text += "1. For multiple-choice questions, input the letter of your answer (A, B, C, or D)\n"
            exam_text += "2. For short-answer questions, write your complete answer\n"
            exam_text += "3. For coding questions, write your complete code solution\n"
            exam_text += "4. **Separate each answer with two line breaks**\n\n"

            return exam_text
        except Exception as e:
            self.exam_in_progress = False
            return f"Error starting exam: {str(e)}"

    def submit_exam(self, answers_text):
        try:
            if not self.exam_in_progress:
                return "No exam is currently in progress. Please start an exam first."

            if not self.exam_questions:
                return "No exam questions available. Please restart the exam."

            # Check time
            current_time = datetime.datetime.now()
            if current_time > self.exam_start_time + timedelta(hours=1):
                time_overrun = current_time - (self.exam_start_time + timedelta(hours=1))
                overrun_minutes = time_overrun.total_seconds() / 60
                time_notice = f"Time limit exceeded by {overrun_minutes:.1f} minutes. Your answers are being processed anyway."
            else:
                time_notice = "Exam completed within the time limit."

            # Split answers by question (double newline separator)
            answers = [ans.strip() for ans in answers_text.split("\n\n") if ans.strip()]

            feedback_text = f"# Day {self.current_day} Exam Results\n\n"
            feedback_text += f"{time_notice}\n\n"

            correct_count = 0
            total_evaluated = 0

            # Ensure we don't exceed the number of questions
            num_questions = min(len(self.exam_questions), len(answers))

            # If the user provided fewer answers than questions, fill in blanks
            while len(answers) < len(self.exam_questions):
                answers.append("")

            for i in range(len(self.exam_questions)):
                question = self.exam_questions[i]
                answer = answers[i] if i < len(answers) else ""

                # Handle empty answers
                if not answer:
                    feedback_text += f"## Question {i+1}\n\n"
                    feedback_text += "**Your Answer:** No answer provided\n\n"
                    feedback_text += "**Result:** Incorrect\n\n"
                    feedback_text += f"**Correct Solution:** {question['correct_answer']}\n\n"
                    total_evaluated += 1
                    continue

                try:
                    # Grade the response
                    feedback = self.content_generator.grade_response(question["id"], answer)
                    total_evaluated += 1

                    # Format feedback
                    feedback_text += f"## Question {i+1}\n\n"
                    feedback_text += f"**Your Answer:**\n{answer}\n\n"
                    feedback_text += f"**Result:** {'✅ Correct' if feedback.get('is_correct', False) else '❌ Incorrect'}\n\n"
                    feedback_text += f"**Feedback:**\n{feedback.get('feedback', '')}\n\n"

                    if feedback.get('is_correct', False):
                        correct_count += 1
                    else:
                        feedback_text += f"**Correct Solution:**\n{feedback.get('correct_solution', '')}\n\n"
                except Exception as e:
                    feedback_text += f"## Question {i+1}\n\n"
                    feedback_text += f"**Error grading answer:** {str(e)}\n\n"

            # Calculate score
            if total_evaluated > 0:
                score = correct_count / total_evaluated * 100
            else:
                score = 0

            feedback_text += f"# Final Score: {score:.1f}%\n\n"

            # Suggestions for improvement
            if score < 100:
                feedback_text += "## Suggestions for Improvement\n\n"
                if score < 60:
                    feedback_text += "- Review the fundamental concepts again\n"
                    feedback_text += "- Practice more with the code examples\n"
                    feedback_text += "- Use the Q&A Sandbox to ask about difficult topics\n"
                elif score < 80:
                    feedback_text += "- Focus on the specific areas where you made mistakes\n"
                    feedback_text += "- Try rewriting the solutions for incorrect answers\n"
                else:
                    feedback_text += "- Great job! Just a few minor issues to review\n"
                    feedback_text += "- Look at the explanations for the few questions you missed\n"
            else:
                feedback_text += "## Excellent Work!\n\n"
                feedback_text += "You've mastered today's content. Ready for the next day's material!\n"

            self.exam_in_progress = False
            return feedback_text
        except Exception as e:
            self.exam_in_progress = False
            return f"Error submitting exam: {str(e)}"

    def answer_sandbox_question(self, question):
        return self.content_generator.answer_question(question)

    def advance_to_next_day(self):
        if self.current_day < 3:
            self.current_day += 1
            self.current_module_id = None
            self.exam_questions = []
            return f"Advanced to Day {self.current_day}."
        else:
            return "You have completed the 3-day curriculum."

    def get_learning_progress(self):
        try:
            modules = self.content_generator.modules
            questions = self.content_generator.questions
            responses = self.content_generator.responses

            total_questions = len(questions)
            answered_questions = len(responses)
            correct_answers = sum(1 for r in responses if r["is_correct"])

            if answered_questions > 0:
                accuracy = correct_answers / answered_questions * 100
            else:
                accuracy = 0

            report = "# Learning Progress Summary\n\n"
            report += f"## Overall Statistics\n"
            report += f"- Total modules completed: {len(modules)}\n"
            report += f"- Total questions attempted: {answered_questions}/{total_questions}\n"
            report += f"- Overall accuracy: {accuracy:.1f}%\n\n"

            # Day-by-day progress with adaptive learning info
            for day in range(1, 4):
                day_modules = [m for m in modules if m["day"] == day]

                report += f"## Day {day}: "
                if day_modules:
                    report += f"{day_modules[0]['title']}\n"

                    day_questions = [q for q in questions if q["module_id"] in [m["id"] for m in day_modules]]
                    day_responses = [r for r in responses if r["question_id"] in [q["id"] for q in day_questions]]

                    day_total = len(day_questions)
                    day_answered = len(day_responses)
                    day_correct = sum(1 for r in day_responses if r["is_correct"])

                    if day_answered > 0:
                        day_accuracy = day_correct / day_answered * 100
                        report += f"- **Exam Score:** {day_accuracy:.1f}%\n"
                    else:
                        report += "- **Exam:** Not taken yet\n"

                    report += f"- Questions attempted: {day_answered}/{day_total}\n"

                    # Show adaptive learning details
                    if day > 1:
                        previous_mistakes = self.content_generator.get_previous_mistakes(day)
                        if previous_mistakes:
                            report += f"- **Adaptive Learning:** {len(previous_mistakes)} topics from Day {day-1} reinforced\n"

                    # Show exam results if available
                    if day_answered > 0:
                        report += "### Exam Performance\n"

                        # Group by question type
                        question_types = set(q["question_type"] for q in day_questions)
                        for q_type in question_types:
                            type_questions = [q for q in day_questions if q["question_type"] == q_type]
                            type_responses = [r for r in day_responses if r["question_id"] in [q["id"] for q in type_questions]]
                            type_correct = sum(1 for r in type_responses if r["is_correct"])

                            if type_responses:
                                type_accuracy = type_correct / len(type_responses) * 100
                                report += f"- **{q_type.title()}:** {type_accuracy:.1f}% correct\n"

                        # Common mistakes
                        incorrect_responses = [r for r in day_responses if not r["is_correct"]]
                        if incorrect_responses:
                            report += "\n### Areas for Improvement\n"

                            for resp in incorrect_responses[:3]:  # Show top 3 mistakes
                                question = next((q for q in questions if q["id"] == resp["question_id"]), None)
                                if question:
                                    report += f"- **Question:** {question['question_text'][:100]}...\n"
                                    report += f"  **Your Answer:** {resp['user_answer'][:100]}...\n"
                                    report += f"  **Correct Answer:** {question['correct_answer'][:100]}...\n\n"
                else:
                    report += "Not started yet\n"

                report += "\n"

            # Learning recommendations
            report += "## Recommendations\n\n"
            if correct_answers < answered_questions * 0.7:
                report += "- Review the modules before moving to the next day\n"
                report += "- Focus on practicing code examples\n"
                report += "- Use the Q&A Sandbox to clarify difficult concepts\n"
            else:
                report += "- Continue with the current pace\n"
                report += "- Try to implement small projects using what you've learned\n"

            return report
        except Exception as e:
            return f"Error generating progress report: {str(e)}"

"""#gradio"""

# Gradio UI - Modified for Google Colab
import os
import gradio as gr

# Note: We're not importing from core_system
# Instead, we'll use the classes already defined in the previous cell

def create_interface():
    # System initialization section
    def initialize_system(api_key_value):
        if not api_key_value or len(api_key_value) < 10:  # Basic validation
            return "Please enter a valid API key.", gr.update(visible=False), None

        try:
            # Test API connection
            test_service = LLMService(api_key_value)
            test_response = test_service.get_completion("Say hello")

            if len(test_response) > 0:
                learning_system = LearningSystem(api_key_value)
                return "✅ System initialized successfully! You can now use the learning system.", gr.update(visible=True), learning_system
            else:
                return "❌ API connection test failed. Please check your API key.", gr.update(visible=False), None
        except Exception as e:
            return f"❌ Error initializing system: {str(e)}", gr.update(visible=False), None

    with gr.Blocks(title="AI-Powered Python Learning System", theme="soft") as interface:
        # Store learning system state
        learning_system_state = gr.State(None)

        # Header
        gr.Markdown(
            """
            <div style="text-align: center; margin-bottom: 20px;">
                <h1 style="color: #4a69bd; font-size: 2.5em;">AI-Powered Python Learning System</h1>
                <p style="font-size: 1.2em; color: #444;">Master Python programming with personalized AI tutoring</p>
            </div>
            """
        )

        # API Key input - outside the tabs
        with gr.Row():
            # Try to get API key from environment variable
            API_KEY = os.environ.get("GROQ_API_KEY", "")
            api_key_input = gr.Textbox(
                label="Enter your Groq API Key",
                placeholder="gsk_...",
                type="password",
                value=API_KEY  # Use environment variable if available
            )
            init_btn = gr.Button("Initialize System", variant="primary")

        init_status = gr.Markdown("Enter your Groq API key and click 'Initialize System' to begin.")

        # Main interface container - hidden until initialized
        with gr.Column(visible=False) as main_interface:
            with gr.Tabs() as tabs:
                # Content & Learning tab
                with gr.Tab("Content & Learning"):
                    with gr.Row():
                        day_display = gr.Markdown("## Current Day: 1")

                    with gr.Row():
                        generate_content_btn = gr.Button("Generate Today's Content", variant="primary")
                        next_day_btn = gr.Button("Advance to Next Day", variant="secondary")

                    content_display = gr.Markdown("Click 'Generate Today's Content' to begin.")

                # Exam tab
                with gr.Tab("Exam"):
                    with gr.Row():
                        start_exam_btn = gr.Button("Start Exam", variant="primary")

                    exam_display = gr.Markdown("Click 'Start Exam' to begin the assessment.")

                    with gr.Row():
                        exam_answers = gr.Textbox(
                            label="Enter your answers (separate each answer with two line breaks)",
                            placeholder="Answer 1\n\nAnswer 2\n\nAnswer 3...",
                            lines=15
                        )

                    submit_exam_btn = gr.Button("Submit Exam", variant="primary")

                    exam_feedback = gr.Markdown("Your exam results will appear here.")

                # Q&A Sandbox tab
                with gr.Tab("Q&A Sandbox"):
                    with gr.Row():
                        question_input = gr.Textbox(
                            label="Ask any question about Python",
                            placeholder="Enter your question here...",
                            lines=3
                        )

                    ask_btn = gr.Button("Ask Question", variant="primary")

                    answer_display = gr.Markdown("Ask a question to get started.")

                # Progress Report tab
                with gr.Tab("Progress Report"):
                    with gr.Row():
                        report_btn = gr.Button("Generate Progress Report", variant="primary")

                    progress_display = gr.Markdown("Click 'Generate Progress Report' to see your learning statistics.")

        # Custom functions to handle state
        def generate_content(learning_system):
            if not learning_system:
                return "Please initialize the system first."
            return learning_system.generate_day_content()

        def advance_day(learning_system):
            if not learning_system:
                return "Please initialize the system first.", "## Current Day: 1"
            result = learning_system.advance_to_next_day()
            return result, f"## Current Day: {learning_system.current_day}"

        def start_exam(learning_system):
            if not learning_system:
                return "Please initialize the system first."
            try:
                exam_content = learning_system.start_exam()
                return exam_content
            except Exception as e:
                return f"Error starting exam: {str(e)}"

        def submit_exam(learning_system, answers):
            if not learning_system:
                return "Please initialize the system first."
            if not answers.strip():
                return "Please provide answers before submitting."

            try:
                feedback = learning_system.submit_exam(answers)
                return feedback
            except Exception as e:
                return f"Error evaluating exam: {str(e)}"

        def ask_question(learning_system, question):
            if not learning_system:
                return "Please initialize the system first."
            if not question.strip():
                return "Please enter a question."

            try:
                answer = learning_system.answer_sandbox_question(question)
                return answer
            except Exception as e:
                return f"Error processing question: {str(e)}"

        def generate_progress_report(learning_system):
            if not learning_system:
                return "Please initialize the system first."

            try:
                report = learning_system.get_learning_progress()
                return report
            except Exception as e:
                return f"Error generating progress report: {str(e)}"

        # Set up event handlers
        init_btn.click(
            initialize_system,
            inputs=[api_key_input],
            outputs=[init_status, main_interface, learning_system_state]
        )

        generate_content_btn.click(
            generate_content,
            inputs=[learning_system_state],
            outputs=[content_display]
        )

        next_day_btn.click(
            advance_day,
            inputs=[learning_system_state],
            outputs=[content_display, day_display]
        )

        start_exam_btn.click(
            start_exam,
            inputs=[learning_system_state],
            outputs=[exam_display]
        )

        submit_exam_btn.click(
            submit_exam,
            inputs=[learning_system_state, exam_answers],
            outputs=[exam_feedback]
        )

        ask_btn.click(
            ask_question,
            inputs=[learning_system_state, question_input],
            outputs=[answer_display]
        )

        report_btn.click(
            generate_progress_report,
            inputs=[learning_system_state],
            outputs=[progress_display]
        )

    return interface

# Create and launch the interface
# For Colab, make sure to install gradio first if you haven't
# !pip install gradio
interface = create_interface()
interface.launch(share=True)