def update_game(choice, game_state_json):
    """Update game based on player choice"""
    try: # Wrap major logic in try-except
        if not choice: # Handle empty choice if dropdown value is cleared
            # Return updates that don't change anything
            return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()

        # Parse game state from JSON
        game_state_dict = json.loads(game_state_json)
        game_state = GameState.from_dict(game_state_dict)

        # Get current page data
        current_page = game_state.current_page
        current_page_str = str(current_page)

        if current_page_str not in game_data:
             # Handle invalid page number
             error_content = f"<p>Error: Reached invalid page number {current_page}. Resetting game.</p>"
             svg_error = create_svg_illustration("default")
             new_game_state = GameState()
             return (svg_error, error_content, gr.Dropdown(choices=["Restart"], label="Error", value=None), new_game_state.to_json(),
                     generate_stats_display(new_game_state), generate_inventory_display(new_game_state), "Error - Resetting")

        page_data = game_data[current_page_str]

        # Find the selected option
        selected_option = None
        current_options_list = page_data.get("options", [])
        for opt in current_options_list:
            # Ensure 'text' key exists in option dictionary
            if isinstance(opt, dict) and opt.get("text") == choice:
                selected_option = opt
                break

        # Check alternative option if it was displayed and chosen
        alt_opt_data = page_data.get("alternativeOption")
        if not selected_option and isinstance(alt_opt_data, dict) and alt_opt_data.get("text") == choice:
             # Check if the alternative option should have been available
             # This logic needs refinement: check if primary options were filtered out *and* alt condition met
             alt_show_if = alt_opt_data.get("showIf")
             current_inventory = game_state.inventory
             primary_options_available = False
             if current_options_list:
                  for opt in current_options_list:
                       is_available = True
                       req_item = opt.get("requireItem")
                       if req_item and req_item not in current_inventory:
                           is_available = False
                       req_any = opt.get("requireAnyItem")
                       if is_available and req_any and not any(i in current_inventory for i in req_any):
                           is_available = False
                       if is_available:
                           primary_options_available = True
                           break # Found at least one available primary option

             # Select alternative only if no primary options were available AND showIf condition is met
             if not primary_options_available and (not alt_show_if or any(item in current_inventory for item in alt_show_if)):
                  selected_option = alt_opt_data


        if selected_option is None:
            # Handle case where choice might be "Restart" or invalid
            if choice == "Restart":
                 return initialize_game()
            else:
                # Stay on the same page if the choice wasn't found
                options = [opt.get("text", "Invalid Option") for opt in current_options_list]
                if alt_opt_data and alt_opt_data.get("text"): # Add alternative option text if it exists
                    # Check showIf condition for alternative option display
                    alt_show_if = alt_opt_data.get("showIf")
                    current_inventory = game_state.inventory
                    if not alt_show_if or any(item in current_inventory for item in alt_show_if):
                         # Check if primary options were filtered out
                         primary_options_available = False
                         if current_options_list:
                             # Re-check primary options availability
                             for opt in current_options_list:
                                 is_available = True
                                 req_item = opt.get("requireItem")
                                 if req_item and req_item not in current_inventory: is_available = False
                                 req_any = opt.get("requireAnyItem")
                                 if is_available and req_any and not any(i in current_inventory for i in req_any): is_available = False
                                 if is_available:
                                     primary_options_available = True
                                     break
                         if not primary_options_available:
                             options.append(alt_opt_data["text"])

                if not options: options = ["Restart"]

                svg_content = create_svg_illustration(page_data.get("illustration", "default"))
                content = f"<h2>{page_data.get('title', 'Error')}</h2>" + page_data.get("content", "") + f"<p><i>Debug: Choice '{choice}' not matched to any available option.</i></p>"
                stats_display = generate_stats_display(game_state)
                inventory_display = generate_inventory_display(game_state)
                story_path_display = f"You remain on page {current_page}: {page_data.get('title', 'Error')}"
                return svg_content, content, gr.Dropdown(choices=options, value=None), game_state.to_json(), stats_display, inventory_display, story_path_display

        # --- Option requirement checks ---
        item_required = selected_option.get("requireItem")
        any_item_required = selected_option.get("requireAnyItem")
        current_inventory = game_state.inventory # Cache inventory

        # Check specific item requirement
        if item_required and item_required not in current_inventory:
            content = f"<h2>{page_data['title']}</h2>" + page_data["content"]
            content += f"<p style='color: red;'>You need the <strong>{item_required}</strong> for this option, but you don't have it.</p>"
            options_texts = [opt.get("text") for opt in page_data.get("options", []) if opt.get("text")]
            # Check if alt option should be added back
            if alt_opt_data and alt_opt_data.get("text"):
                alt_show_if = alt_opt_data.get("showIf")
                if not alt_show_if or any(item in current_inventory for item in alt_show_if):
                     primary_available_check = any(
                         opt.get("text") and (not opt.get("requireItem") or opt.get("requireItem") in current_inventory) and \
                         (not opt.get("requireAnyItem") or any(i in current_inventory for i in opt.get("requireAnyItem")))
                         for opt in page_data.get("options", [])
                     )
                     if not primary_available_check: options_texts.append(alt_opt_data["text"])

            if not options_texts: options_texts = ["Restart"]
            svg_content = create_svg_illustration(page_data.get("illustration", "default"))
            stats_display = generate_stats_display(game_state)
            inventory_display = generate_inventory_display(game_state)
            story_path_display = f"You remain on page {current_page}: {page_data['title']}"
            return svg_content, content, gr.Dropdown(choices=list(set(options_texts)), value=None), game_state.to_json(), stats_display, inventory_display, story_path_display # Use set to remove duplicates

        # Check 'any item' requirement
        if any_item_required and not any(item in current_inventory for item in any_item_required):
            item_list = ", ".join(f"'{item}'" for item in any_item_required)
            content = f"<h2>{page_data['title']}</h2>" + page_data["content"]
            content += f"<p style='color: red;'>You need one of the following items for this option: <strong>{item_list}</strong>, but you don't have any.</p>"
            options_texts = [opt.get("text") for opt in page_data.get("options", []) if opt.get("text")]
             # Check if alt option should be added back (similar logic as above)
            if alt_opt_data and alt_opt_data.get("text"):
                alt_show_if = alt_opt_data.get("showIf")
                if not alt_show_if or any(item in current_inventory for item in alt_show_if):
                     primary_available_check = any(
                         opt.get("text") and (not opt.get("requireItem") or opt.get("requireItem") in current_inventory) and \
                         (not opt.get("requireAnyItem") or any(i in current_inventory for i in opt.get("requireAnyItem")))
                         for opt in page_data.get("options", [])
                     )
                     if not primary_available_check: options_texts.append(alt_opt_data["text"])

            if not options_texts: options_texts = ["Restart"]
            svg_content = create_svg_illustration(page_data.get("illustration", "default"))
            stats_display = generate_stats_display(game_state)
            inventory_display = generate_inventory_display(game_state)
            story_path_display = f"You remain on page {current_page}: {page_data['title']}"
            return svg_content, content, gr.Dropdown(choices=list(set(options_texts)), value=None), game_state.to_json(), stats_display, inventory_display, story_path_display


        # --- Process valid choice ---
        item_to_add = selected_option.get("addItem")
        if item_to_add and item_to_add not in game_state.inventory:
            game_state.inventory.append(item_to_add)
            item_data = items_data.get(item_to_add, {})
            if item_data.get("type") == "consumable" and item_data.get("useOnAdd"):
                 if "hpRestore" in item_data:
                      hp_before = game_state.current_hp
                      game_state.current_hp = min(game_state.max_hp, game_state.current_hp + item_data["hpRestore"])
                      # Maybe add feedback about using the item? Add later if needed.
                 game_state.inventory.remove(item_to_add) # Remove consumable after use

        # Move to the next page (initial move before battle/challenge checks)
        next_page = selected_option["next"]
        next_page_str = str(next_page)

        if next_page_str not in game_data:
             error_content = f"<p>Error: Option leads to invalid page number {next_page}. Resetting game.</p>"
             svg_error = create_svg_illustration("default")
             new_game_state = GameState()
             return (svg_error, error_content, gr.Dropdown(choices=["Restart"], label="Error", value=None), new_game_state.to_json(),
                     generate_stats_display(new_game_state), generate_inventory_display(new_game_state), "Error - Resetting")

        # --- Battle Check ---
        battle_occurred = False
        battle_message = ""
        battle_result = True

        # Check random battle flag on the *current* page data (page_data before challenge potentially changes it)
        if page_data.get("randomBattle", False) and random.random() < 0.2:
            battle_result, battle_log = simulate_battle(game_state)
            battle_occurred = True
            if not battle_result:
                content = "<h2>Game Over</h2><p>You have been defeated in battle!</p>" + battle_log
                stats_display = generate_stats_display(game_state)
                inventory_display = generate_inventory_display(game_state)
                return create_svg_illustration("game-over"), content, gr.Dropdown(choices=["Restart"], label="Game Over", value=None), game_state.to_json(), stats_display, inventory_display, "Game Over - You were defeated in battle."
            else:
                 battle_message = f"<div style='border: 1px solid green; padding: 10px; margin-top: 10px; background-color: #e8f5e9;'><strong>Battle Won!</strong>{battle_log}</div>"

        # --- Set current page to the determined next page (before challenge check) ---
        game_state.current_page = next_page
        if next_page not in game_state.visited_pages:
            game_state.visited_pages.append(next_page)

        # Update journey progress
        game_state.journey_progress += 5
        if game_state.journey_progress > 100: game_state.journey_progress = 100

        # Get data for the potentially final destination page (next_page_str)
        page_data = game_data[next_page_str] # Now refers to the data of the page we are landing on

        # --- HP Loss / Stat Increase on Landing Page ---
        stat_increase = page_data.get("statIncrease")
        if stat_increase:
            stat = stat_increase.get("stat")
            amount = stat_increase.get("amount")
            if stat and amount and stat in game_state.stats:
                 game_state.stats[stat] += amount

        hp_loss = page_data.get("hpLoss")
        if hp_loss:
            game_state.current_hp -= hp_loss
            if game_state.current_hp <= 0:
                game_state.current_hp = 0
                content = "<h2>Game Over</h2><p>You have died from your wounds!</p>"
                stats_display = generate_stats_display(game_state)
                inventory_display = generate_inventory_display(game_state)
                return create_svg_illustration("game-over"), content, gr.Dropdown(choices=["Restart"], label="Game Over", value=None), game_state.to_json(), stats_display, inventory_display, "Game Over - You died from your wounds."


        # --- Challenge Check on Landing Page ---
        challenge_log = ""
        challenge_occurred = False
        challenge = page_data.get("challenge")
        if challenge:
            challenge_occurred = True
            req_stat = challenge.get("stat")
            req_difficulty = challenge.get("difficulty")
            req_success_page = challenge.get("success")
            req_failure_page = challenge.get("failure")

            if not all([req_stat, req_difficulty, req_success_page is not None, req_failure_page is not None]): # Check pages can be 0
                 challenge_log = "<div style='color: orange;'>Challenge data incomplete.</div>"
                 challenge = None # Skip challenge processing
            else:
                success, roll, total = perform_challenge(game_state, challenge)
                challenge_log = f"<div style='border: 1px solid #ccc; padding: 10px; margin-top: 10px; background-color: #eee;'>"
                challenge_log += f"<strong>Challenge: {challenge.get('title', 'Skill Check')}</strong><br>"
                challenge_log += f"Target Stat: {req_stat}, Difficulty: {req_difficulty}<br>"
                stat_val_before_roll = total - roll # Stat value used in the roll
                challenge_log += f"You rolled a {roll} + ({stat_val_before_roll} {req_stat}) = {total}<br>"

                if success:
                    challenge_log += "<strong style='color: green;'>Success!</strong></div>"
                    next_page = req_success_page
                else:
                    # *** THIS IS THE CORRECTED LINE (around line 208 of app.py) ***
                    challenge_log += "<strong style='color: red;'>Failure!</strong></div>"
                    # **************************************************************
                    next_page = req_failure_page

                # Update game state again based on challenge outcome
                game_state.current_page = next_page
                next_page_str = str(next_page)

                if next_page_str not in game_data:
                    error_content = f"<p>Error: Challenge outcome leads to invalid page {next_page}. Resetting.</p>"
                    svg_error = create_svg_illustration("default")
                    new_game_state = GameState()
                    return (svg_error, error_content, gr.Dropdown(choices=["Restart"], label="Error", value=None), new_game_state.to_json(),
                            generate_stats_display(new_game_state), generate_inventory_display(new_game_state), "Error - Resetting")

                if next_page not in game_state.visited_pages:
                    game_state.visited_pages.append(next_page)
                # Load the *final* destination page data after challenge resolution
                page_data = game_data[next_page_str]


        # --- Prepare Final Output ---
        final_page_title = page_data.get('title', 'Untitled')
        svg_content = create_svg_illustration(page_data.get("illustration", "default"))

        # Handle game over on the final destination page
        if page_data.get("gameOver", False):
            content = f"<h2>{final_page_title}</h2>"
            content += page_data.get("content", "")
            if battle_occurred and battle_result: content += battle_message
            if challenge_occurred: content += challenge_log
            if "ending" in page_data:
                content += f"<div style='text-align: center; margin-top: 20px; font-weight: bold; color: #c00;'>THE END</div>"
                content += f"<p style='font-style: italic;'>{page_data['ending']}</p>"

            stats_display = generate_stats_display(game_state)
            inventory_display = generate_inventory_display(game_state)
            return svg_content, content, gr.Dropdown(choices=["Restart"], label="Game Over", value=None), game_state.to_json(), stats_display, inventory_display, "Game Over - " + final_page_title

        # Build content for the final destination page (if not game over)
        content = f"<h2>{final_page_title}</h2>"
        content += page_data.get("content", "<p>No content.</p>")
        if battle_occurred and battle_result: content += battle_message
        if challenge_occurred: content += challenge_log

        # Build options for the final destination page
        options_texts = []
        current_inventory = game_state.inventory # Cache inventory again
        final_page_options = page_data.get("options", [])
        if final_page_options:
            for opt in final_page_options:
                option_available = True
                if isinstance(opt, dict): # Ensure opt is a dictionary
                    req_item = opt.get("requireItem")
                    if req_item and req_item not in current_inventory:
                         option_available = False
                    req_any_item = opt.get("requireAnyItem")
                    if option_available and req_any_item:
                        if not any(item in current_inventory for item in req_any_item):
                             option_available = False
                    if option_available and opt.get("text"):
                        options_texts.append(opt["text"])
                # else: skip invalid option format

        # Handle alternative option if necessary (only if no primary options were available/visible)
        alt_opt_data = page_data.get("alternativeOption")
        if isinstance(alt_opt_data, dict) and alt_opt_data.get("text") and not options_texts: # Check if text exists and no primary options shown
            alt_show_if = alt_opt_data.get("showIf")
            if not alt_show_if or any(item in current_inventory for item in alt_show_if):
                options_texts.append(alt_opt_data["text"])


        if not options_texts: # If still no options (dead end?)
            options_texts = ["Restart"]
            content += "<p><i>There are no further actions you can take from here.</i></p>"

        # Update story path display text
        story_path = f"You are on page {next_page}: {final_page_title}"
        if game_state.journey_progress >= 80: story_path += " (Nearing the conclusion)"
        elif game_state.journey_progress >= 50: story_path += " (Middle of your journey)"
        elif game_state.journey_progress >= 25: story_path += " (Adventure beginning)"

        # Generate final displays
        stats_display = generate_stats_display(game_state)
        inventory_display = generate_inventory_display(game_state)

        # Return final state
        return (svg_content, content, gr.Dropdown(choices=list(set(options_texts)), label="What will you do?", value=None),
                game_state.to_json(), stats_display, inventory_display, story_path)

    except Exception as e:
         # Generic error handling for the entire update function
         print(f"Error during update_game: {e}")
         import traceback
         traceback.print_exc() # Print detailed traceback to console (if possible in Gradio Lite)
         error_content = f"<p>A critical error occurred: {e}. Resetting game state.</p>"
         svg_error = create_svg_illustration("default")
         new_game_state = GameState() # Reset state
         return (svg_error, error_content, gr.Dropdown(choices=["Restart"], label="Critical Error", value=None), new_game_state.to_json(),
                 generate_stats_display(new_game_state), generate_inventory_display(new_game_state), "Critical Error - Reset")