Update app.py

app.py

@@ -38,6 +38,75 @@ client = openai.OpenAI(
     api_key=api_key,
 )
 
+### --- DATA: FULL 6-MODULE CURRICULUM (EXPANDED) --- ###
+curriculum = [
+    # MODULE 1: Variables
+    {"module": "Mastering Variables", "title": "Lesson 1: What is a Variable?", "explanation": "In programming, a **variable** is a named container that holds a value. Think of it like a labeled box where you can store a piece of information, like a number or a piece of text. You can then refer to the information by the box's label.\n\n**Example:**\n```python\n# Here, 'city' is the variable, and 'Jhang' is the value.\ncity = \"Jhang\"\n```", "check": {"type": "mcq", "question": "In `age = 25`, what is the variable name?", "options": ["age", "25", "="], "answer": "age"}},
+    {"module": "Mastering Variables", "title": "Lesson 2: Common Data Types", "explanation": "Variables can store different **types** of data. The most common are:\n- **`int` (Integer):** Whole numbers, like `10`, `-5`, or `150`.\n- **`str` (String):** Text, enclosed in quotes, like `\"Hello, Gojra\"` or `'Python'`.\n- **`float`:** Numbers with a decimal point, like `3.14` or `99.9`.", "check": {"type": "writing", "question": "What is the data type for text, like \"hello\"?", "answer": "string"}},
+
+    # MODULE 2: Lists
+    {"module": "Mastering Lists", "title": "Lesson 1: What is a List?", "explanation": "A **list** is an ordered collection of items, enclosed in square brackets `[]`. Lists are incredibly useful because they let you store multiple related values in a single variable.\n\n**Example:**\n```python\n# A list of numbers\nscores = [88, 92, 100]\n\n# A list of strings\ncities = [\"Jhang\", \"Gojra\", \"Faisalabad\"]\n```", "check": {"type": "mcq", "question": "Which of these creates a valid Python list?", "options": ["(1, 2)", "[1, 2]", "{1, 2}"], "answer": "[1, 2]"}},
+    {"module": "Mastering Lists", "title": "Lesson 2: Accessing Elements by Index", "explanation": "You can get a single item from a list using its **index**—its position in the list. **Important:** Indexing starts at `0` for the first item.\n\n**Example:**\n```python\nletters = ['a', 'b', 'c']\nfirst_letter = letters[0]  # This gets 'a'\nthird_letter = letters[2]  # This gets 'c'\n```", "check": {"type": "logical", "question": "For `letters = ['a', 'b', 'c']`, how do you get the item 'b'?", "options": ["letters[0]", "letters[1]", "letters[2]"], "answer": "letters[1]"}},
+    {"module": "Mastering Lists", "title": "Lesson 3: Modifying Lists", "explanation": "Lists are **mutable**, which means you can change them after they are created. A common way to modify a list is to add an item to the end using the `.append()` method.\n\n**Example:**\n```python\nscores = [88, 92]\nscores.append(100) # Now, scores is [88, 92, 100]\n```", "check": {"type": "writing", "question": "Which method adds an item to the end of a list?", "answer": "append"}},
+
+    # MODULE 3: Loops
+    {"module": "Mastering Loops", "title": "Lesson 1: The `for` Loop", "explanation": "A **`for` loop** is used for iterating over a sequence (like a list). It runs a block of code once for each item in the sequence. This is perfect for when you want to do something to every item in a collection.\n\n**Example:**\n```python\n# This will print each city on a new line\ncities = [\"Jhang\", \"Gojra\"]\nfor city in cities:\n    print(city)\n```", "check": {"type": "writing", "question": "Which loop is best for going through every single item in a list?", "answer": "for"}},
+    
+    # MODULE 4: Operators
+    {"module": "Mastering Operators", "title": "Lesson 1: Comparison Operators", "explanation": "Comparison operators compare two values and return a boolean result (`True` or `False`). They are the foundation of decision-making in code.\n- `==` : Equal to\n- `!=` : Not equal to\n- `>` : Greater than\n- `<` : Less than\n\n**Example:**\n```python\nage = 18\nis_adult = age > 17 # This will be True\n```", "check": {"type": "mcq", "question": "Which operator checks if two values are exactly equal?", "options": ["=", "==", "!="], "answer": "=="}},
+
+    # MODULE 5: Strings
+    {"module": "Mastering Strings", "title": "Lesson 1: String Methods", "explanation": "Strings have built-in functions called **methods** that perform actions on the string. They are called using a dot (`.`) after the string variable.\n\n**Example:**\n```python\nmessage = \"Hello World\"\nprint(message.upper()) # Prints 'HELLO WORLD'\nprint(message.lower()) # Prints 'hello world'\n```", "check": {"type": "logical", "question": "What would `'Python'.lower()` return?", "options": ["'PYTHON'", "'Python'", "'python'"], "answer": "'python'"}},
+
+    # MODULE 6: Stacks
+    {"module": "Mastering DSA - Stacks", "title": "Lesson 1: Stacks (LIFO)", "explanation": "A **stack** is a data structure that follows the LIFO (Last-In, First-Out) principle. In Python, a list can be used as a stack. You use `.append()` to add an item to the top ('push') and `.pop()` to remove the most recently added item ('pop').\n\n**Example:**\n```python\nstack = []\nstack.append('a') # stack is ['a']\nstack.append('b') # stack is ['a', 'b']\nitem = stack.pop()  # item is 'b', stack is now ['a']\n```", "check": {"type": "mcq", "question": "Which principle does a stack follow?", "options": ["FIFO", "LIFO", "Random"], "answer": "LIFO"}},
+]
+
+### --- DATA: DEDICATED PRACTICE PROBLEMS (ALIGNED WITH LESSONS) --- ###
+practice_problems = [
+    # --- Foundations (Baby Steps) ---
+    {
+        "title": "Foundations: Access a List Item",
+        "concepts_covered": ["Lists"],
+        "problem_statement": "You are given a list: `cities = ['Jhang', 'Gojra', 'Faisalabad']`. Get the second item, 'Gojra', and store it in a variable called `my_city`.",
+        "starter_code": "cities = ['Jhang', 'Gojra', 'Faisalabad']\n\n# Your code here\nmy_city = ...",
+        "check_type": "variable", "check_variable": "my_city", "expected_result": "Gojra",
+        "background_knowledge": "Remember that list indexing starts at 0. The first item is at index 0, the second at index 1, and so on. You access an item using square brackets `[]`."
+    },
+    {
+        "title": "Foundations: Add to a List",
+        "concepts_covered": ["Lists"],
+        "problem_statement": "You have a list of numbers: `scores = [88, 92]`. Add the number `100` to the **end** of this list.",
+        "starter_code": "scores = [88, 92]\n\n# Your code here",
+        "check_type": "variable", "check_variable": "scores", "expected_result": [88, 92, 100],
+        "background_knowledge": "The `.append()` method is used to add a single item to the end of a list. For example, `my_list.append(5)` would add the number 5 to the end of `my_list`."
+    },
+    {
+        "title": "Foundations: Uppercase a String",
+        "concepts_covered": ["Strings"],
+        "problem_statement": "You have a string `name = \"gojra\"`. Convert this string to all uppercase letters and store the result in a variable called `uppercase_name`.",
+        "starter_code": "name = \"gojra\"\n\n# Your code here\nuppercase_name = ...",
+        "check_type": "variable", "check_variable": "uppercase_name", "expected_result": "GOJRA",
+        "background_knowledge": "Strings have many useful built-in methods. The `.upper()` method will return a new string where all characters are in uppercase. Remember to call it with parentheses, like `my_string.upper()`."
+    },
+    # --- Easy (Combining Concepts) ---
+    {
+        "title": "Easy: Count Positive Numbers",
+        "concepts_covered": ["Lists", "Loops", "Operators"],
+        "problem_statement": "You are given a list: `data = [10, -5, 3, 0, -1, 8]`. Write a script that loops through the list and counts how many numbers are **strictly greater than 0**. The final count should be in a variable named `positive_count`.",
+        "starter_code": "data = [10, -5, 3, 0, -1, 8]\npositive_count = 0\n\n# Your code here",
+        "check_type": "variable", "check_variable": "positive_count", "expected_result": 3,
+        "background_knowledge": "This problem combines loops and conditional statements. Remember, a `for` loop is great for checking every item in a list, and an `if` statement can be used inside the loop to check if a number meets a certain condition (like being greater than zero)."
+    },
+    {
+        "title": "Easy: Filter Long Words",
+        "concepts_covered": ["Lists", "Loops", "Strings"],
+        "problem_statement": "You have a list of words: `words = ['cat', 'python', 'excellent', 'door', 'window']`. Create a new list called `long_words` that contains only the words from the original list that have **more than 5 characters**.",
+        "starter_code": "words = ['cat', 'python', 'excellent', 'door', 'window']\nlong_words = []\n\n# Your code here",
+        "check_type": "variable", "check_variable": "long_words", "expected_result": ['python', 'excellent', 'window'],
+        "background_knowledge": "To solve this, you'll need to loop through the `words` list. Inside the loop, you can find the length of each word using the `len()` function. If the length meets the condition, you can add that word to your `long_words` list using the `.append()` method."
+    },
+]
 
 ### --- HELPER & AI FUNCTIONS --- ###
 
@@ -63,55 +132,11 @@ def make_api_call(system_prompt, user_prompt, timeout=120.0):
     except Exception as e:
         return {"success": False, "error": f"An API error occurred: {e}"}
 
-def generate_dynamic_curriculum(topic):
-    """
-    Asks the AI to generate a full curriculum and practice problems as a JSON object.
-    """
-    system_prompt = """
-    You are an expert Python programming instructor and curriculum designer. Your task is to generate a complete, interactive learning module based on a user-provided topic. You MUST respond with ONLY a valid JSON object and nothing else. Do not include any introductory text, markdown formatting like ```json, or any explanations outside of the JSON structure.
-
-    The JSON object must have two top-level keys: "curriculum" and "practice_problems".
-
-    1.  **curriculum**: This must be a JSON list of 2 to 3 lesson objects. Each lesson object must have:
-        - "module": A string with the name of the overall topic (e.g., "Mastering Dictionaries").
-        - "title": A string for the specific lesson title (e.g., "Lesson 1: What is a Dictionary?").
-        - "explanation": A concise, simple explanation of the concept (1-3 sentences).
-        - "check": A JSON object containing:
-            - "type": The string "mcq".
-            - "question": A string with a clear question.
-            - "options": A JSON list of 3 string options.
-            - "answer": A string that exactly matches one of the options.
-
-    2.  **practice_problems**: This must be a JSON list containing exactly ONE practice problem object. This object must have:
-        - "title": A string (e.g., "Practice: Word Frequency Counter").
-        - "problem_statement": A clear problem description.
-        - "starter_code": A string of Python code for the user to start with.
-        - "check_type": The string "variable".
-        - "check_variable": The name of the variable to check for the final answer.
-        - "expected_result": The correct final value of the check_variable (can be a number, string, list, or dictionary).
-        - "background_knowledge": A brief hint about the overall approach.
-    """
-    user_prompt = f"Generate a learning module for the Python topic: '{topic}'"
-
+def get_new_explanation(lesson_title, prev_exp, question, answer):
+    user_prompt = f"A student is struggling with '{lesson_title}'. They saw '{prev_exp}', were asked '{question}', and answered '{answer}'. Re-explain concisely with a new analogy."
+    system_prompt = "You are a helpful Python tutor."
     result = make_api_call(system_prompt, user_prompt)
-    
-    if result["success"]:
-        if not result["content"] or not result["content"].strip():
-            return {"success": False, "error": "The AI returned an empty response. This might be a temporary issue. Please try again."}
-        try:
-            json_string = result["content"].strip()
-            if json_string.startswith("```json"):
-                json_string = json_string[7:-3].strip()
-            
-            data = json.loads(json_string)
-            if "curriculum" in data and "practice_problems" in data:
-                return {"success": True, "data": data}
-            else:
-                return {"success": False, "error": "AI response was missing the required 'curriculum' or 'practice_problems' keys."}
-        except json.JSONDecodeError as e:
-            return {"success": False, "error": f"AI returned invalid JSON. Error: {e}\n\nRaw response received:\n{result['content']}"}
-    else:
-        return {"success": False, "error": result["error"]}
+    return result["content"] if result["success"] else f"Error getting explanation: {result['error']}"
 
 
 def get_socratic_hint(problem, user_code, actual_result, error_message=None):
@@ -142,91 +167,68 @@ def get_code_coaching(problem, user_code):
     return result["content"] if result["success"] else f"Error getting coaching feedback: {result['error']}"
 
 
-### --- GRADIO APP WITH DYNAMIC TUTOR --- ###
+### --- GRADIO APP WITH TABS --- ###
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    time_str = "Thursday, August 21, 2025 at 09:30 PM PKT"
+    time_str = "Sunday, August 24, 2025 at 02:03 PM PKT"
     
-    gr.Markdown(f"# Welcome to the AI Python Master\n*Current Location: Jhang, Punjab, Pakistan. Current Time: {time_str}*")
-
-    # --- STATE MANAGEMENT ---
-    dynamic_curriculum = gr.State([])
-    dynamic_practice_problems = gr.State([])
-    lesson_index = gr.State(0)
-    practice_attempts = gr.State(0)
-
-    # --- UI for Topic Selection ---
-    with gr.Column(visible=True) as topic_selection_ui:
-        gr.Markdown("## What Python concept do you want to master today?")
-        topic_input = gr.Textbox(label="Enter a Topic", placeholder="e.g., Python Lists, Dictionaries, For Loops, etc.")
-        generate_lesson_btn = gr.Button("Generate Lesson Plan")
-        generation_status = gr.Markdown("")
-
-    # --- UI for Dynamic Learning ---
-    with gr.Column(visible=False) as learning_ui:
-        # --- Learn Section ---
-        progress_bar = gr.Markdown("")
-        lesson_progress = gr.Markdown("")
-        explanation_box = gr.Markdown("")
-        with gr.Column() as check_ui:
-            check_question = gr.Markdown("")
-            mcq_input = gr.Radio(label="Select your answer")
-            submit_button = gr.Button("Submit Answer")
-        lesson_feedback_box = gr.Markdown("")
-        next_button = gr.Button("➡️ Continue", visible=False)
-        
-        # --- Practice Section ---
-        with gr.Column(visible=False) as practice_ui:
-            gr.Markdown("--- \n ## Practice Arena")
+    gr.Markdown(f"# Welcome to the CS Pathfinder\n*Current Location: Jhang, Punjab, Pakistan. Current Time: {time_str}*")
+
+    with gr.Tabs():
+        # --- TAB 1: LEARN ---
+        with gr.TabItem("🎓 Learn"):
+            with gr.Row():
+                start_vars_btn = gr.Button("Variables")
+                start_lists_btn = gr.Button("Lists")
+                start_loops_btn = gr.Button("Loops")
+                start_ops_btn = gr.Button("Operators")
+                start_strings_btn = gr.Button("Strings")
+                start_dsa_btn = gr.Button("DSA - Stacks")
+            
+            lesson_index = gr.State(0)
+            failed_attempts = gr.State(0)
+
+            progress_bar = gr.Markdown("")
+            
+            lesson_progress = gr.Markdown(f"### Module: {curriculum[0]['module']} - Lesson 1 / {len(curriculum)}")
+            explanation_box = gr.Markdown(curriculum[0]['explanation'])
+            with gr.Column() as check_ui:
+                check_question = gr.Markdown(f"**Question:** {curriculum[0]['check']['question']}")
+                mcq_input = gr.Radio(choices=curriculum[0]['check']['options'], label="Select your answer")
+                writing_input = gr.Textbox(label="Type your answer here", visible=False)
+                submit_button = gr.Button("Submit Answer")
+            lesson_feedback_box = gr.Markdown("")
+            next_button = gr.Button("➡️ Continue", visible=False)
+            success_message = gr.Markdown("🎉 **Congratulations! You have finished all learning modules!** 🎉", visible=False)
+
+        # --- TAB 2: PRACTICE ---
+        with gr.TabItem("💻 Practice"):
+            gr.Markdown("## Practice Arena\nTest your combined knowledge with these coding challenges.")
+            
+            practice_attempts = gr.State(0)
+            problem_titles = [p["title"] for p in practice_problems]
+            
+            practice_problem_selector = gr.Dropdown(choices=problem_titles, label="Choose a Problem", value=None)
+            
             with gr.Row():
                 with gr.Column(scale=2):
-                    practice_problem_statement = gr.Markdown("")
-                    practice_code_input = gr.Code(language="python", label="Your Code")
+                    practice_problem_statement = gr.Markdown(visible=False)
+                    practice_code_input = gr.Code(language="python", label="Your Code", visible=False)
                 with gr.Column(scale=1):
+                    # Dedicated box for coaching feedback
                     coach_feedback_box = gr.Markdown(visible=False)
-            
-            submit_practice_button = gr.Button("Run Code")
+
+            submit_practice_button = gr.Button("Run Code", visible=False)
             hint_button = gr.Button("🤔 Get a Hint", visible=False)
             coach_button = gr.Button("🤖 Coach Me: Improve My Code", visible=False)
             practice_feedback_box = gr.Markdown("")
 
-        success_message = gr.Markdown("🎉 **Congratulations! You have finished this module!** 🎉", visible=False)
-        start_new_topic_btn = gr.Button("Learn Another Topic", visible=False)
-
-    # --- LOGIC FOR DYNAMIC TUTOR ---
-    def generate_and_start_lesson(topic, progress=gr.Progress()):
-        progress(0, desc="Asking the AI to design your lesson... This may take a moment.")
-        
-        result = generate_dynamic_curriculum(topic)
+    # --- LOGIC FOR LEARN TAB ---
+    def update_ui_for_lesson(new_lesson_index):
+        lesson = curriculum[new_lesson_index]
+        mcq_visible = lesson['check']['type'] in ['mcq', 'logical']
         
-        if not result["success"]:
-            return {
-                topic_selection_ui: gr.update(visible=True),
-                generation_status: gr.update(visible=True, value=f"❌ **Error:** {result['error']}"),
-                learning_ui: gr.update(visible=False)
-            }
-
-        new_curriculum = result["data"]["curriculum"]
-        new_practice = result["data"]["practice_problems"]
-        
-        first_lesson_ui = update_ui_for_lesson(0, new_curriculum)
-
-        return {
-            dynamic_curriculum: new_curriculum,
-            dynamic_practice_problems: new_practice,
-            lesson_index: 0,
-            practice_attempts: 0,
-            learning_ui: gr.update(visible=True),
-            topic_selection_ui: gr.update(visible=False),
-            generation_status: gr.update(visible=False),
-            **first_lesson_ui
-        }
-
-    def update_ui_for_lesson(index, current_curriculum):
-        lesson = current_curriculum[index]
-        check_data = lesson.get("check", {}) # Safer access
-        
-        total_lessons = len(current_curriculum)
-        completed_lessons = index
+        total_lessons = len(curriculum)
+        completed_lessons = new_lesson_index
         percentage = int((completed_lessons / total_lessons) * 100)
         bar_length = 30
         filled_length = int(bar_length * percentage / 100)
@@ -234,57 +236,83 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         progress_text = f"**Progress:** {bar} {percentage}% ({completed_lessons}/{total_lessons} Lessons)"
         
         return {
-            lesson_index: index,
-            lesson_progress: f"### Module: {lesson.get('module', 'Module')} - Lesson {index + 1} / {total_lessons}",
-            explanation_box: lesson.get('explanation', ''),
-            check_ui: gr.update(visible=True),
-            check_question: f"**Question:** {check_data.get('question', '')}",
-            mcq_input: gr.update(choices=check_data.get('options', []), value=None),
-            lesson_feedback_box: "",
-            next_button: gr.update(visible=False),
+            lesson_index: new_lesson_index, failed_attempts: 0,
+            lesson_progress: f"### Module: {lesson['module']} - Lesson {new_lesson_index + 1} / {len(curriculum)}",
+            explanation_box: lesson['explanation'], check_ui: gr.update(visible=True),
+            check_question: f"**Question:** {lesson['check']['question']}",
+            mcq_input: gr.update(visible=mcq_visible, choices=lesson['check'].get('options', []), value=None),
+            writing_input: gr.update(visible=not mcq_visible, value=""),
+            lesson_feedback_box: "", next_button: gr.update(visible=False),
             progress_bar: progress_text
         }
 
-    def process_answer(index, mcq_answer, current_curriculum):
-        lesson = current_curriculum[index]
-        check_data = lesson.get("check", {})
-        is_correct = str(mcq_answer).strip().lower() == str(check_data.get('answer', '')).strip().lower()
+    def process_answer(current_lesson_index, mcq_answer, writing_answer, attempts, explanation_text):
+        lesson = curriculum[current_lesson_index]
+        user_answer = writing_answer if lesson['check']['type'] == 'writing' else mcq_answer
+        is_correct = str(user_answer).strip().lower().replace(".", "").replace("()", "") == str(lesson['check']['answer']).strip().lower()
         if is_correct:
-            return { lesson_feedback_box: "✅ **Correct!**", check_ui: gr.update(visible=False), next_button: gr.update(visible=True) }
+            return { lesson_feedback_box: "✅ **Correct!**", check_ui: gr.update(visible=False), next_button: gr.update(visible=True), failed_attempts: 0 }
         else:
-            return { lesson_feedback_box: "❌ Not quite. Try again.", check_ui: gr.update(visible=True), next_button: gr.update(visible=False) }
-
-    def on_next_lesson(index, current_curriculum, current_practice):
-        new_index = index + 1
-        if new_index < len(current_curriculum):
-            return update_ui_for_lesson(new_index, current_curriculum)
+            new_attempts = attempts + 1
+            if new_attempts >= 10:
+                return { lesson_feedback_box: "🤔 Let's move on for now.", check_ui: gr.update(visible=False), next_button: gr.update(visible=True), failed_attempts: 0 }
+            new_explanation = get_new_explanation(lesson['title'], explanation_text, lesson['check']['question'], user_answer)
+            feedback = f"❌ Not quite (Attempt {new_attempts}/10). Read the new explanation above."
+            return { explanation_box: new_explanation, lesson_feedback_box: feedback, failed_attempts: new_attempts }
+    
+    def on_next_lesson(current_lesson_index):
+        new_index = current_lesson_index + 1
+        if new_index < len(curriculum):
+            return update_ui_for_lesson(new_index)
         else:
-            # End of lessons, show practice problem
-            practice_problem = current_practice[0]
-            total_lessons = len(current_curriculum)
+            total_lessons = len(curriculum)
             bar = '█' * 30
             progress_text = f"**Progress:** {bar} 100% ({total_lessons}/{total_lessons} Lessons)"
-            
             return {
-                lesson_progress: "### All Lessons Complete! Now for the Practice Arena.",
-                explanation_box: "",
-                check_ui: gr.update(visible=False),
-                next_button: gr.update(visible=False),
-                practice_ui: gr.update(visible=True),
-                practice_problem_statement: practice_problem["problem_statement"],
-                practice_code_input: practice_problem["starter_code"],
-                progress_bar: progress_text,
-                lesson_index: new_index
+                lesson_progress: "### All Modules Complete! ###", explanation_box: "",
+                success_message: gr.update(visible=True), next_button: gr.update(visible=False), 
+                check_ui: gr.update(visible=False), lesson_index: new_index,
+                progress_bar: progress_text
             }
-            
-    def process_practice_answer(user_code, current_practice):
-        problem = current_practice[0]
+    
+    def start_module(module_name):
+        for i, lesson in enumerate(curriculum):
+            if lesson['module'] == module_name:
+                return update_ui_for_lesson(i)
+        return {}
+        
+    # --- LOGIC FOR PRACTICE TAB ---
+    def select_practice_problem(problem_title):
+        if not problem_title:
+             return {
+                practice_problem_statement: gr.update(visible=False), practice_code_input: gr.update(visible=False),
+                submit_practice_button: gr.update(visible=False), hint_button: gr.update(visible=False),
+                coach_button: gr.update(visible=False), coach_feedback_box: gr.update(visible=False),
+                practice_feedback_box: "", practice_attempts: 0
+            }
+        problem = next((p for p in practice_problems if p["title"] == problem_title), None)
+        if problem:
+            # NEW: Display the concepts covered
+            concepts_text = f"**Concepts Tested:** {', '.join(problem['concepts_covered'])}"
+            return {
+                practice_problem_statement: gr.update(visible=True, value=f"{concepts_text}\n\n---\n\n{problem['problem_statement']}"),
+                practice_code_input: gr.update(visible=True, value=problem["starter_code"]),
+                submit_practice_button: gr.update(visible=True), hint_button: gr.update(visible=False),
+                coach_button: gr.update(visible=False), coach_feedback_box: gr.update(visible=False, value=""),
+                practice_feedback_box: "", practice_attempts: 0
+            }
+        return {}
+
+    def process_practice_answer(problem_title, user_code):
+        problem = next((p for p in practice_problems if p["title"] == problem_title), None)
         result = execute_practice_code(user_code)
         
+        # Always reset hint counter on a new submission
         attempts = 0
+
         if not result['success']:
             return { 
-                practice_feedback_box: f"❌ **Code Error:**\n\n```\n{result['error']}\n```", 
+                practice_feedback_box: f"❌ **Code Error:** Your code couldn't run. See the error below. Read it carefully, or ask for a hint to help find the mistake.\n\n```\n{result['error']}\n```", 
                 hint_button: gr.update(visible=True), coach_button: gr.update(visible=False),
                 practice_attempts: attempts 
             }
@@ -293,7 +321,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         expected_value = problem['expected_result']
         actual_value = result['scope'].get(var_name, f"Variable '{var_name}' not found!")
         
-        if str(actual_value) == str(expected_value):
+        if actual_value == expected_value:
             return { 
                 practice_feedback_box: f"✅ **Success!** The variable `{var_name}` has the correct value. Great job! Now, let the AI Code Coach show you how to improve it.", 
                 hint_button: gr.update(visible=False), coach_button: gr.update(visible=True),
@@ -305,11 +333,9 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 hint_button: gr.update(visible=True), coach_button: gr.update(visible=False),
                 practice_attempts: attempts 
             }
-
-    def provide_hint(user_code, current_practice, attempts):
+    
+    def provide_hint(problem_title, user_code, attempts):
         new_attempts = attempts + 1
-        problem = current_practice[0]
-        
         if new_attempts > MAX_HINTS:
             return { 
                 practice_feedback_box: f"**Hint Limit Reached ({MAX_HINTS}/{MAX_HINTS}).**", 
@@ -317,6 +343,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                 practice_attempts: new_attempts
             }
 
+        problem = next((p for p in practice_problems if p["title"] == problem_title), None)
         result = execute_practice_code(user_code)
         
         if new_attempts == 1 and result['success']:
@@ -333,66 +360,49 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             practice_attempts: new_attempts
         }
 
-    def coach_code(user_code, current_practice):
-        problem = current_practice[0]
+    def coach_code(problem_title, user_code):
+        problem = next((p for p in practice_problems if p["title"] == problem_title), None)
         coaching_text = get_code_coaching(problem, user_code)
         return {
             coach_feedback_box: gr.update(visible=True, value=coaching_text),
-            coach_button: gr.update(interactive=False),
-            success_message: gr.update(visible=True),
-            start_new_topic_btn: gr.update(visible=True)
-        }
-        
-    def reset_to_start():
-        return {
-            topic_selection_ui: gr.update(visible=True),
-            learning_ui: gr.update(visible=False),
-            practice_ui: gr.update(visible=False),
-            success_message: gr.update(visible=False),
-            start_new_topic_btn: gr.update(visible=False),
-            coach_feedback_box: gr.update(visible=False, value=""),
-            coach_button: gr.update(visible=False, interactive=True),
-            hint_button: gr.update(visible=False),
-            practice_feedback_box: "",
-            generation_status: ""
+            coach_button: gr.update(interactive=False) # Disable button after use
         }
 
     # --- EVENT LISTENERS ---
-    generate_lesson_btn.click(
-        fn=generate_and_start_lesson,
-        inputs=[topic_input],
-        outputs=[topic_selection_ui, generation_status, dynamic_curriculum, dynamic_practice_problems, lesson_index, practice_attempts, learning_ui, lesson_progress, explanation_box, check_ui, check_question, mcq_input, lesson_feedback_box, next_button, progress_bar]
-    )
-    submit_button.click(
-        fn=process_answer,
-        inputs=[lesson_index, mcq_input, dynamic_curriculum],
-        outputs=[lesson_feedback_box, check_ui, next_button]
-    )
-    next_button.click(
-        fn=on_next_lesson,
-        inputs=[lesson_index, dynamic_curriculum, dynamic_practice_problems],
-        outputs=[lesson_progress, explanation_box, check_ui, next_button, practice_ui, practice_problem_statement, practice_code_input, progress_bar, lesson_index]
+    all_learning_components = [lesson_index, failed_attempts, lesson_progress, explanation_box, check_ui, check_question, mcq_input, writing_input, lesson_feedback_box, next_button, progress_bar]
+    
+    submit_button.click(fn=process_answer, inputs=[lesson_index, mcq_input, writing_input, failed_attempts, explanation_box], outputs=[explanation_box, lesson_feedback_box, check_ui, next_button, failed_attempts])
+    next_button.click(fn=on_next_lesson, inputs=[lesson_index], outputs=all_learning_components + [success_message])
+    
+    start_vars_btn.click(fn=lambda: start_module("Mastering Variables"), inputs=None, outputs=all_learning_components)
+    start_lists_btn.click(fn=lambda: start_module("Mastering Lists"), inputs=None, outputs=all_learning_components)
+    start_loops_btn.click(fn=lambda: start_module("Mastering Loops"), inputs=None, outputs=all_learning_components)
+    start_ops_btn.click(fn=lambda: start_module("Mastering Operators"), inputs=None, outputs=all_learning_components)
+    start_strings_btn.click(fn=lambda: start_module("Mastering Strings"), inputs=None, outputs=all_learning_components)
+    start_dsa_btn.click(fn=lambda: start_module("Mastering DSA - Stacks"), inputs=None, outputs=all_learning_components)
+
+    practice_problem_selector.change(
+        fn=select_practice_problem,
+        inputs=[practice_problem_selector],
+        outputs=[practice_problem_statement, practice_code_input, submit_practice_button, hint_button, coach_button, coach_feedback_box, practice_feedback_box, practice_attempts]
     )
     submit_practice_button.click(
         fn=process_practice_answer,
-        inputs=[practice_code_input, dynamic_practice_problems],
+        inputs=[practice_problem_selector, practice_code_input],
         outputs=[practice_feedback_box, hint_button, coach_button, practice_attempts]
     )
     hint_button.click(
         fn=provide_hint,
-        inputs=[practice_code_input, dynamic_practice_problems, practice_attempts],
+        inputs=[practice_problem_selector, practice_code_input, practice_attempts],
         outputs=[practice_feedback_box, hint_button, practice_attempts]
     )
     coach_button.click(
         fn=coach_code,
-        inputs=[practice_code_input, dynamic_practice_problems],
-        outputs=[coach_feedback_box, coach_button, success_message, start_new_topic_btn]
-    )
-    start_new_topic_btn.click(
-        fn=reset_to_start,
-        inputs=None,
-        outputs=[topic_selection_ui, learning_ui, practice_ui, success_message, start_new_topic_btn, coach_feedback_box, coach_button, hint_button, practice_feedback_box, generation_status]
+        inputs=[practice_problem_selector, practice_code_input],
+        outputs=[coach_feedback_box, coach_button]
     )
+    
+    demo.load(lambda: update_ui_for_lesson(0), outputs=all_learning_components)
 
 if __name__ == "__main__":
     demo.launch(debug=True)