from dataclasses import replace as dataclass_replace

import streamlit as st
from gui_elements.paginator import paginator
from gui_elements.stateful_widget import StatefulWidgets

from qstn.utilities import placeholder
from qstn.utilities.constants import QuestionnairePresentation

# CONSTANTS FOR FIELDS
question_stem_field = "Question Stem"
randomize_order_tick = "Randomize the order of items"
system_prompt_field = "System prompt"
prompt_field = "Prompt"
change_all_system_prompts_checkbox = "system_change_all"
change_all_prompts_checkbox = "prompts_change_all"

field_ids = [question_stem_field, randomize_order_tick]

st.set_page_config(layout="wide")
st.title("Prompt Configuration")
st.write(
    "This interface allows you configure how the questions are prompted to "
    "the LLM and the overall prompt structure. "
    "These options are applied to every questionnaire in your survey."
)
st.page_link("pages/01_Option_Prompt.py", label="Click here to adjust the answer options.")
st.page_link(
    "pages/00_Tutorial.py",
    label="📖 Need help? See tutorial: Prompts",
    query_params={"section": "prompts"},
)
st.divider()


@st.cache_data
def create_stateful_widget() -> StatefulWidgets:
    return StatefulWidgets()


state = create_stateful_widget()

if "questionnaires" not in st.session_state:
    st.error("You need to first upload a questionnaire and the population you want to survey.")
    st.stop()

current_questionnaire_id = paginator(
    st.session_state.questionnaires,
    "current_questionnaire_index_prompt",
)


# Helper functions (used by _inject_default_placeholders_once)
def get_survey_options():
    """Helper to get survey options from session state."""
    return st.session_state.get("survey_options")


def get_randomize_order_bool():
    """Helper to get randomize order boolean."""
    return st.session_state.get(f"input_{randomize_order_tick}", False)


def _inject_default_placeholders_once():
    """
    On first load of Prompt Configuration: inject QUESTION_PLACEHOLDER/OPTIONS_PLACEHOLDER
    into prompt and QUESTION_CONTENT_PLACEHOLDER into question_stem for all questionnaires,
    then prepare them and set form/preview state so prompts and live preview show correctly.
    """
    if st.session_state.get("prompt_config_placeholders_initialized"):
        return
    questionnaires = st.session_state.questionnaires
    survey_options = get_survey_options()
    randomize_order = get_randomize_order_bool()

    for q in questionnaires:
        # Prompt: ensure both placeholders present (append once if either missing)
        p = q.prompt or ""
        if placeholder.PROMPT_QUESTIONS not in p:
            p = (
                p.rstrip() + " " + placeholder.PROMPT_QUESTIONS + " " + placeholder.PROMPT_OPTIONS
            ).strip()
        elif placeholder.PROMPT_OPTIONS not in p:
            p = (p.rstrip() + " " + placeholder.PROMPT_OPTIONS).strip()
        q.prompt = p

        # Question stem: ensure QUESTION_CONTENT placeholder present for each item
        for i, item in enumerate(q._questions):
            stem = item.question_stem or ""
            if placeholder.QUESTION_CONTENT not in stem:
                new_stem = (stem.rstrip() + " " + placeholder.QUESTION_CONTENT).strip()
                q._questions[i] = dataclass_replace(item, question_stem=new_stem)

        # Prepare so preview can resolve placeholders
        first_stem = q._questions[0].question_stem if q._questions else None
        q.prepare_prompt(
            question_stem=first_stem,
            answer_options=survey_options,
            randomized_item_order=randomize_order,
        )

    cur_id = current_questionnaire_id
    st.session_state.temporary_questionnaire = questionnaires[cur_id].duplicate()
    st.session_state.temporary_questionnaire_id = cur_id

    # Form keys: so text areas show the placeholder version
    st.session_state[f"system_prompt_textarea_{cur_id}"] = questionnaires[cur_id].system_prompt
    st.session_state[f"prompt_textarea_{cur_id}"] = questionnaires[cur_id].prompt
    st.session_state[f"input_{question_stem_field}_{cur_id}"] = (
        questionnaires[cur_id]._questions[0].question_stem
        if questionnaires[cur_id]._questions
        else ""
    )

    # Initial preview: resolved content immediately
    preview_key = f"preview_{cur_id}"
    system_prompt, prompt = generate_preview(
        questionnaires[cur_id],
        survey_options,
        randomize_order,
    )
    st.session_state[preview_key] = {"system_prompt": system_prompt, "prompt": prompt}

    st.session_state["prompt_config_placeholders_initialized"] = True


def clear_questionnaire_keys(questionnaire_id):
    """Helper to clear session state keys for a questionnaire."""
    keys_to_clear = [
        f"system_prompt_textarea_{questionnaire_id}",
        f"prompt_textarea_{questionnaire_id}",
        f"input_{question_stem_field}_{questionnaire_id}",
        f"preview_{questionnaire_id}",
    ]
    for key in keys_to_clear:
        if key in st.session_state:
            del st.session_state[key]


def extract_placeholders(text):
    """Extract all placeholder strings from text."""
    all_placeholders = [
        placeholder.PROMPT_QUESTIONS,
        placeholder.PROMPT_OPTIONS,
        placeholder.PROMPT_AUTOMATIC_OUTPUT_INSTRUCTIONS,
        placeholder.QUESTION_CONTENT,
        placeholder.JSON_TEMPLATE,
    ]
    found_placeholders = []
    for ph in all_placeholders:
        if ph in text:
            found_placeholders.append(ph)
    return found_placeholders


def add_missing_placeholders(target_text, placeholders_to_add, source_text):
    """Add or update placeholders in target text to match source formatting."""
    if not placeholders_to_add:
        return target_text

    result = target_text.rstrip()

    # First, remove any existing placeholders from the target to avoid duplicates
    # and to allow re-formatting them
    for ph in placeholders_to_add:
        if ph in result:
            # Remove the placeholder and any surrounding whitespace/newlines
            # This allows us to re-add it in the correct format
            result = result.replace(ph, "")
            # Clean up extra whitespace/newlines that might be left
            result = result.replace("\n\n\n", "\n\n")  # Remove triple newlines
            result = result.replace("  ", " ")  # Remove double spaces
            result = result.rstrip()

    # Determine formatting from source text
    # Check if any placeholder in source appears on the same line (not after a newline)
    same_line_format = False
    for ph in placeholders_to_add:
        if ph in source_text:
            # Find the placeholder in source
            ph_index = source_text.find(ph)
            # Check the character immediately before the placeholder
            # If it's a newline, the placeholder is on a new line
            # If it's a space or other character (not newline), it's on the same line
            if ph_index > 0:
                char_before = source_text[ph_index - 1]
                if char_before != "\n":
                    # Placeholder is on same line (not preceded by newline)
                    same_line_format = True
                    break
            # If placeholder is at start of text (ph_index == 0), treat as new line
            # If preceded by newline, also treat as new line

    # Add placeholders in the correct format
    if same_line_format:
        # Add placeholders on same line with space before
        if result:
            result += " "
        result += " ".join(placeholders_to_add)
    else:
        # Add placeholders on new line(s)
        if result and not result.endswith("\n"):
            result += "\n"
        result += "\n".join(placeholders_to_add)

    return result


def generate_preview(questionnaire, survey_options, randomize_order):
    """Helper to generate preview content."""
    temp_q = questionnaire.duplicate()
    current_question_stem = (
        questionnaire._questions[0].question_stem if questionnaire._questions else ""
    )
    temp_q.prepare_prompt(
        question_stem=current_question_stem,
        answer_options=survey_options,
        randomized_item_order=randomize_order,
    )
    temp_q.system_prompt = questionnaire.system_prompt
    temp_q.prompt = questionnaire.prompt
    system_prompt, prompt = temp_q.get_prompt_for_questionnaire_type(
        QuestionnairePresentation.SEQUENTIAL
    )
    return system_prompt.replace("\n", "  \n"), prompt.replace("\n", "  \n")


# First time on this page: inject default placeholders into prompts/question_stem,
# prepare questionnaires, set form and preview
_inject_default_placeholders_once()

# Initialize or update temporary_questionnaire to match current questionnaire
if "temporary_questionnaire" not in st.session_state:
    st.session_state.temporary_questionnaire = st.session_state.questionnaires[
        current_questionnaire_id
    ].duplicate()
    st.session_state.temporary_questionnaire_id = current_questionnaire_id
elif st.session_state.get("temporary_questionnaire_id") != current_questionnaire_id:
    # User switched questionnaires, store old ID before updating
    old_questionnaire_id = st.session_state.get("temporary_questionnaire_id")
    st.session_state.temporary_questionnaire = st.session_state.questionnaires[
        current_questionnaire_id
    ].duplicate()
    st.session_state.temporary_questionnaire_id = current_questionnaire_id

    # Clear old text area keys so they get re-initialized from the new temporary_questionnaire
    if old_questionnaire_id is not None:
        clear_questionnaire_keys(old_questionnaire_id)

    # Clear keys for the NEW questionnaire so they get re-initialized from temporary_questionnaire
    # This ensures we use fresh values from the actual questionnaire, not stale session state
    new_system_key = f"system_prompt_textarea_{current_questionnaire_id}"
    new_prompt_key = f"prompt_textarea_{current_questionnaire_id}"
    new_question_stem_key = f"input_{question_stem_field}_{current_questionnaire_id}"
    clear_questionnaire_keys(current_questionnaire_id)

    # Explicitly set the keys to values from temporary_questionnaire after clearing
    # This ensures the widgets initialize with the correct values, not stale session state
    st.session_state[new_system_key] = st.session_state.temporary_questionnaire.system_prompt
    st.session_state[new_prompt_key] = st.session_state.temporary_questionnaire.prompt
    new_question_stem_default = (
        st.session_state.temporary_questionnaire._questions[0].question_stem
        if st.session_state.temporary_questionnaire._questions
        else ""
    )
    st.session_state[new_question_stem_key] = new_question_stem_default

if "base_questionnaire" not in st.session_state:
    st.session_state.base_questionnaire = st.session_state.temporary_questionnaire.duplicate()
elif st.session_state.get("temporary_questionnaire_id") != current_questionnaire_id:
    # Update base_questionnaire when switching questionnaires
    st.session_state.base_questionnaire = st.session_state.temporary_questionnaire.duplicate()

if "questionnaires" in st.session_state and st.session_state.questionnaires is not None:
    try:
        # Validate questionnaire index
        _ = st.session_state.questionnaires[current_questionnaire_id]
    except IndexError:
        st.error("Index is out of range. Resetting to the first item.")
        current_questionnaire_id = 0
        st.session_state.temporary_questionnaire = st.session_state.questionnaires[
            current_questionnaire_id
        ].duplicate()
        st.session_state.temporary_questionnaire_id = current_questionnaire_id

    col1, col2 = st.columns(2, gap="large")

    with col1:
        st.subheader("⚙️ Configuration")

        # Global settings checkboxes at the top
        change_all_system = state.create(
            st.checkbox,
            key=change_all_system_prompts_checkbox,
            label="On update: change all System Prompts",
            help="If this is ticked, all system prompts will be changed to this.",
            initial_value=True,
        )

        change_all_questionnaire = state.create(
            st.checkbox,
            key=change_all_prompts_checkbox,
            label="On update: change all questionnaire instructions",
            help="If this is ticked, all questionnaire instructions will be changed to this.",
            initial_value=True,
        )

        st.divider()

        # System prompt and main prompt section
        # Handle placeholder replacement for both textboxes before widgets are created
        if (
            "unified_placeholder_to_replace" in st.session_state
            and st.session_state.unified_placeholder_to_replace
        ):
            current_system_text = st.session_state.temporary_questionnaire.system_prompt
            current_prompt_text = st.session_state.temporary_questionnaire.prompt
            placeholder_shortcut = st.session_state.unified_placeholder_to_replace["shortcut"]
            placeholder_value = st.session_state.unified_placeholder_to_replace["value"]
            target_textbox = st.session_state.unified_placeholder_to_replace.get(
                "target",
                "prompt",
            )  # "system" or "prompt"

            # Check if placeholder already exists in EITHER textbox
            if placeholder_value in current_system_text or placeholder_value in current_prompt_text:
                st.session_state.unified_placeholder_warning = (
                    f"⚠️ The placeholder `{placeholder_value}` already exists "
                    "in one of the textboxes. Please remove it first if you "
                    "want to insert it again."
                )
            else:
                # Check for shortcut in both textboxes - replace where found
                if placeholder_shortcut in current_system_text:
                    st.session_state.temporary_questionnaire.system_prompt = (
                        current_system_text.replace(
                            placeholder_shortcut,
                            placeholder_value,
                        )
                    )
                elif placeholder_shortcut in current_prompt_text:
                    st.session_state.temporary_questionnaire.prompt = current_prompt_text.replace(
                        placeholder_shortcut,
                        placeholder_value,
                    )
                else:
                    # No shortcut found, add to the target textbox (default
                    # based on which was clicked)
                    if target_textbox == "system":
                        st.session_state.temporary_questionnaire.system_prompt = (
                            current_system_text + f" {placeholder_value} "
                        )
                    else:
                        st.session_state.temporary_questionnaire.prompt = (
                            current_prompt_text + f" {placeholder_value} "
                        )

            st.session_state.unified_placeholder_to_replace = None
            st.rerun()

        # Display warnings if they exist
        if (
            "unified_placeholder_warning" in st.session_state
            and st.session_state.unified_placeholder_warning
        ):
            st.warning(st.session_state.unified_placeholder_warning)
            st.session_state.unified_placeholder_warning = None  # Clear after displaying

        # Use temporary_questionnaire for text areas (temporary edits)
        system_prompt_key = f"system_prompt_textarea_{current_questionnaire_id}"
        prompt_key = f"prompt_textarea_{current_questionnaire_id}"

        # Initialize session state keys from temporary_questionnaire if they don't exist
        # (This happens on first load or when switching to a new questionnaire)
        if system_prompt_key not in st.session_state:
            st.session_state[system_prompt_key] = (
                st.session_state.temporary_questionnaire.system_prompt
            )
        if prompt_key not in st.session_state:
            st.session_state[prompt_key] = st.session_state.temporary_questionnaire.prompt

        new_system_prompt = st.text_area(
            label=system_prompt_field,
            help="The system prompt the model is prompted with.",
            key=system_prompt_key,
        )
        # Sync from session state to temporary_questionnaire (captures user edits)
        st.session_state.temporary_questionnaire.system_prompt = st.session_state[system_prompt_key]

        # Display warning for main prompt if it exists
        if "main_prompt_warning" in st.session_state and st.session_state.main_prompt_warning:
            st.warning(st.session_state.main_prompt_warning)
            st.session_state.main_prompt_warning = None  # Clear after displaying

        new_prompt = st.text_area(
            label=prompt_field,
            help="Instructions that are given to the model before the questions.",
            key=prompt_key,
        )
        # Sync from session state to temporary_questionnaire (captures user edits)
        st.session_state.temporary_questionnaire.prompt = st.session_state[prompt_key]

        # Unified placeholder insertion buttons (work for both system prompt and main prompt)
        st.write("**Insert Placeholder:**")

        # Check if options were configured (needed for both main prompt and question stem sections)
        options_configured = (
            "survey_options" in st.session_state and st.session_state.survey_options is not None
        )

        unified_placeholders = [
            (placeholder.PROMPT_QUESTIONS, "-P", "P", "Prompt Questions"),
            (placeholder.PROMPT_OPTIONS, "-O", "O", "Prompt Options"),
            (placeholder.PROMPT_AUTOMATIC_OUTPUT_INSTRUCTIONS, "-A", "A", "Automatic Output"),
            (placeholder.JSON_TEMPLATE, "-J", "J", "JSON Template"),
        ]

        shortcuts_list = ", ".join([f"`{shortcut}`" for _, shortcut, _, _ in unified_placeholders])
        st.caption(
            f"💡 Tip: Type shortcuts {shortcuts_list} in either the system "
            "prompt or main prompt, then click the button to replace them. "
            "The placeholder will be inserted where the shortcut is found, "
            "or in the main prompt if not found."
        )

        cols_unified = st.columns(len(unified_placeholders))
        for i, (
            placeholder_value,
            shortcut,
            char_label,
            description,
        ) in enumerate(unified_placeholders):
            button_key = f"btn_unified_placeholder_{char_label}"

            # Disable "Prompt Options" button if options weren't configured
            is_options_button = placeholder_value == placeholder.PROMPT_OPTIONS
            button_disabled = is_options_button and not options_configured
            button_help = f"Replaces '{shortcut}' with {placeholder_value} in either textbox"
            if button_disabled:
                button_help = (
                    "⚠️ You need to configure answer options first. Go back "
                    "to the Options page to set them up."
                )

            if cols_unified[i].button(
                description,
                key=button_key,
                use_container_width=True,
                disabled=button_disabled,
                help=button_help,
            ):
                st.session_state.unified_placeholder_to_replace = {
                    "shortcut": shortcut,
                    "value": placeholder_value,
                    "target": "prompt",  # Default to main prompt if no shortcut found
                }
                st.rerun()

        st.divider()

        # Initialize field keys if they don't exist
        for field_id in field_ids:
            if field_id == question_stem_field:
                input_key = f"input_{field_id}_{current_questionnaire_id}"
            else:
                input_key = f"input_{field_id}"
            if input_key not in st.session_state:
                if field_id == question_stem_field:
                    st.session_state[input_key] = (
                        st.session_state.temporary_questionnaire._questions[0].question_stem
                    )
                if field_id == randomize_order_tick:
                    st.session_state[input_key] = False

        # Handle placeholder replacement before widget is created
        input_key = f"input_{question_stem_field}_{current_questionnaire_id}"
        if "placeholder_to_replace" in st.session_state and st.session_state.placeholder_to_replace:
            current_text = st.session_state.get(input_key, "")
            placeholder_shortcut = st.session_state.placeholder_to_replace["shortcut"]
            placeholder_value = st.session_state.placeholder_to_replace["value"]

            # Check if placeholder already exists in the text
            if placeholder_value in current_text:
                st.session_state.question_stem_warning = (
                    f"⚠️ The placeholder `{placeholder_value}` already exists "
                    "in the text. Please remove it first if you want to "
                    "insert it again."
                )
            else:
                # Replace all occurrences of the shortcut (e.g., -Q) with the placeholder
                if placeholder_shortcut in current_text:
                    st.session_state[input_key] = current_text.replace(
                        placeholder_shortcut,
                        placeholder_value,
                    )
                else:
                    # Shortcut not found, append at the end
                    st.session_state[input_key] = current_text + f" {placeholder_value} "

            st.session_state.placeholder_to_replace = None
            st.rerun()

        # --- Input Widgets ---
        # Display warning for question stem if it exists
        if "question_stem_warning" in st.session_state and st.session_state.question_stem_warning:
            st.warning(st.session_state.question_stem_warning)
            st.session_state.question_stem_warning = None  # Clear after displaying

        # Use questionnaire-specific key (consistent with system_prompt and prompt)
        # Streamlit will automatically use the session_state value when key is provided
        input_key = f"input_{question_stem_field}_{current_questionnaire_id}"
        question_stem_input = st.text_area(
            question_stem_field,
            key=input_key,
            height=100,
        )
        # Sync from session state to temporary_questionnaire (captures user edits)
        # This ensures consistency with system_prompt and prompt fields
        survey_options = get_survey_options()
        randomize_order_bool = get_randomize_order_bool()
        st.session_state.temporary_questionnaire.prepare_prompt(
            question_stem=st.session_state[input_key],
            answer_options=survey_options,
            randomized_item_order=randomize_order_bool,
        )

        # --- Placeholder Replacement Buttons ---
        st.write("**Insert Placeholder:**")

        # Define available placeholders with their shortcuts and character labels
        # Format: (placeholder_value, shortcut, character_label, description)
        available_placeholders = [
            (placeholder.QUESTION_CONTENT, "-Q", "Q", "Question Content"),
            (placeholder.PROMPT_OPTIONS, "-O", "O", "Prompt Options"),
        ]

        # Create shortcuts list for the tip
        shortcuts_list = ", ".join(
            [f"`{shortcut}`" for _, shortcut, _, _ in available_placeholders]
        )
        st.caption(
            f"💡 Tip: Type shortcuts {shortcuts_list} in the text, then click "
            "the button to replace them with placeholders."
        )

        # Create buttons in columns with consistent formatting
        cols = st.columns(len(available_placeholders))
        for i, (
            placeholder_value,
            shortcut,
            char_label,
            description,
        ) in enumerate(available_placeholders):
            button_label = description  # Use the actual placeholder name
            button_key = f"btn_placeholder_{char_label}"

            # Disable "Prompt Options" button if options weren't configured
            is_options_button = placeholder_value == placeholder.PROMPT_OPTIONS
            button_disabled = is_options_button and not options_configured
            button_help = f"Replaces '{shortcut}' with {placeholder_value}"
            if button_disabled:
                button_help = (
                    "⚠️ You need to configure answer options first. Go back "
                    "to the Options page to set them up."
                )

            if cols[i].button(
                button_label,
                key=button_key,
                use_container_width=True,
                disabled=button_disabled,
                help=button_help,
            ):
                st.session_state.placeholder_to_replace = {
                    "shortcut": shortcut,
                    "value": placeholder_value,
                }
                st.rerun()

        randomize_order_bool = st.checkbox(
            randomize_order_tick,
            key=f"input_{randomize_order_tick}",
            value=False,
        )

        st.divider()

    # Place the corresponding output in the second column
    with col2:
        st.subheader("📄 Live Preview")
        # Preview only updates when "Update Prompt(s)" is clicked
        with st.container(border=True):
            # Initialize preview state if it doesn't exist
            preview_key = f"preview_{current_questionnaire_id}"
            if preview_key not in st.session_state:
                # Create initial preview
                survey_options = get_survey_options()
                system_prompt, prompt = generate_preview(
                    st.session_state.temporary_questionnaire, survey_options, False
                )
                st.session_state[preview_key] = {"system_prompt": system_prompt, "prompt": prompt}

            # Display the stored preview
            # Add a visible questionnaire identifier to force Streamlit to update when switching
            # This ensures the preview updates even when "change all" makes content identical
            st.caption(
                f"📋 Questionnaire {current_questionnaire_id + 1} of "
                f"{len(st.session_state.questionnaires)}"
            )
            # Use a unique container key for each questionnaire to force
            # Streamlit to update when switching
            # This ensures the preview updates even when content is identical
            with st.container(key=f"preview_container_{current_questionnaire_id}"):
                st.markdown(st.session_state[preview_key]["system_prompt"])
                st.write(st.session_state[preview_key]["prompt"])

    st.divider()

    if st.button("Update Preview", type="secondary", use_container_width=True):
        # Update the preview when Update Prompt(s) is clicked
        # Use temporary_questionnaire directly (already has all the edits)
        preview_key = f"preview_{current_questionnaire_id}"
        survey_options = get_survey_options()
        randomize_order_bool = get_randomize_order_bool()

        system_prompt, prompt = generate_preview(
            st.session_state.temporary_questionnaire, survey_options, randomize_order_bool
        )
        st.session_state[preview_key] = {"system_prompt": system_prompt, "prompt": prompt}

        st.success("Prompt(s) updated!")
        st.rerun()

    if st.button("Confirm and Prepare Questionnaire", type="primary", use_container_width=True):
        # Get survey options if they exist
        survey_options = get_survey_options()
        randomize_order_bool = get_randomize_order_bool()

        # Copy from temporary_questionnaire to actual questionnaires
        # All values come from temporary_questionnaire (now fully synced with all edits)
        current_system_value = st.session_state.temporary_questionnaire.system_prompt
        current_prompt_value = st.session_state.temporary_questionnaire.prompt
        current_question_stem = (
            st.session_state.temporary_questionnaire._questions[0].question_stem
            if st.session_state.temporary_questionnaire._questions
            else ""
        )

        # Extract placeholders from current system prompt if "change all System Prompts" is checked
        placeholders_to_add = []
        if change_all_system:
            placeholders_to_add = extract_placeholders(current_system_value)

        for idx, questionnaire in enumerate(st.session_state.questionnaires):
            # Determine if this questionnaire should be updated
            # System prompt: current questionnaire gets full update, others
            # get placeholders added (if checkbox checked)
            should_update_system = idx == current_questionnaire_id
            should_update_prompt = change_all_questionnaire or (idx == current_questionnaire_id)
            should_update = (
                should_update_system
                or should_update_prompt
                or (change_all_system and idx != current_questionnaire_id)
            )

            if should_update:
                # Update system prompt: full update for current, add placeholders for others
                if should_update_system:
                    # Current questionnaire: update entire system prompt
                    questionnaire.system_prompt = current_system_value
                elif change_all_system and idx != current_questionnaire_id:
                    # Other questionnaires: add missing placeholders while preserving base content
                    questionnaire.system_prompt = add_missing_placeholders(
                        questionnaire.system_prompt, placeholders_to_add, current_system_value
                    )

                if should_update_prompt:
                    questionnaire.prompt = current_prompt_value

                # Call prepare_prompt for questionnaires being updated
                # Use question stem from temporary_questionnaire (consistent with other fields)
                questionnaire.prepare_prompt(
                    question_stem=current_question_stem,
                    answer_options=survey_options,
                    randomized_item_order=randomize_order_bool,
                )
        st.success("Changed the prompts!")

        # Auto-save session
        from gui_elements.session_cache import save_session_state

        save_session_state()

        st.switch_page("pages/03_Inference_Setting.py")
else:
    st.warning("No data found. Please upload a CSV file on the 'Start Page' first.")
