app.py

import gradio as gr
from openai import OpenAI

import os
from docx import Document
import random
import uuid
import json
from datetime import datetime
import pytz
import json
import tempfile
import urllib.parse
import pandas as pd
import re
import time

# From other files
from storage_service import GoogleCloudStorage
from assignment_ui import create_assignment_ui
from assignment_service import AssignmentService
from submission_service import SubmissionService
from dashboard_service import DashboardService

is_env_local = os.getenv("IS_ENV_LOCAL", "false") == "true"
print(f"is_env_local: {is_env_local}")

# KEY CONFIG
if is_env_local:
    with open("local_config.json") as f:
        config = json.load(f)
        IS_ENV_PROD = "False"
        OPEN_AI_KEY = config["OPEN_AI_KEY"]
        GCS_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
        CUTOR_OPEN_AI_KEY = config["CUTOR_OPEN_AI_KEY"]
        CUTOR_OPEN_AI_ASSISTANT_ID = config["CUTOR_OPEN_AI_ASSISTANT_ID"]
        CUTOR_OPEN_AI_ASSISTANT_SPELLING_ID = config["CUTOR_OPEN_AI_ASSISTANT_SPELLING_ID"]
        CUTOR_OPEN_AI_STRUCTURE_ASSISTANT_ID = config["CUTOR_OPEN_AI_STRUCTURE_ASSISTANT_ID"]
        OPEN_AI_MODERATION_BOT1 = config["OPEN_AI_MODERATION_BOT1"]

else:
    OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
    GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
    CUTOR_OPEN_AI_KEY = os.getenv("CUTOR_OPEN_AI_KEY")
    CUTOR_OPEN_AI_ASSISTANT_ID = os.getenv("CUTOR_OPEN_AI_ASSISTANT_ID")
    CUTOR_OPEN_AI_ASSISTANT_SPELLING_ID = os.getenv("CUTOR_OPEN_AI_ASSISTANT_SPELLING_ID")
    CUTOR_OPEN_AI_STRUCTURE_ASSISTANT_ID = os.getenv("CUTOR_OPEN_AI_STRUCTURE_ASSISTANT_ID")
    OPEN_AI_MODERATION_BOT1 = os.getenv("OPEN_AI_MODERATION_BOT1", OPEN_AI_KEY)

OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)
CUTOR_OPEN_AI_CLIENT = OpenAI(api_key=CUTOR_OPEN_AI_KEY)
OPEN_AI_MODERATION_CLIENT = OpenAI(api_key=OPEN_AI_MODERATION_BOT1)

# 設置 Google Cloud Storage 客户端
GCS_SERVICE = GoogleCloudStorage(GCS_KEY)
GCS_CLIENT = GCS_SERVICE.client

_AssignmentService = AssignmentService(GCS_SERVICE)
_SubmissionService = SubmissionService(GCS_SERVICE)
_DashboardService = DashboardService(_AssignmentService, _SubmissionService)

def update_scenario_input(scenario_radio):
    return scenario_radio

def get_exam_history():
    exam_history = """
    92
    Topic: Various Exams in High School Life
    Theme Sentence (First Paragraph): Exams of all kinds have become a necessary part of my high school life.
    Theme Sentence (Second Paragraph): The most unforgettable exam I have ever taken is…
    Keywords:
    giving reasons
    experience

    93
    Topic: Travel Is The Best Teacher
    Theme Sentence (First Paragraph): Explain the advantages of travel.
    Theme Sentence (Second Paragraph): Share personal travel experiences, either domestic or international, to support the first paragraph.
    Keywords:
    enumeration
    experience

    94
    Topic: Organizing the First Reunion After Graduation
    Theme Sentence (First Paragraph): Details of the reunion, including time, location, and activities.
    Theme Sentence (Second Paragraph): Reasons for choosing this type of activity.
    Keywords:
    description
    giving reasons

    95
    Topic: Experiences of Being Misunderstood
    Theme Sentence (First Paragraph): Describe a personal experience of being misunderstood.
    Theme Sentence (Second Paragraph): Discuss the impact and insights gained from this experience.
    Keywords:
    experience
    effect

    96
    Topic: Imagining a World Without Electricity
    Theme Sentence (First Paragraph): Describe what the world would be like without electricity.
    Theme Sentence (Second Paragraph): Explain whether such a world would be good or bad, with examples.
    Keywords:
    description
    giving reasons

    97
    Topic: A Memorable Advertisement
    Theme Sentence (First Paragraph): Describe the content of a memorable TV or print advertisement (e.g., theme, storyline, music, visuals).
    Theme Sentence (Second Paragraph): Explain why the advertisement is memorable.
    Keywords:
    description
    giving reasons
    
    98
    Topic: A Day Without Budget Concerns
    Theme Sentence (First Paragraph): Who would you invite to spend the day with and why?
    Theme Sentence (Second Paragraph): Describe where you would go, what you would do, and why.
    Keywords:
    description
    
    99
    Topic: An Unforgettable Smell
    Theme Sentence (First Paragraph): Describe the situation in which you encountered the smell and your initial feelings.
    Theme Sentence (Second Paragraph): Explain why the smell remains unforgettable.
    Keywords:
    description
    giving reasons
    
    100
    Topic: Your Ideal Graduation Ceremony
    Theme Sentence (First Paragraph): Explain the significance of the graduation ceremony to you.
    Theme Sentence (Second Paragraph): Describe how to arrange or conduct the ceremony to reflect this significance.
    Keywords:
    definition
    enumeration
    """

    return exam_history

def generate_topics(model, max_tokens, sys_content, scenario, eng_level, user_generate_topics_prompt):
    """
    根据系统提示和用户输入的情境及主题，调用OpenAI API生成相关的主题句。
    """

    exam_history = get_exam_history()
    exam_history_prompt = f"""
        Please refer a topic scenario from the following exam history: 
        {exam_history}
        Base on English level to give similar topic scenario. But don't use the same topic scenario.
    """

    user_content = f"""
        english level is: {eng_level}
        ---
        exam_history_prompt: {exam_history_prompt}
        ---
        {user_generate_topics_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
        "response_format": { "type": "json_object" }
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content
        topics = json.loads(content)["topics"]
        print(f"====generate_topics====")
        print(topics)
        gr_update = gr.update(choices=topics, visible=True)
    except Exception as e:
        print(f"An error occurred while generating topics: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def update_topic_input(topic):
    return topic

def generate_points(model, max_tokens, sys_content, scenario, eng_level, topic, user_generate_points_prompt):
    """
    根据系统提示和用户输入的情境、主题，调用OpenAI API生成相关的主题句。
    """
    user_content = f"""
        scenario is: {scenario}
        english level is: {eng_level}
        topic is: {topic}
        ---
        {user_generate_points_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
        "response_format": { "type": "json_object" }
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content
        points = json.loads(content)["points"]
        gr_update = gr.update(choices=points, visible=True)
    except Exception as e:
        print(f"An error occurred while generating points: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def update_points_input(points):
    return points

def generate_topic_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, user_generate_topic_sentences_prompt):
    """
    根据系统提示和用户输入的情境及要点，调用OpenAI API生成相关的主题句及其合理性解释。
    """

    if eng_level == "台灣學科能力測驗等級":
        exam_history = get_exam_history()
        exam_history_prompt = f"""
            Please refer a topic scenario from the following exam history:
            {exam_history}
            give similar topic scenario and level of English. But don't use the same topic scenario.
        """
    else:
        exam_history_prompt = ""

    user_content = f"""
        scenario is: {scenario}
        english level is: {eng_level}
        topic is: {topic}
        points is: {points}
        ---
        exam_history_prompt: {exam_history_prompt}
        ---
        {user_generate_topic_sentences_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]
    response_format = { "type": "json_object" }

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
        "response_format": response_format
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        response_content = json.loads(response.choices[0].message.content)
        json_content = response_content["results"]
        topic_sentences_list = [item["topic-sentence"] for item in json_content]
        random.shuffle(topic_sentences_list)
        
        gr_update_json = gr.update(value=json_content)
        gr_update_radio = gr.update(choices=topic_sentences_list, visible=True)
    except Exception as e:
        print(f"An error occurred while generating topic sentences: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update_json, gr_update_radio

def generate_topic_sentence_feedback(model, max_tokens, sys_content, scenario, eng_level, topic, points, topic_sentence, user_generate_topic_sentence_feedback_prompt):
    """
    根据系统提示和用户输入的情境、主题、要点、主题句，调用OpenAI API生成相关的主题句反饋。
    """
    user_content = f"""
        scenario is: {scenario}
        english level is: {eng_level}
        topic is: {topic}
        points is: {points}
        ---
        my written topic sentence is: {topic_sentence}
        ---
        {user_generate_topic_sentence_feedback_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content.strip()
        gr_update = gr.update(value=content, visible=True)
    except Exception as e:
        print(f"An error occurred while generating topic sentence feedback: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def update_topic_sentence_input(topic_sentences_json, selected_topic_sentence):
    topic_sentence_input = ""
    for ts in topic_sentences_json:
        if ts["topic-sentence"] == selected_topic_sentence:
            appropriate = "O 適合" if ts["appropriate"] == "Y" else "X 不適合"
            border_color = "green" if ts["appropriate"] == "Y" else "red"
            text_color = "green" if ts["appropriate"] == "Y" else "red"
            background_color = "#e0ffe0" if ts["appropriate"] == "Y" else "#ffe0e0"
            
            suggestion_html = f"""
            <div style="border: 2px solid {border_color}; background-color: {background_color}; padding: 10px; border-radius: 5px;">
                <p style="color: {text_color}" >你選了主題句：{selected_topic_sentence}</p>
                <p style="color: {text_color}">是否適當：{appropriate}</p>
                <p style="color: {text_color}">原因：{ts['reason']}</p>
            </div>
            """

            topic_sentence_input = ts["topic-sentence"] if ts["appropriate"] == "Y" else ""
            break

    gr_suggestion_html = gr.update(value=suggestion_html, visible=True)

    return topic_sentence_input, gr_suggestion_html

def generate_supporting_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, topic_sentence, user_generate_supporting_sentences_prompt):
    """
    根据系统提示和用户输入的情境、主题、要点、主题句，调用OpenAI API生成相关的支持句。
    """
    user_content = f"""
        scenario is: {scenario}
        english level is: {eng_level}
        topic is: {topic}
        points is: {points}
        topic sentence is: {topic_sentence}
        ---
        {user_generate_supporting_sentences_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content.strip()
        gr_update = gr.update(choices=[content], visible=True)
    except Exception as e:
        print(f"An error occurred while generating supporting sentences: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def update_supporting_sentences_input(supporting_sentences_radio):
    return supporting_sentences_radio

def generate_conclusion_sentences(model, max_tokens, sys_content, scenario, eng_level, topic, points, topic_sentence, user_generate_conclusion_sentence_prompt):
    """
    根据系统提示和用户输入的情境、主题、要点、主题句，调用OpenAI API生成相关的结论句。
    """
    user_content = f"""
        scenario is: {scenario}
        english level is: {eng_level}
        topic is: {topic}
        points is: {points}
        topic sentence is: {topic_sentence}
        ---
        {user_generate_conclusion_sentence_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
        "response_format": { "type": "json_object" }
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        response_content = json.loads(response.choices[0].message.content)
        json_content = response_content["results"]
        gr_update = gr.update(choices=[json_content], visible=True)
    except Exception as e:
        print(f"An error occurred while generating conclusion sentences: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def update_conclusion_sentence_input(conclusion_sentence_radio):
    return conclusion_sentence_radio

def generate_paragraph(topic_sentence, supporting_sentences, conclusion_sentence):
    """
    根据用户输入的主题句、支持句、结论句，生成完整的段落。
    """
    paragraph = f"{topic_sentence} {supporting_sentences} {conclusion_sentence}"
    return paragraph

def generate_paragraph_evaluate(model, sys_content, paragraph, user_generate_paragraph_evaluate_prompt):
    """
    根据用户输入的段落，调用OpenAI API生成相关的段落分析。
    """
    user_content = f"""
        paragraph is: {paragraph}
        ---
        {user_generate_paragraph_evaluate_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    response_format = { "type": "json_object" }

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": 2000,
        "response_format": response_format
    }

    max_attempts = 2
    attempt = 0
    while attempt < max_attempts:
        try:
            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
            content = response.choices[0].message.content

            print(f"====generate_paragraph_evaluate====")
            print(content)

            data = json.loads(content)
            table_data = [
                ["學測架構|內容（Content）", data['content']['level'], data['content']['explanation']],
                ["學測架構|組織（Organization）", data['organization']['level'], data['organization']['explanation']],
                ["學測架構|文法、句構（Grammar/Sentence Structure）", data['grammar_and_usage']['level'], data['grammar_and_usage']['explanation']],
                ["學測架構|字彙、拼字（Vocabulary/Spelling）", data['vocabulary']['level'], data['vocabulary']['explanation']],
                ["JUTOR 架構|連貫性和連接詞（Coherence and Cohesion）", data['coherence_and_cohesion']['level'], data['coherence_and_cohesion']['explanation']]
            ]
            headers = ["架構", "評分", "解釋"]
            gr_update = gr.update(value=table_data, headers=headers, visible=True)
            break
        except Exception as e:
            print(f"An error occurred while generating paragraph evaluate: {e}")
            attempt += 1
            if attempt == max_attempts:
                raise gr.Error("網路塞車，請重新嘗試一次！")

    return gr_update

def generate_correct_grammatical_spelling_errors(model, sys_content, eng_level, paragraph, user_correct_grammatical_spelling_errors_prompt):
    """
    根据用户输入的段落，调用OpenAI API生成相关的文法和拼字错误修正。
    """
    user_content = f"""
        level is: {eng_level}
        paragraph is: {paragraph}
        ---
        {user_correct_grammatical_spelling_errors_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]
    response_format = { "type": "json_object" }
    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": 1000,
        "response_format": response_format
    }

    max_attempts = 2
    attempt = 0
    while attempt < max_attempts:
        try:
            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
            content = response.choices[0].message.content
            data = json.loads(content)
            print(f"data: {data}")

            corrections_list = [
                [item['original'], item['correction'], item['explanation']]
                for item in data['Corrections and Explanations']
            ]
            headers = ["原文", "建議", "解釋"]

            corrections_list_gr_update = gr.update(value=corrections_list, headers=headers, wrap=True, visible=True)
            reverse_paragraph_gr_update = gr.update(value=data["Revised Paragraph"], visible=False)
            break
        except Exception as e:
            print(f"An error occurred while generating correct grammatical spelling errors: {e}")
            attempt += 1
            if attempt == max_attempts:
                raise gr.Error("網路塞車，請重新嘗試一次！")
    
    return corrections_list_gr_update, reverse_paragraph_gr_update

def highlight_diff_texts(highlight_list, text):
    # Convert DataFrame to JSON string
    highlight_list_json = highlight_list.to_json()

    # Print the JSON string to see its structure
    print("=======highlight_list_json=======")
    print(highlight_list_json)

    # Parse JSON string back to dictionary
    highlight_list_dict = json.loads(highlight_list_json)

    # Extract suggestions from the parsed JSON
    suggestions = [highlight_list_dict['建議'][str(i)] for i in range(len(highlight_list_dict['建議']))]

    # Initialize the HTML for text
    text_html = f"<p>{text}</p>"

    # Replace each suggestion in text with highlighted version
    for suggestion in suggestions:
        text_html = text_html.replace(suggestion, f'<span style="color:red;">{suggestion}</span>')

    return text_html

def update_paragraph_correct_grammatical_spelling_errors_input(paragraph):
    return paragraph

def generate_refine_paragraph(model, sys_content, eng_level, paragraph, user_refine_paragraph_prompt):
    """
    根据用户输入的段落，调用OpenAI API生成相关的段落改善建议。
    """
    user_content = f"""
        eng_level is: {eng_level}
        paragraph is: {paragraph}
        ---
        {user_refine_paragraph_prompt}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    response_format = { "type": "json_object" }

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": 4000,
        "response_format": response_format
    }

    max_attempts = 2
    attempt = 0
    while attempt < max_attempts:
        try:
            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
            content = response.choices[0].message.content
            data = json.loads(content)
            headers = ["原文", "建議", "解釋"]
            table_data = [
                [item['origin'], item['suggestion'], item['explanation']]
                for item in data['Suggestions and Explanations']
            ]

            refine_paragraph_gr_update = gr.update(value=table_data, headers=headers, visible=True)
            revised_paragraph_gr_update = gr.update(value=data["Revised Paragraph"],visible=False)
            break
        except Exception as e:
            print(f"An error occurred while generating refine paragraph: {e}")
            attempt += 1
            if attempt == max_attempts:
                raise gr.Error("網路塞車，請重新嘗試一次！")

    return refine_paragraph_gr_update, revised_paragraph_gr_update

def update_paragraph_refine_input(text):
    return text

# 段落練習歷史紀錄
def generate_paragraph_history(
        user_data,
        session_timestamp,
        request_origin,
        scenario_input,
        topic_output,
        points_output,
        topic_sentence_input,
        supporting_sentences_input,
        conclusion_sentence_input,
        paragraph_output,
        paragraph_evaluate_output,
        correct_grammatical_spelling_errors_output_table,
        refine_output_table,
        refine_output
    ):
    """
    生成段落歷史紀錄
    """

    print("====生成段落歷史紀錄====")
    print(f"user_data: {user_data}")
    print(f"session_timestamp: {session_timestamp}")
    print(f"request_origin: {request_origin}")

    if user_data:
        encoded_user_id_url = urllib.parse.quote(user_data, safe='')
        log_type_name = "jutor_write_paragraph_practice"
        file_name = f"{encoded_user_id_url}/{log_type_name}/{session_timestamp}.json"
        content = {
            "content_type": "english_paragraph_practice",
            "session_timestamp": session_timestamp,
            "request_origin": request_origin,
            "scenario_input": scenario_input,
            "topic_output": topic_output,
            "points_output": points_output,
            "topic_sentence_input": topic_sentence_input,
            "supporting_sentences_input": supporting_sentences_input,
            "conclusion_sentence_input": conclusion_sentence_input,
            "paragraph_output": paragraph_output,
            "paragraph_evaluate_output": paragraph_evaluate_output.to_dict(orient='records'),
            "correct_grammatical_spelling_errors_output_table": correct_grammatical_spelling_errors_output_table.to_dict(orient='records'),
            "refine_output_table": refine_output_table.to_dict(orient='records'),
            "refine_output": refine_output
        }
        print(file_name)
        print(content)
        GCS_SERVICE.upload_json_string("jutor_logs", file_name, json.dumps(content))
    else:
        print("User data is empty.")

    return scenario_input, \
            topic_output, \
            points_output, \
            topic_sentence_input, \
            supporting_sentences_input, \
            conclusion_sentence_input, \
            paragraph_output, \
            paragraph_evaluate_output, \
            correct_grammatical_spelling_errors_output_table, \
            refine_output_table, \
            refine_output

def paragraph_save_and_tts(paragraph_text):
    """
    Saves the paragraph text and generates an audio file using OpenAI's TTS.
    """
    try:
        # Call OpenAI's TTS API to generate speech from text
        response = OPEN_AI_CLIENT.audio.speech.create(
            model="tts-1",
            voice="alloy",
            input=paragraph_text,
        )

        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
            temp_file.write(response.content)

        # Get the file path of the temp file
        audio_path = temp_file.name

        # Return the path to the audio file along with the text
        return paragraph_text, audio_path

    except Exception as e:
        print(f"An error occurred while generating TTS: {e}")
        # Handle the error appropriately (e.g., return an error message or a default audio path)
        return paragraph_text, None

def update_history_accordion():
    history_accordion_gr_update = gr.update(open=True)
    return history_accordion_gr_update

def get_logs_sessions(user_data, log_type):
    if user_data and log_type:
        encoded_user_id_url = urllib.parse.quote(user_data, safe='')
        file_name_prefix = f"{encoded_user_id_url}/{log_type}"
        print(f"file_name_prefix: {file_name_prefix}")
        file_names = GCS_SERVICE.list_files("jutor_logs", file_name_prefix)
        print(f"file_names: {file_names}")
    else:
        file_names = []

    # file_names sort by timestamp DESC
    file_names.sort(reverse=True)
    choices = [
        (format_log_file_name_timestamp(file_name.split("/")[-1].split(".")[0]), file_name) 
        for file_name in file_names
    ]

    paragraph_logs_session_list = gr.update(choices=choices, interactive=True, visible=True)

    return paragraph_logs_session_list

def format_log_file_name_timestamp(timestamp):
    # 假設時間戳格式為 "YYYY-MM-DD-HH-MM-SS"
    parts = timestamp.split("-")
    if len(parts) == 6:
        return f"{'-'.join(parts[:3])} {':'.join(parts[3:])}"
    return timestamp  # 如果格式不符合預期,則返回原始字符串

def get_paragraph_practice_log_session_content(file_name):
    if file_name:
        content = GCS_SERVICE.download_as_string("jutor_logs", file_name)
        print(f"content: {content}")
        content_json = json.loads(content)
        paragraph_log_topic_input_history = content_json["topic_output"]
        paragraph_log_points_input_history = content_json["points_output"]
        paragraph_log_topic_sentence_input_history = content_json["topic_sentence_input"]
        paragraph_log_supporting_sentences_input_history = content_json["supporting_sentences_input"]
        paragraph_log_conclusion_sentence_input_history = content_json["conclusion_sentence_input"]
        paragraph_log_paragraph_output_history = content_json["paragraph_output"]
        # to df
        paragraph_log_paragraph_evaluate_output_history = pd.DataFrame(content_json["paragraph_evaluate_output"])
        paragraph_log_correct_grammatical_spelling_errors_output_table_history = pd.DataFrame(content_json["correct_grammatical_spelling_errors_output_table"])
        paragraph_log_refine_output_table_history = pd.DataFrame(content_json["refine_output_table"])
        paragraph_log_refine_output_history = content_json["refine_output"]
        paragraph_log_paragraph_save_output = content_json["paragraph_output"]
    else:
        paragraph_log_topic_input_history = ""
        paragraph_log_points_input_history = ""
        paragraph_log_topic_sentence_input_history = ""
        paragraph_log_supporting_sentences_input_history = ""
        paragraph_log_conclusion_sentence_input_history = ""
        paragraph_log_paragraph_output_history = ""
        paragraph_log_paragraph_evaluate_output_history = pd.DataFrame()
        paragraph_log_correct_grammatical_spelling_errors_output_table_history = pd.DataFrame()
        paragraph_log_refine_output_table_history = pd.DataFrame()
        paragraph_log_refine_output_history = ""
        paragraph_log_paragraph_save_output = ""

    return paragraph_log_topic_input_history, \
            paragraph_log_points_input_history, \
            paragraph_log_topic_sentence_input_history, \
            paragraph_log_supporting_sentences_input_history, \
            paragraph_log_conclusion_sentence_input_history, \
            paragraph_log_paragraph_output_history, \
            paragraph_log_paragraph_evaluate_output_history, \
            paragraph_log_correct_grammatical_spelling_errors_output_table_history, \
            paragraph_log_refine_output_table_history, \
            paragraph_log_refine_output_history, \
            paragraph_log_paragraph_save_output

# 全文批改歷史紀錄
def generate_paragraph_evaluate_history(
        user_data,
        user_email,
        user_nickname,
        session_timestamp,
        request_origin,
        assignment_id_input,
        full_paragraph_input,
        full_paragraph_evaluate_output,
        full_paragraph_correct_grammatical_spelling_errors_input,
        full_paragraph_correct_grammatical_spelling_errors_output_table,
        full_paragraph_refine_input,
        full_paragraph_refine_output_table,
        full_paragraph_refine_output,
        full_paragraph_save_output
    ):

    print("====生成全文批改歷史紀錄====")
    print(f"user_data: {user_data}")
    print(f"user_email: {user_email}")
    print(f"session_timestamp: {session_timestamp}")
    print(f"request_origin: {request_origin}")

    if user_data:
        encoded_user_id_url = urllib.parse.quote(user_data, safe='')
        log_type_name = "jutor_write_full_paragraph_evaluation"
        file_name = f"{encoded_user_id_url}/{log_type_name}/{session_timestamp}.json"
        content = {
            "content_type": "english_full_paragraph_evaluation",
            "session_timestamp": session_timestamp,
            "request_origin": request_origin,
            "assignment_id": assignment_id_input,
            "full_paragraph_input": full_paragraph_input,
            "full_paragraph_evaluate_output": full_paragraph_evaluate_output.to_dict(orient='records'),
            "full_paragraph_correct_grammatical_spelling_errors_input": full_paragraph_correct_grammatical_spelling_errors_input,
            "full_paragraph_correct_grammatical_spelling_errors_output_table": full_paragraph_correct_grammatical_spelling_errors_output_table.to_dict(orient='records'),
            "full_paragraph_refine_input": full_paragraph_refine_input,
            "full_paragraph_refine_output_table": full_paragraph_refine_output_table.to_dict(orient='records'),
            "full_paragraph_refine_output": full_paragraph_refine_output,
            "full_paragraph_save_output": full_paragraph_save_output
        }
        print(file_name)
        print(content)
        GCS_SERVICE.upload_json_string("jutor_logs", file_name, json.dumps(content))

        if assignment_id_input:
            submission_id = submit_assignment(assignment_id_input, user_data, user_email, user_nickname, content, file_name)
            if submission_id:
                print(f"Assignment submitted successfully. Submission ID: {submission_id}")
            else:
                print("Failed to submit assignment.")
    else:
        gr.Error("請先登入")

    return full_paragraph_input, \
            full_paragraph_evaluate_output, \
            full_paragraph_correct_grammatical_spelling_errors_input, \
            full_paragraph_correct_grammatical_spelling_errors_output_table, \
            full_paragraph_refine_input, \
            full_paragraph_refine_output_table, \
            full_paragraph_refine_output, \
            full_paragraph_save_output

def get_full_paragraph_evaluate_log_session_content(file_name):
    if file_name:
        content = GCS_SERVICE.download_as_string("jutor_logs", file_name)
        print(f"content: {content}")
        content_json = json.loads(content)
        full_paragraph_input = content_json["full_paragraph_input"]
        full_paragraph_evaluate_output = pd.DataFrame(content_json["full_paragraph_evaluate_output"])
        full_paragraph_correct_grammatical_spelling_errors_input = content_json["full_paragraph_correct_grammatical_spelling_errors_input"]
        full_paragraph_correct_grammatical_spelling_errors_output_table = pd.DataFrame(content_json["full_paragraph_correct_grammatical_spelling_errors_output_table"])
        full_paragraph_refine_input = content_json["full_paragraph_refine_input"]
        full_paragraph_refine_output_table = pd.DataFrame(content_json["full_paragraph_refine_output_table"])
        full_paragraph_refine_output = content_json["full_paragraph_refine_output"]
        full_paragraph_save_output = content_json["full_paragraph_save_output"]
    else:
        full_paragraph_input = ""
        full_paragraph_evaluate_output = pd.DataFrame()
        full_paragraph_correct_grammatical_spelling_errors_input = ""
        full_paragraph_correct_grammatical_spelling_errors_output_table = pd.DataFrame()
        full_paragraph_refine_input = ""
        full_paragraph_refine_output_table = pd.DataFrame()
        full_paragraph_refine_output = ""
        full_paragraph_save_output = ""

    return full_paragraph_input, \
            full_paragraph_evaluate_output, \
            full_paragraph_correct_grammatical_spelling_errors_input, \
            full_paragraph_correct_grammatical_spelling_errors_output_table, \
            full_paragraph_refine_input, \
            full_paragraph_refine_output_table, \
            full_paragraph_refine_output, \
            full_paragraph_save_output


# # 考古題練習歷史紀錄
def generate_past_exam_history(
        user_data,
        session_timestamp,
        request_origin,
        past_exam_title,
        past_exam_evaluation_input,
        past_exam_evaluation_output,
        past_exam_correct_grammatical_spelling_errors_input,
        past_exam_correct_grammatical_spelling_errors_output_table,
        past_exam_refine_input,
        past_exam_refine_output_table,
        past_exam_refine_output,
        past_exam_save_output
    ):
    print("====生成考古題練習歷史紀錄====")
    print(f"user_data: {user_data}")
    print(f"session_timestamp: {session_timestamp}")
    print(f"request_origin: {request_origin}")

    if user_data:
        encoded_user_id_url = urllib.parse.quote(user_data, safe='')
        log_type_name = "jutor_write_past_exam"
        file_name = f"{encoded_user_id_url}/{log_type_name}/{session_timestamp}.json"
        content = {
            "content_type": "english_past_exam",
            "session_timestamp": session_timestamp,
            "request_origin": request_origin,
            "past_exam_title": past_exam_title,
            "past_exam_evaluation_input": past_exam_evaluation_input,
            "past_exam_evaluation_output": past_exam_evaluation_output.to_dict(orient='records'),
            "past_exam_correct_grammatical_spelling_errors_input": past_exam_correct_grammatical_spelling_errors_input,
            "past_exam_correct_grammatical_spelling_errors_output_table": past_exam_correct_grammatical_spelling_errors_output_table.to_dict(orient='records'),
            "past_exam_refine_input": past_exam_refine_input,
            "past_exam_refine_output_table": past_exam_refine_output_table.to_dict(orient='records'),
            "past_exam_refine_output": past_exam_refine_output,
            "past_exam_save_output": past_exam_save_output
        }
        print(file_name)
        print(content)
        GCS_SERVICE.upload_json_string("jutor_logs", file_name, json.dumps(content))
    
    return past_exam_title, \
            past_exam_evaluation_input, \
            past_exam_evaluation_output, \
            past_exam_correct_grammatical_spelling_errors_input, \
            past_exam_correct_grammatical_spelling_errors_output_table, \
            past_exam_refine_input, \
            past_exam_refine_output_table, \
            past_exam_refine_output, \
            past_exam_save_output

def get_past_exam_practice_log_session_content(file_name):
    if file_name:
        content = GCS_SERVICE.download_as_string("jutor_logs", file_name)
        print(f"content: {content}")
        content_json = json.loads(content)
        past_exam_title = content_json["past_exam_title"]
        past_exam_evaluation_input = content_json["past_exam_evaluation_input"]
        past_exam_evaluation_output = pd.DataFrame(content_json["past_exam_evaluation_output"])
        past_exam_correct_grammatical_spelling_errors_input = content_json["past_exam_correct_grammatical_spelling_errors_input"]
        past_exam_correct_grammatical_spelling_errors_output_table = pd.DataFrame(content_json["past_exam_correct_grammatical_spelling_errors_output_table"])
        past_exam_refine_input = content_json["past_exam_refine_input"]
        past_exam_refine_output_table = pd.DataFrame(content_json["past_exam_refine_output_table"])
        past_exam_refine_output = content_json["past_exam_refine_output"]
        past_exam_save_output = content_json["past_exam_save_output"]
    else:
        past_exam_title = ""
        past_exam_evaluation_input = ""
        past_exam_evaluation_output = pd.DataFrame()
        past_exam_correct_grammatical_spelling_errors_input = ""
        past_exam_correct_grammatical_spelling_errors_output_table = pd.DataFrame()
        past_exam_refine_input = ""
        past_exam_refine_output_table = pd.DataFrame()
        past_exam_refine_output = ""
        past_exam_save_output = ""

    return past_exam_title, \
            past_exam_evaluation_input, \
            past_exam_evaluation_output, \
            past_exam_correct_grammatical_spelling_errors_input, \
            past_exam_correct_grammatical_spelling_errors_output_table, \
            past_exam_refine_input, \
            past_exam_refine_output_table, \
            past_exam_refine_output, \
            past_exam_save_output

def load_exam_data():
    with open("exams.json", "r") as file:
        data = json.load(file)
    return data

def update_exam_contents(selected_title):
    exams = load_exam_data()["exams"]
    for exam in exams:
        if exam["title"] == selected_title:
            return exam["title"], exam["question"], exam["hint"], exam["image_url"]


# === Chinese ===
def generate_chinese_paragraph_practice_history(
    user_data,
    user_email,
    user_nickname,
    session_timestamp,
    request_origin,
    assignment_id_input,
    chinese_full_paragraph_input,
    chinese_full_paragraph_evaluate_output_text,
    chinese_full_paragraph_evaluate_output_table,
    chinese_full_paragraph_refine_input,
    chinese_full_paragraph_refine_output_text,
    chinese_full_paragraph_refine_output_table,
    chinese_full_paragraph_save_output
):
    if user_data:
        encoded_user_id_url = urllib.parse.quote(user_data, safe='')
        log_type_name = "jutor_write_chinese_full_paragraph_evaluation"
        file_name = f"{encoded_user_id_url}/{log_type_name}/{session_timestamp}.json"
        content = {
            "content_type": "chinese_full_paragraph_evaluation",
            "session_timestamp": session_timestamp,
            "request_origin": request_origin,
            "chinese_full_paragraph_input": chinese_full_paragraph_input,
            "chinese_full_paragraph_evaluate_output_text": chinese_full_paragraph_evaluate_output_text,
            "chinese_full_paragraph_evaluate_output_table": chinese_full_paragraph_evaluate_output_table.to_dict(orient='records'),
            "chinese_full_paragraph_refine_input": chinese_full_paragraph_refine_input,
            "chinese_full_paragraph_refine_output_text": chinese_full_paragraph_refine_output_text,
            "chinese_full_paragraph_refine_output_table": chinese_full_paragraph_refine_output_table.to_dict(orient='records'),
            "chinese_full_paragraph_save_output": chinese_full_paragraph_save_output,
            "assignment_id": assignment_id_input 
        }
        GCS_SERVICE.upload_json_string("jutor_logs", file_name, json.dumps(content))

        if assignment_id_input:
            submission_id = submit_assignment(assignment_id_input, user_data, user_email, user_nickname, content, file_name)
            if submission_id:
                print(f"Assignment submitted successfully. Submission ID: {submission_id}")
            else:
                print("Failed to submit assignment.")
    else:
        gr.Error("請先登入")

    return chinese_full_paragraph_input, \
            chinese_full_paragraph_evaluate_output_text, \
            chinese_full_paragraph_evaluate_output_table, \
            chinese_full_paragraph_refine_input, \
            chinese_full_paragraph_refine_output_text, \
            chinese_full_paragraph_refine_output_table, \
            chinese_full_paragraph_save_output

def submit_assignment(assignment_id, user_data, user_email, user_nickname, submission_content, file_name):
    try:
        submission_id = _SubmissionService.submit_assignment(
            assignment_id=assignment_id,
            student_id=user_data,
            student_email=user_email,
            student_name=user_nickname,
            submission_content=submission_content,
            file_name=file_name,
            bucket_name="jutor_logs"
        )
        
        if submission_id:
            print(f"Updated assignment {assignment_id} with new submission: {submission_id}")
            return submission_id
        else:
            print(f"Failed to submit assignment {assignment_id}")
            return None
    except Exception as e:
        print(f"Error submitting assignment {assignment_id}: {str(e)}")
        return None

def generate_unique_submission_id():
    while True:
        submission_id = str(uuid.uuid4())
        if not GCS_SERVICE.check_file_exists("ai_assignment_submission", f"submissions/{submission_id}.json"):
            return submission_id

def update_assignment_submission(assignment_id, submission_id):
    assignment_data = get_assignment_content(assignment_id)
    if assignment_data:
        assignment_data["submission_ids"].append(submission_id)
        GCS_SERVICE.upload_json_string("ai_assignment_submission", f"assignments/{assignment_id}.json", json.dumps(assignment_data))

def get_assignment_content(assignment_id):
    try:
        Bucket_Name = "ai_assignment_submission"
        file_name = f"assignments/{assignment_id}.json"
        assignment_json = GCS_SERVICE.download_as_string(Bucket_Name, file_name)
        assignment_data = json.loads(assignment_json)
    except Exception as e:
        print(f"Error: {e}")
        return None
    return assignment_data

def get_assignment_formatted_deadline(submission_deadline_data):
    if submission_deadline_data is None:
        return "未設置截止日期"
    
    try:
        # 嘗試解析 Unix 時間戳
        if isinstance(submission_deadline_data, (int, float)):
            submission_datetime = datetime.fromtimestamp(submission_deadline_data)
        # 嘗試解析 ISO 格式字串
        elif isinstance(submission_deadline_data, str):
            try:
                submission_datetime = datetime.fromisoformat(submission_deadline_data)
            except ValueError:
                # 如果不是 ISO 格式,嘗試其他常見格式
                submission_datetime = datetime.strptime(submission_deadline_data, "%Y-%m-%d %H:%M:%S")
        else:
            raise ValueError(f"無效的日期類型: {type(submission_deadline_data)}")
        
        # 確保時間是 UTC+8
        taipei_tz = pytz.timezone('Asia/Taipei')
        submission_datetime = submission_datetime.astimezone(taipei_tz)
        
        return submission_datetime.strftime("%Y-%m-%d %H:%M")
    except Exception as e:
        return f"無效的日期格式: {str(e)}"

def get_chinese_paragraph_practice_log_session_content(file_name):
    if file_name:
        content = GCS_SERVICE.download_as_string("jutor_logs", file_name)
        print(f"content: {content}")
        content_json = json.loads(content)
        chinese_full_paragraph_input_history = content_json["chinese_full_paragraph_input"] if "chinese_full_paragraph_input" in content_json else ""
        chinese_full_paragraph_evaluate_output_text_history = content_json["chinese_full_paragraph_evaluate_output_text"] if "chinese_full_paragraph_evaluate_output_text" in content_json else ""
        chinese_full_paragraph_evaluate_output_table_history = pd.DataFrame(content_json["chinese_full_paragraph_evaluate_output_table"]) if "chinese_full_paragraph_evaluate_output_table" in content_json else pd.DataFrame()
        chinese_full_paragraph_refine_input_history = content_json["chinese_full_paragraph_refine_input"] if "chinese_full_paragraph_refine_input" in content_json else ""
        chinese_full_paragraph_refine_output_text_history = content_json["chinese_full_paragraph_refine_output_text"] if "chinese_full_paragraph_refine_output_text" in content_json else ""
        chinese_full_paragraph_refine_output_table_history = pd.DataFrame(content_json["chinese_full_paragraph_refine_output_table"]) if "chinese_full_paragraph_refine_output_table" in content_json else pd.DataFrame()
        chinese_full_paragraph_save_output_history = content_json["chinese_full_paragraph_save_output"] if "chinese_full_paragraph_save_output" in content_json else ""

        # 作業模式 
        assignment_id = content_json["assignment_id"] if "assignment_id" in content_json else ""
        chinese_assignment_content = gr.update(visible=False)
        chinese_assignment_grade = ""
        chinese_assignment_topic = ""
        chinese_assignment_introduction = ""
        chinese_assignment_description = ""
        chinese_assignment_submission_deadline = ""
        
        if assignment_id:
            chinese_assignment_content = gr.update(visible=True)
            try:
                assignment = get_assignment_content(assignment_id)
                chinese_assignment_grade = assignment["metadata"]["grade"]
                chinese_assignment_topic = assignment["metadata"]["topic"]
                chinese_assignment_introduction = assignment["metadata"]["introduction"]
                chinese_assignment_description = assignment["metadata"]["description"]
                submission_deadline = assignment["metadata"]["submission_deadline"]
                chinese_assignment_submission_deadline = get_assignment_formatted_deadline(submission_deadline)
            except Exception as e:
                print(f"Error: {e}")
                chinese_assignment_grade = "作業已刪除"
                chinese_assignment_topic = "作業已刪除"
                chinese_assignment_introduction = "作業已刪除"
                chinese_assignment_description = "作業已刪除"
                chinese_assignment_submission_deadline = "作業已刪除"
    else:
        chinese_full_paragraph_input_history = ""
        chinese_full_paragraph_evaluate_output_text_history = ""
        chinese_full_paragraph_evaluate_output_table_history = pd.DataFrame()
        chinese_full_paragraph_refine_input_history = ""
        chinese_full_paragraph_refine_output_text_history = ""
        chinese_full_paragraph_refine_output_table_history = pd.DataFrame()
        chinese_full_paragraph_save_output_history = ""

        chinese_assignment_content = gr.update(visible=False)
        chinese_assignment_grade = ""
        chinese_assignment_topic = ""
        chinese_assignment_introduction = ""
        chinese_assignment_description = ""
        chinese_assignment_submission_deadline = ""

    return chinese_full_paragraph_input_history, \
            chinese_full_paragraph_evaluate_output_text_history, \
            chinese_full_paragraph_evaluate_output_table_history, \
            chinese_full_paragraph_refine_input_history, \
            chinese_full_paragraph_refine_output_text_history, \
            chinese_full_paragraph_refine_output_table_history, \
            chinese_full_paragraph_save_output_history, \
            chinese_assignment_content, \
            chinese_assignment_grade, \
            chinese_assignment_topic, \
            chinese_assignment_introduction, \
            chinese_assignment_description, \
            chinese_assignment_submission_deadline


# === OpenAI Assistant ===
def verify_string_length(text):
    if len(text) > 2000:
        raise gr.Error("輸入的文字長度過長，請重新輸入！")

def verify_string_length_short(text):
    if len(text) < 100:
        raise gr.Error("輸入的文字長度過短，少於 100字，請重新輸入！")

def verify_moderation(text):
    response = OPEN_AI_MODERATION_CLIENT.moderations.create(input=text)
    response_dict = response.model_dump()
    is_flagged = response_dict['results'][0]['flagged']
    print("========get_chat_moderation==========")
    print(f"is_flagged: {is_flagged}")
    print(response_dict)
    print("========get_chat_moderation==========")

    if is_flagged:
        raise gr.Error("您的輸入包含不當內容，請重新輸入！")

    return is_flagged, response_dict

def generate_size_count_prompt(paragraph):
    if len(paragraph) > 100 and len(paragraph) < 200:
        size_count_prompt = """
            # Restrictions:
            1. 目前提交字數在100-200字之間，主題與內容的評等最高只能是B+。
            2. 請在主題與內容的回饋中加一句：「文章字數一定要超過200字，請閱讀回饋以後充實你的作文內容。」
        """
    else:
        size_count_prompt = ""
    
    return size_count_prompt

def generate_assignment_prompt(chinese_assignment_topic, chinese_assignment_introduction, chinese_assignment_description):
    if chinese_assignment_topic != "":
        assignment_prompt = f"""
            assignment_topic: {chinese_assignment_topic}
            assignment_introduction: {chinese_assignment_introduction}
            assignment_description: {chinese_assignment_description}
            請根據 assignment_topic, assignment_introduction, assignment_description 來評分
            如果 paragraph 的內容與 assignment_topic, assignment_introduction, assignment_description 無關，請給予最低分，並告知原因
        """
    else:
        assignment_prompt = ""

    return assignment_prompt

def assign_grade(subject_content, structure, diction, spelling_punctuation):
    # 定義等級順序
    grade_order = ["A+", "A", "A-", "B+", "B", "B-"]

    # 確認等級順序
    def grade_is_higher_or_equal(grade1, grade2):
        return grade_order.index(grade1) <= grade_order.index(grade2)

    # 如果任何一個選項為 "X"，則直接返回紅燈
    if any(grade == "X" for grade in [subject_content, structure, diction, spelling_punctuation]):
        return "🔴"

    # 🟢 條件
    if (subject_content in ["A+", "A", "A-"] and
        grade_is_higher_or_equal(structure, "B+") and
        grade_is_higher_or_equal(diction, "B+") and
        grade_is_higher_or_equal(spelling_punctuation, "B+")):
        return "🟢"

    # 🟡 條件
    elif (subject_content in ["B+", "B"] and
          grade_is_higher_or_equal(structure, "B") and
          grade_is_higher_or_equal(diction, "B") and
          grade_is_higher_or_equal(spelling_punctuation, "B")):
        return "🟡"

    # 🔴 條件
    elif (subject_content == "B-" and
          structure == "B-" and
          diction == "B-" and
          spelling_punctuation == "B-"):
        return "🔴"

    # 預設為 🟡
    return "🟡"

def get_chinese_conversation_thread_id(thread_id):
    if thread_id:
        return thread_id
    else:
        client = CUTOR_OPEN_AI_CLIENT
        thread = client.beta.threads.create()
        thread_id = thread.id
        return thread_id

def retry_operation(operation, max_attempts=3, delay=2):
    for attempt in range(max_attempts):
        try:
            return operation()
        except Exception as e:
            if attempt == max_attempts - 1:
                raise e
            time.sleep(delay)

def get_chinese_paragraph_evaluate_content(thread_id, model, user_content, paragraph):
    content_text = ""
    table_data = []
    headers = ["架構", "評分", "解釋"]
    error_messages = []

    # 主題與內容、遣詞造句
    try:
        def content_operation():
            content = generate_content_by_open_ai_assistant(user_content, thread_id, model_name=model)
            if "```json" not in content:
                raise ValueError("回應格式不正確")
            return content
        
        content = retry_operation(content_operation)
        content_list = content.split("```json")
        content_text = content_list[0]
        content_json = content_list[1].split("```")[0]
        data = json.loads(content_json)["results"]
        table_data.extend([
            ["主題與內容", data['主題與內容']['level'], data['主題與內容']['explanation']],
            ["遣詞造句", data['遣詞造句']['level'], data['遣詞造句']['explanation']],
        ])
    except Exception as e:
        error_messages.append(f"主題與內容、遣詞造句評估出錯: {str(e)}")

    # 段落結構
    try:
        def structure_operation():
            content = generate_content_by_open_ai_assistant_structure_robot(paragraph, thread_id=None, model_name=model)
            if "```json" not in content:
                raise ValueError("回應格式不正確")
            return content
        
        paragraph_structure_content = retry_operation(structure_operation)
        structure_content_list = paragraph_structure_content.split("```json")
        content_text += "\n" + structure_content_list[0]
        structure_json = structure_content_list[1].split("```")[0]
        structure_data = json.loads(structure_json)["results"]["段落結構"]
        table_data.append(["段落結構", structure_data['level'], structure_data['explanation']])
    except Exception as e:
        error_messages.append(f"段落結構評估出錯: {str(e)}")

    # 錯別字
    try:
        def spelling_operation():
            content = generate_content_by_open_ai_assistant_spelling_robot(paragraph, thread_id=None, model_name=model)
            if "```json" not in content:
                raise ValueError("回應格式不正確")
            return content
        
        spelling_content = retry_operation(spelling_operation)
        spelling_content_list = spelling_content.split("```json")
        content_text += "\n" + spelling_content_list[0]
        spelling_json = spelling_content_list[1].split("```")[0]
        spelling_data = json.loads(spelling_json)["results"]["錯別字"]
        table_data.append(["錯別字", spelling_data['level'], spelling_data['explanation']])
    except Exception as e:
        error_messages.append(f"錯別字檢查出錯: {str(e)}")

    # 綜合評分
    if len(table_data) == 4:  # 確保所有評估都成功完成
        grade = assign_grade(
            table_data[0][1],  # 主題與內容
            table_data[2][1],  # 段落結構
            table_data[1][1],  # 遣詞造句
            table_data[3][1]   # 錯別字
        )
        grade_content_text = f"# 綜合評分：{grade}"
        content_text = grade_content_text + "\n" + content_text

        # 綜合回饋
        feedback_match = re.search(r"綜合回饋(.*?)評分標準與回饋", content_text, re.DOTALL)
        feedback_text = feedback_match.group(1).strip() if feedback_match else "無法提取綜合回饋"
        table_data.append(["綜合評分", grade, feedback_text])
    else:
        error_messages.append("無法進行綜合評分，因為部分評估未完成")

    # 處理錯誤信息
    if error_messages:
        error_content = "\n".join(error_messages)
        content_text = f"評估過程中遇到以下問題:\n{error_content}\n\n" + content_text

    content_table = gr.update(value=table_data, headers=headers, visible=True)
    
    return content_text, content_table

def get_chinese_paragraph_1st_evaluate_content(
        thread_id,
        model, 
        chinese_assignment_topic,
        chinese_assignment_introduction, 
        chinese_assignment_description, 
        paragraph, 
    ):
    verify_string_length(paragraph)
    verify_moderation(paragraph)
    verify_string_length_short(paragraph)

    size_count_prompt = generate_size_count_prompt(paragraph)
    assignment_prompt = generate_assignment_prompt(chinese_assignment_topic, chinese_assignment_introduction, chinese_assignment_description)
    sys_content_prompt = "You are a Chinese teacher who is practicing with me to improve my Chinese writing skill."
    paragraph_evaluate_prompt = """
        # 請嚴格根據 instructions
        # Rules:
        1. 先檢查是否是合理的作文或是段落，再進行評分
        2. 請確保作文或段落的內容完整，並且符合中文語法
        3. 如果是一篇亂打的文章請直接給予回饋：「這篇文章內容不完整，無法進行評分。」
        4. 如果無法進行評分 評分標準與回饋的內容跟等級，則為 X
        5. 評分標準與回饋根據「A+、A、A-、B+、B、B-」等級來評分，最低為 B-

        # Restrictions:
        1. 不用給整體評分
        2. 不用改標點符號
        3. 不用改段落結構
        4. 評分標準的分數等級請使用「A+、A、A-、B+、B、B-」等級，不可使用數字或是其他等級，像是「90分、80分、C、D」等等。

        # Output format:
        1. 先給 綜合回饋、評分標準與回饋、修改範例
        2. 再將評分標準與回饋的內容以JSON格式輸出，並且請使用繁體中文（ZH-TW）來評分段落並輸出，用 ```json ..... ``` 包裹:
        3. please use Chinese language (ZH-TW) to evaluate the paragraph and output use JSON format
        4. json 內容只需要給「主題與內容」、「遣詞造句」的評分標準與回饋

        EXAMPLE:
        # 綜合回饋
        你的文章...............(寫出一段話，來總結這篇作文的好壞)

        # 評分標準與回饋
        ### 主題與內容：B+ 你的主題很明確，講述了CSS在渲染空間上的問題及解決方案，這是一個重要而實用的話題。然而，內容相對較少，缺乏足夠的細節與實例來支撐你的觀點。建議你可以添加一些具體情境或例子，讓讀者更容易理解CSS的應用情況，例如提到常見的渲染問題以及具體的解決方法。
        ### 遣詞造句：A 你的遣詞造句大致良好，用詞得體且通順。不過可以嘗試加一些更具體的技術詞彙或示例，使文章更專業化。
            - 修改範例
                - 原文：內容雖然簡短，但主題明確。
                    - 修改：雖然內容相對簡短，但主題表達得非常明確。
                - 原文：缺乏實例和具體情境來支持內容。 
                    - 修改：目前缺少具體的實例及情境來支持文章的內容與主張。
                - 原文：可以進一步擴展。
                    - 修改：可以進一步擴展來豐富內容，讓讀者更有共鳴。
        ```json
        {{
            "results": {{
                "主題與內容": {{
                    "level": "A+",
                    "explanation": "#中文解釋 ZH-TW"
                }},
                "遣詞造句": {{
                    "level": "C",
                    "explanation": "#中文解釋 ZH-TW"
                }}
            }}
        }}
        ```

        Restrictions:
        - ALL the content should be in Traditional Chinese (zh-TW), it's very important.
    """

    user_content = f"""
        sys_content: {sys_content_prompt}
        ---
        assignment_prompt: {assignment_prompt}
        ---
        paragraph is: {paragraph}
        ---
        paragraph_evaluate_prompt: {paragraph_evaluate_prompt}
        size_count_prompt: {size_count_prompt}
    """
    total_content_text, content_table = get_chinese_paragraph_evaluate_content(thread_id, model, user_content, paragraph)
    
    return total_content_text, content_table

def get_chinese_paragraph_refine_evaluate_content(
        thread_id, model, 
        chinese_assignment_topic,
        chinese_assignment_introduction, 
        chinese_assignment_description, 
        paragraph_2, 
    ):
    verify_string_length(paragraph_2)
    verify_moderation(paragraph_2)
    verify_string_length_short(paragraph_2)

    size_count_prompt = generate_size_count_prompt(paragraph_2)
    assignment_prompt = generate_assignment_prompt(chinese_assignment_topic, chinese_assignment_introduction, chinese_assignment_description)
    sys_content_prompt = "You are a Chinese teacher who is practicing with me to improve my Chinese writing skill."
    paragraph_evaluate_prompt = f"""
        # 請嚴格根據 instructions
        # Rules: 
        1. 我給你兩篇文章，請進行比較跟批改，並給出建議，如果文章完全一樣，請給出回饋：「這兩篇文章內容完全一樣，無法進行評分。」，後續評分給予 level X，仍要輸出 JSON
        2. 先檢查是否是合理的作文或是段落，再進行評分
        2. 請確保作文或段落的內容完整，並且符合中文語法
        3. 如果是一篇亂打的文章請直接給予回饋：「這篇文章內容不完整，無法進行評分。」
        4. 如果無法進行評分 評分標準與回饋的內容跟等級，則為 X
        5. 針對修改後的評分標準與回饋根據「A+、A、A- 、B+、 B、 B-」等級來評分，最低為 B-

        # Restrictions:
        1. 不用給整體評分
        2. 不用改標點符號
        3. 評分標準的分數等級請使用「A+、A、A- 、B+、 B、 B-」等級，不可使用數字或是其他等級，像是「90分、80分、C、D」等等。
        4. 回傳的 output json 不需要有原文的評分，只需要有修改後的評分

        # Output format:
        1. 先給 綜合回饋、評分標準與回饋、修改範例
        2. 再將評分標準與回饋的內容以JSON格式輸出，並且請使用繁體中文（ZH-TW）來評分段落並輸出，用 ```json ..... ``` 包裹:
        3. please use Chinese language (ZH-TW) to evaluate the paragraph and output use JSON format:
        4. if the score is X, please still follow the format and give the key as level and value as 'X'. then give the explanation in Chinese
        
        EXAMPLE:
        # 綜合回饋（前後比較）
        你的文章...............(寫出一段話，比較兩篇作文的差異)

        # 評分標準與回饋
        主題與內容：B+ 你的主題很明確，講述了CSS在渲染空間上的問題及解決方案，這是一個重要而實用的話題。然而，內容相對較少，缺乏足夠的細節與實例來支撐你的觀點。建議你可以添加一些具體情境或例子，讓讀者更容易理解CSS的應用情況，例如提到常見的渲染問題以及具體的解決方法。

        遣詞造句：A 你的遣詞造句大致良好，用詞得體且通順。不過可以嘗試加一些更具體的技術詞彙或示例，使文章更專業化。

        # 修改範例
        - 原文：內容雖然簡短，但主題明確。
            - 修改：雖然內容相對簡短，但主題表達得非常明確。
        - 原文：缺乏實例和具體情境來支持內容。 
            - 修改：目前缺少具體的實例及情境來支持文章的內容與主張。
        - 原文：可以進一步擴展。
            - 修改：可以進一步擴展來豐富內容，讓讀者更有共鳴。

        ```json
        {{
            "results": {{
                "主題與內容": {{
                    "level": "A+",
                    "explanation": "#中文解釋 ZH-TW"
                }},
                "遣詞造句": {{
                    "level": "C",
                    "explanation": "#中文解釋 ZH-TW"
                }}
            }}
        }}
        ```

        Restrictions:
        - ALL the content should be in Traditional Chinese (zh-TW), it's very important.    
    """
    
    user_content = f"""
        sys_content: {sys_content_prompt}
        ---
        {assignment_prompt}
        refined paragraph is: {paragraph_2}
        ---
        paragraph_evaluate_prompt: {paragraph_evaluate_prompt}   
        size_count_prompt: {size_count_prompt}
    """
    total_content_text, content_table = get_chinese_paragraph_evaluate_content(thread_id, model, user_content, paragraph_2)
    
    return total_content_text, content_table

# 小學作文機器人
def generate_content_by_open_ai_assistant(user_content, thread_id=None, model_name=None):
    verify_moderation(user_content)

    client = CUTOR_OPEN_AI_CLIENT
    assistant_id = CUTOR_OPEN_AI_ASSISTANT_ID

    assistant = client.beta.assistants.update(
        assistant_id=assistant_id,
        tools=[{"type": "file_search"}], 
    )
    print(f"My assistant: {assistant}")
    print(f"instructions: {assistant.instructions}")

    try:
        thread_id = get_chinese_conversation_thread_id(thread_id) if not thread_id else thread_id
        thread = client.beta.threads.retrieve(thread_id)
        print(f"Thread ID: {thread.id}")

        # if metadata:
        #     client.beta.threads.update(thread_id=thread.id, metadata=metadata)

        # Send the user message to the thread
        print("==============Send the user message to the thread====================")
        client.beta.threads.messages.create(thread_id=thread.id, role="user", content=user_content)

        # Run the assistant
        print("==============Run the assistant====================")
        run = client.beta.threads.runs.create_and_poll(
            thread_id=thread.id, 
            assistant_id=assistant.id,
            tools=[{"type": "file_search"}],
        )
        
        if run.status == "completed":
            print("==============completed====================")
            print(f"Thread ID: {thread.id}")
            messages = client.beta.threads.messages.list(thread_id=thread.id)
            print(f"Messages: {messages}")
            response = messages
            response_text = messages.data[0].content[0].text.value
            print(f"Response: {response_text}")
    except Exception as e:
        print(f"An error occurred while generating content by OpenAI Assistant: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return response_text

# 錯別字機器人
def generate_content_by_open_ai_assistant_spelling_robot(paragraph, thread_id=None, model_name=None):   
    verify_moderation(paragraph)

    client = CUTOR_OPEN_AI_CLIENT
    assistant_id = CUTOR_OPEN_AI_ASSISTANT_SPELLING_ID

    assistant = client.beta.assistants.update(
        assistant_id=assistant_id,
        tools=[{"type": "file_search"}], 
    )
    print(f"My assistant: {assistant}")
    print(f"instructions: {assistant.instructions}")

    try:
        thread_id = get_chinese_conversation_thread_id(thread_id) if not thread_id else thread_id
        thread = client.beta.threads.retrieve(thread_id)
        print(f"Thread ID: {thread.id}")

        # Send the user message to the thread
        print("==============Send the user message to the thread====================")
        user_content = f"""
            this is the paragraph: {paragraph}
            ---
            Rule:
            1. 請根據 instructions 來挑出錯別字，並輸出錯別字的等級與解釋
            2. 請輸出錯別字的等級與解釋，並輸出錯別字的等級與解釋 by json format as example
            3. 請用 zh-TW 繁體中文輸出
            4. json 完成之後不用多作解釋
            5. 輸出前，每一段都多做一次確認，確認原文跟修正是否一樣，如果一樣，就不要輸出
            6. 請確定使用繁體中文輸出，並不要使用簡體中文以及中國的用語

            EXAMPLE:
                ### 錯別字檢查： A+
                1. 「產現」應作「產線」。
                    - 原文：「擔任產線主任的老闆弟弟...」
                    - 修正：「擔任產線主任的老闆弟弟...」
                2. 「保母」應作「保姆」。
                    - 原文：「平時不只得充當保母...」
                    - 修正：「平時不只得充當保姆...」

                ```json
                {{
                    "results": {{
                        "錯別字": {{
                            "level": "A+",
                            "explanation": "#中文解釋 ZH-TW"
                        }}
                    }}
                }}
                ```
        """
        client.beta.threads.messages.create(thread_id=thread.id, role="user", content=user_content)

        # Run the assistant
        print("==============Run the assistant====================")
        run = client.beta.threads.runs.create_and_poll(
            thread_id=thread.id, 
            assistant_id=assistant.id,
            tools=[{"type": "file_search"}],
        )
        
        if run.status == "completed":
            print("==============completed====================")
            print(f"Thread ID: {thread.id}")
            messages = client.beta.threads.messages.list(thread_id=thread.id)
            print(f"Messages: {messages}")
            response = messages
            response_text = messages.data[0].content[0].text.value
            print(f"Response: {response_text}")
    except Exception as e:
        print(f"An error occurred while generating content by OpenAI Assistant: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return response_text

# 結構 assistant id
def generate_content_by_open_ai_assistant_structure_robot(paragraph, thread_id=None, model_name=None):
    verify_moderation(paragraph)

    client = CUTOR_OPEN_AI_CLIENT
    assistant_id = CUTOR_OPEN_AI_STRUCTURE_ASSISTANT_ID

    assistant = client.beta.assistants.update(
        assistant_id=assistant_id,
        tools=[{"type": "file_search"}], 
    )
    print(f"My assistant: {assistant}")
    print(f"instructions: {assistant.instructions}")

    try:
        thread_id = get_chinese_conversation_thread_id(thread_id) if not thread_id else thread_id
        thread = client.beta.threads.retrieve(thread_id)
        print(f"Thread ID: {thread.id}")

        # Send the user message to the thread
        print("==============Send the user message to the thread====================")
        user_content = f"""
            this is the paragraph: {paragraph}
            ---
            Rule:
            1. 請根據 instructions 來評分「段落結構」並給出分數
            2. 請輸出 text for 段落結構、段落大意摘要、結構分析質性分析
            3. 並提供的等級與解釋 by json format as example
            4. 請用 zh-TW 繁體中文輸出
            4. json 的 explanation 提供為何給這個分數的解釋，並且輸出段落大意摘要、結構分析
            5. json 完成之後不用多作解釋

            EXAMPLE:
                ### 段落結構： B+
                - 段落大意摘要：這篇文章有四個自然段。
                    1. 描述回家路上的期待感，家是讓人心安的地方。
                    2. 描述推開家門時的溫馨感受和父母的關心。
                    3. 描述家承載的情感與回憶，家是生活的原點和港灣。
                    4. 描述回家後的堅定與勇氣，家人的支持讓人勇敢前行。

                - 結構分析：
                    - 這篇文章的分段合理，共有四段，符合一篇文章分段的建議。
                    - 每段的主題明確，第一段破題，第二、三段描述回家的感受和家中的情感，最後一段總結並抒發自己的感想，結構完整且連貫。
                    - 建議在段落之間使用一些連接詞來強化段落間的關聯性，例如在第二段和第三段之間可以用「此外」來銜接，讓文章更加流暢。
                    - 整體來說，段落結構清晰，主題明確，表現很好。

                ```json
                {{
                    "results": {{
                        "段落結構": {{
                            "level": "A+",
                            "explanation": "#中文解釋 ZH-TW"
                        }}
                    }}
                }}
                ```
        """
        client.beta.threads.messages.create(thread_id=thread.id, role="user", content=user_content)

        # Run the assistant
        print("==============Run the assistant====================")
        run = client.beta.threads.runs.create_and_poll(
            thread_id=thread.id, 
            assistant_id=assistant.id,
            tools=[{"type": "file_search"}],
        )
        
        if run.status == "completed":
            print("==============completed====================")
            print(f"Thread ID: {thread.id}")
            messages = client.beta.threads.messages.list(thread_id=thread.id)
            print(f"Messages: {messages}")
            response = messages
            response_text = messages.data[0].content[0].text.value
            print(f"Response: {response_text}")
    except Exception as e:
        print(f"An error occurred while generating content by OpenAI Assistant: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return response_text

# 小工具
def show_elements():
    return gr.update(visible=True)

def hide_elements():
    return gr.update(visible=False)

def enable_elements():
    return gr.update(interactive=True)

def disable_elements():
    return gr.update(interactive=False)

def duplicate_element(element):
    return element

def generate_chinese_essay_idea(model, user_prompt, chinese_essay_title_input):
    verify_moderation(chinese_essay_title_input)

    sys_content = "你是一位老師，正在和我一起練習提高我的寫作技能。 給予的回覆不超過 500字。 用 Markdown 語法回答。"
    user_content = f"""
        {user_prompt}
        ---
        題目：{chinese_essay_title_input}
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": model,
        "messages": messages,
        "max_tokens": 2000,
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content.strip()
    except Exception as e:
        print(f"An error occurred while generating Chinese essay idea: {e}")
        raise gr.Error("網路塞車，請重新嘗試一次！")

    return content

def check_chinese_essay_feedback(feedback_check_prompt, chinese_essay_from_student_input, chinese_essay_feedback_check_input):
    verify_moderation(chinese_essay_from_student_input)
    verify_moderation(chinese_essay_feedback_check_input)

    verify_string_length_short(chinese_essay_from_student_input)
    verify_string_length_short(chinese_essay_feedback_check_input)

    # 檢查回饋是否符合規範  
    sys_content = f"""
        你是一位專業的中文寫作老師, 正在檢查自己要給學生的作文回饋。
        請根據規範：
        {feedback_check_prompt}
        來檢查回饋是否符合規範。
    """
    user_content = f"""
        這是學生的原文: {chinese_essay_from_student_input}
        這是老師的批改回饋: {chinese_essay_feedback_check_input}
        請根據規範：
        {feedback_check_prompt}
        來檢查老師的批改回饋是否符合規範。
        符合的話則在該項目前面給予 ✅，給予為什麼給過的理由
        不符合的話則在該項目前面給予 ❌，給予為什麼給不過的理由

        並在最後給出🟢🔴🟡 評分，🔴代表不合格，🟡代表需要修改，🟢代表合格。
        再提供修改建議。

        Example:
        ---
        # 規範檢查：
        - ✅ 1. 本篇佳句對該篇文章的正向肯定或佳句摘選 > 10 字 
            - 原因：對文章的正向肯定或佳句摘選。
        - ✅ 2. 潤飾句子、刪冗詞贅字與修正錯別字、標點符號(提取文中使用得當的詞彙/提供不適合的詞綴替代字) > 5 字 
            - 原因：提供了刪除冗詞及修正錯別字的內容。
        - ❌ 3. 檢視文章結構、段落安排是否完整、具有連貫性 > 10 字 
            - 原因：未見有關文章結構與段落安排的評語。
        - ❌ 4. 評語:予以鼓勵，指出可精進方向 > 100 字 
            - 原因：評語「寫得很好，還可以更好」遠不足 100 字，且未有具體指出可精進之處。

        # 檢測結果：（🟢🔴🟡）

        # 修改建議：
        - ...
        - ...
    """
    
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": "gpt-4o",
        "messages": messages,
        "max_tokens": 2000,
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        content = response.choices[0].message.content.strip()
    except Exception as e:
        print(f"檢查中文作文回饋時發生錯誤: {e}")
        raise gr.Error("網路塞車,請稍後重試!")

    return content
    


# Download doc
def create_word(content):
    unique_filename = str(uuid.uuid4())
    word_file_path = f"/tmp/{unique_filename}.docx"
    doc = Document()
    doc.add_paragraph(content)
    doc.save(word_file_path)
    return word_file_path

def download_content(content):
    word_path = create_word(content)
    return word_path


# === INIT PARAMS ===
def init_params(request: gr.Request):
    if request:
        print("Request headers dictionary:", request.headers)
        print("IP address:", request.client.host)
        print("Query parameters:", dict(request.query_params))
        # url = request.url
        print("Request URL:", request.url)
        
        admin_group = gr.update(visible=False)
        english_group = gr.update(visible=True)
        chinese_group = gr.update(visible=True)
        assignment_group = gr.update(visible=False)

        user_data = gr.update(value="")
        user_email = gr.update(value="")
        user_nickname = gr.update(value="")

        # check if origin is from junyiacademy
        # check if origin is from junyiacademy
        query_params = dict(request.query_params)
        request_origin = request.headers.get("origin", "").replace("https://", "").replace("http://", "")
        print(f"request_origin: {request_origin}")
        allowed_request_origins = [
            "junyiacademy.org", 
            "junyiacademy.appspot.com", 
            "colearn30.com", # 樂寫網
            "hf.space",
        ]
        if any(allowed_origin in request_origin for allowed_origin in allowed_request_origins) or is_env_local:
            pass
        else:
            raise gr.Error("Invalid origin")
        
        # admin_group visible in local
        if is_env_local:
            admin_group = gr.update(visible=True)
            user_data = gr.update(value="aa")
            user_email = gr.update(value="[email protected]")
            user_nickname = gr.update(value="aa_name")

        if "hf.space" in request_origin:
            admin_group = gr.update(visible=True)
            user_data = gr.update(value="aa")
            user_email = gr.update(value="[email protected]")
            user_nickname = gr.update(value="aa_name")

        # session timestamp 用 2024-01-01-12-00-00 格式, 要用 UTC+8 時間
        session_timestamp = datetime.now(pytz.utc).astimezone(pytz.timezone('Asia/Taipei')).strftime("%Y-%m-%d-%H-%M-%S")

        if "language" in query_params and query_params["language"] == "english":
                print(f"language: english")
                english_group = gr.update(visible=True)
                chinese_group = gr.update(visible=False)
                assignment_group = gr.update(visible=False)
        
        if "language" in query_params and query_params["language"] == "chinese":
                print(f"language: chinese")
                english_group = gr.update(visible=False)
                chinese_group = gr.update(visible=True)
                assignment_group = gr.update(visible=False)

        if "assignment_mode" in query_params and query_params["assignment_mode"] == "true":
            english_group = gr.update(visible=False)
            chinese_group = gr.update(visible=False)
            assignment_group = gr.update(visible=True)

        assignment_id_value = None
        assignment_json_value = None
        if "assignment" in query_params:
            assignment_id_value = query_params["assignment"]
            assignment_json_value = get_assignment_content(assignment_id_value)

            if assignment_json_value and assignment_json_value.get("assignment_type") == "中文寫作 AI 批改":
                chinese_assignment_row = gr.update(visible=True)
                chinese_assignment_grade = gr.update(value=assignment_json_value.get("metadata", {}).get("grade", ""))
                chinese_assignment_topic = gr.update(value=assignment_json_value.get("metadata", {}).get("topic", ""))
                chinese_assignment_introduction = gr.update(value=assignment_json_value.get("metadata", {}).get("introduction", ""))
                chinese_assignment_description = gr.update(value=assignment_json_value.get("metadata", {}).get("description", ""))
                submission_deadline = assignment_json_value.get("metadata", {}).get("submission_deadline", "")
                # submission_deadline 轉成 y-m-d H:M
                submission_deadline_value = submission_deadline_value = get_assignment_formatted_deadline(submission_deadline)
                chinese_assignment_submission_deadline = gr.update(value=submission_deadline_value)

                print(f"chinese_assignment_submission_deadline: {chinese_assignment_submission_deadline}")
            else:
                chinese_assignment_row = gr.update(visible=False)
                chinese_assignment_grade = gr.update(value="")
                chinese_assignment_topic = gr.update(value="")
                chinese_assignment_introduction = gr.update(value="")
                chinese_assignment_description = gr.update(value="")
                chinese_assignment_submission_deadline = gr.update(value="")

            assignment_id_input = gr.update(value=assignment_id_value)
            assignment_json = gr.update(value=assignment_json_value)
        else:
            # 處理沒有 assignment 參數的情況
            chinese_assignment_row = gr.update(visible=False)
            chinese_assignment_grade = gr.update(value="")
            chinese_assignment_topic = gr.update(value="")
            chinese_assignment_introduction = gr.update(value="")
            chinese_assignment_description = gr.update(value="")
            chinese_assignment_submission_deadline = gr.update(value="")
            assignment_id_input = gr.update(value=None)
            assignment_json = gr.update(value=None)
        
    return user_data, user_email, user_nickname, \
            admin_group, session_timestamp, request_origin, \
            assignment_id_input, assignment_json, \
            chinese_assignment_row, \
            chinese_assignment_grade, \
            chinese_assignment_topic, \
            chinese_assignment_introduction, \
            chinese_assignment_description, \
            chinese_assignment_submission_deadline, \
            english_group, chinese_group, assignment_group

CSS = """
    .accordion-prompts {
        background-color: orange;
    }
"""

english_header_init_btn_js = """
        document.getElementById("english_grapragh_practice_row").style.display = "none";
        document.getElementById("english_grapragh_evaluate_row").style.display = "none";
        document.getElementById("english_exam_practice_row").style.display = "none";
        document.getElementById("english_logs_row").style.display = "none";
        document.getElementById("english_grapragh_practice_button").classList.remove("primary");
        document.getElementById("english_grapragh_evaluate_button").classList.remove("primary");
        document.getElementById("english_exam_practice_tab_button").classList.remove("primary");
        document.getElementById("english_logs_tab_button").classList.remove("primary");
"""
english_grapragh_practice_button_js = f"""
    function english_grapragh_practice_button_click() {{
        {english_header_init_btn_js}
        document.getElementById("english_grapragh_practice_row").style.display = "block";
        document.getElementById("english_grapragh_practice_button").classList.add("primary");
        return true;
    }}
""" 
english_grapragh_evaluate_button_js = f"""
    function english_grapragh_evaluate_button_click() {{
        {english_header_init_btn_js}
        document.getElementById("english_grapragh_evaluate_row").style.display = "block";
        document.getElementById("english_grapragh_evaluate_button").classList.add("primary");
        return true;
    }}
"""
english_exam_practice_tab_button_js = f"""
    function english_exam_practice_tab_button_click() {{
        {english_header_init_btn_js}
        document.getElementById("english_exam_practice_row").style.display = "block";
        document.getElementById("english_exam_practice_tab_button").classList.add("primary");
        return true;
    }}
"""
english_logs_tab_button_js = f"""
    function english_logs_tab_button_click() {{
        {english_header_init_btn_js}
        document.getElementById("english_logs_row").style.display = "block";
        document.getElementById("english_logs_tab_button").classList.add("primary");
        return true;
    }}
"""

THEME = gr.themes.Glass(
        primary_hue=gr.themes.colors.blue, 
        secondary_hue=gr.themes.colors.orange,
        text_size=gr.themes.sizes.text_lg
    ).set(
        button_primary_background_fill="*primary_300",
        button_shadow="*block_shadow",
        button_shadow_hover="*block_shadow"
    )

with gr.Blocks(theme=THEME, css=CSS) as demo:

    with gr.Row(visible=False) as admin_group:
        user_data = gr.Textbox(label="User Data", value="", elem_id="jutor_user_data_input")
        user_email = gr.Textbox(label="User Email", value="", elem_id="jutor_user_email_input")
        user_nickname = gr.Textbox(label="User Nickname", value="", elem_id="jutor_user_nickname_input")
        session_timestamp = gr.Textbox(label="Session Timestamp", value="", elem_id="jutor_session_timestamp_input")
        request_origin = gr.Textbox(label="Request Domain", value="")
        assignment_id_input = gr.Textbox(label="Assignment ID", value="", elem_id="jutor_assignment_id_input")
        assignment_json = gr.JSON(label="Assignment JSON", elem_id="jutor_assignment_json_input")

    with gr.Row(visible=False) as english_group:
        with gr.Column():
            with gr.Row() as page_title_english:
                with gr.Column():
                    with gr.Row():
                        with gr.Column():
                            gr.Markdown("# 🔮 JUTOR 英文段落寫作練習")
                        with gr.Column():
                            gr.HTML("""
                                <span style="text-align: center;">
                                    <a href="https://www.facebook.com/groups/jutor" target="_blank" style=" font-size: 14px; color="blue";> 🇫 加入 Facebook 討論社團</a>
                                </span>
                            """)
                    with gr.Row():
                        with gr.Column():
                            english_grapragh_practice_button = gr.Button("📝 英文段落寫作練習", variant="primary", elem_id="english_grapragh_practice_button")
                        with gr.Column():
                            english_grapragh_evaluate_button = gr.Button("📊 英文段落寫作評分", variant="", elem_id="english_grapragh_evaluate_button")
                        with gr.Column():
                            english_exam_practice_tab_button = gr.Button("🎯 英文考古題寫作練習", variant="", elem_id="english_exam_practice_tab_button")
                        with gr.Column():
                            english_logs_tab_button = gr.Button("📚 歷程回顧", variant="", elem_id="english_logs_tab_button")
            # ===== 英文段落寫作練習 =====
            with gr.Row(visible=True, elem_id="english_grapragh_practice_row") as english_grapragh_practice_row:
                with gr.Column():
                    with gr.Row():
                        gr.Markdown("# 📝 英文段落寫作練習")
                    with gr.Row():
                        with gr.Column():
                            gr.Image(value="https://storage.googleapis.com/jutor/Jutor%E6%AE%B5%E8%90%BD%20banner.jpg", show_label=False, show_download_button=False)
                        with gr.Column():
                            with gr.Accordion("📝 為什麼要學英文寫作架構？學測英文作文評分標準的啟示", open=False):
                                gr.Markdown("""
                                    ### 我們相信學習英文段落寫作基礎架構，必能幫助你在學測英文作文的內容、結構項目有好的表現。目前「大學學科能力測驗」的英文作文項目要求考生寫兩個段落，如果能書寫有清晰組織架構、強而有力的段落，你必然能在競爭激烈的環境中脫穎而出。
                                    ### 學測英文作文評分標準在內容、組織兩項目（計10分）的要求：「開頭、發展、結尾、主題清楚，相關細節支持、連貫一致、轉承語」。因此，「JUTOR 英文段落寫作平台」將幫助你從主題句「開頭」，然後「發展」支持句，最後「結尾」寫結論句。藉由基礎架構：讓「主題」清楚，具有「相關細節支持」，確保作文「連貫一致」，並在最後輔助正確使用「轉承語」。
                                    ### 此外，由於英文段落是一切英文寫作的基礎，成功駕馭段落是掌握不同形式英文寫作的關鍵，諸如語言能力測驗、郵件、部落格貼文、報告、論文等。然而英文段落有其特殊的架構與表達方式，與中文大不相同。你如果使用 ChatGPT 將中文文章翻譯成英文，你會發現 ChatGPT 會按照英文慣例，先在中文文章中找尋「主題句」並移至段落開頭處，顯現中、英文段落寫作的明顯差異。
                                    ### 我們創建這個平台旨在為你提供一個良好的學習環境，通過啟發和挑戰，幫助你逐步提升英文段落寫作的技能。無論初學者還是有一定經驗的寫作者，我們都盡力為你提供所需的學習資源，助你突破學習瓶頸。
                                    ### 謝謝你選擇使用我們的平台，讓我們攜手前行，一起開始這段寫作之旅吧！Cheers!
                                """)
                            with gr.Accordion("📝 英文作文跟中文作文的差異？", open=False):
                                gr.Image(value="https://storage.googleapis.com/jutor/jutor_en_chinese.jpg", show_label=False, show_download_button=False)

                    # ===== 基礎級使用者 =====
                    with gr.Row(visible=False) as default_params:
                        model = gr.Radio(["gpt-4o", "gpt-4-turbo"], label="Model", value="gpt-4o")
                        max_tokens = gr.Slider(minimum=50, maximum=4000, value=4000, label="Max Tokens")
                        sys_content_input = gr.Textbox(label="System Prompt", value="You are an English teacher who is practicing with me to improve my English writing skill.")
                    with gr.Row():
                        eng_level_input = gr.Radio([("初學", "beginner"), ("進階", "advanced")], label="English Level", value="beginner")

                    # basic inputs 主題與情境
                    with gr.Group():
                        with gr.Row(visible=False) as scenario_params:
                            with gr.Column():
                                
                                with gr.Row():
                                    gr.Markdown("# Step 1. 你今天想練習寫什麼呢？")
                                with gr.Row():
                                    gr.Markdown("""## 寫作的主題與讀者、寫作的目的、文章的風格、長度、範圍、以及作者的專業知識等都有關係。因為不容易找主題，所以利用兩階段方式來找主題。特為較無英文寫作經驗的  基礎級使用者 提供多種大範圍情境，待篩選情境後，下一步再來決定明確的主題。""")
                                with gr.Row():
                                    with gr.Column():
                                        scenario_input = gr.Textbox(label="先選擇一個大範圍的情境或是自定義：")
                                    with gr.Column():
                                        scenario_values = [
                                            "Health",
                                            "Thanksgiving",
                                            "Halloween",
                                            "moon festival in Taiwan",
                                            "School and Learning",
                                            "Travel and Places",
                                            "Family and Friends",
                                            "Hobbies and Leisure Activities",
                                            "Health and Exercise",
                                            "Personal Experiences",
                                            "My Future Goals",
                                            "School Life",
                                            "Pets",
                                            "A Problem and Solution",
                                            "Holidays and Celebrations",
                                            "My Favorite Cartoon/Anime"
                                        ]
                                        scenario_radio_button = gr.Radio(scenario_values, label="Scenario", elem_id="scenario_button")

                                        scenario_radio_button.select(
                                            fn=update_scenario_input,
                                            inputs=[scenario_radio_button],
                                            outputs=[scenario_input]
                                        )

                    # Step 1. 確定段落主題
                    with gr.Row():
                        with gr.Column():      
                            with gr.Row():
                                gr.Markdown("# Step 1. 確定段落主題")
                            with gr.Row():
                                with gr.Column():
                                    gr.Markdown("""## 主題是整個段落要探討、闡述的主要議題。確定主題對於段落的架構、內容非常重要。""")
                                # with gr.Column():
                                #     with gr.Accordion("參考指引：情境與主題如何搭配呢？", open=False):
                                #         gr.Markdown("""
                                #         例如，情境是 `School & Learning` ，你可以依照自己的興趣、背景及經驗，決定合適的主題，像是：`My First Day at School` 或 `The Role of Internet in Learning`
                                #         例如，情境是 `Climate Change`，相關主題可能是 `Global Warming` 或 `Extreme Weather Events`
                                #     """)
                            with gr.Row(visible=False) as topic_params:
                                default_generate_topics_prompt = """
                                    The topic is the main issue that the entire paragraph aims to discuss and elaborate on. 
                                    Determining the topic is crucial for the structure and content of the paragraph.
                                    For example, if the context is School & Learning, you can decide on an appropriate topic based on your interests, background, and experiences, such as My First Day at School or The Role of the Internet in Learning. 
                                    If the context is Climate Change, related topics could be Global Warming or Extreme Weather Events.

                                    Give me 10 randon topics, 
                                    for a paragraph. Just the topics, no explanation, use English language base on  eng_level. 
                                    Make sure the vocabulary you use is at eng_level.
                                    output use JSON 
                                    EXAMPLE:
                                    "topics":["topic1", "topic2", "topic3", "topic4", "topic5", "topic6", "topic7", "topic8", "topic9", "topic10"]
                                """
                                user_generate_topics_prompt = gr.Textbox(label="Topics Prompt", value=default_generate_topics_prompt, visible=False)
                            with gr.Row():
                                with gr.Column():
                                    topic_input = gr.Textbox(label="自訂主題")
                                with gr.Column():
                                    generate_topics_button = gr.Button("✨ JUTOR 隨機產出 10 個段落主題，挑選一個來練習吧！", variant="primary")
                                    topic_output = gr.Radio(label="AI 產出主題", visible=False, interactive=True)
                                        
                                    generate_topics_button.click(
                                        fn=show_elements,
                                        inputs=[],
                                        outputs=[topic_output]
                                    ).then(
                                        fn=generate_topics,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            user_generate_topics_prompt
                                        ],
                                        outputs=[topic_output]
                                    )

                                    topic_output.select(
                                        fn=update_topic_input,
                                        inputs=[topic_output],
                                        outputs=[topic_input]
                                    )

                    
                    # Step 2. 寫出關鍵字
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as points_params:
                                default_generate_points_prompt = """
                                    Based on the topic and eng_level setting, think about the direction and content of the paragraph, then present it using some related points/keywords. 
                                    For example, the topic: "The Benefits of Learning a Second Language." The direction and content: Learning a second language, such as Japanese, allows you to communicate with Japanese people and understand Japanese culture. 
                                    Therefore, the points/keywords are "Improving communication skills" and "Understanding other cultures." ....
                                    Please provide main points to develop in a paragraph about topic in the context of scenario, 
                                    use simple English language and make sure the vocabulary you use is at eng_level.
                                    No more explanation either no developing these points into a simple paragraph.
                                    Output use JSON format
                                    EXAMPLE:
                                    {{
                                        "points":["point1", "point2", "point3"]
                                    }}
                                """  
                                user_generate_points_prompt = gr.Textbox(label="Points Prompt", value=default_generate_points_prompt, visible=False)
                            with gr.Row() as points_html:
                                gr.Markdown("# Step 2. 找要點/關鍵字")
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        gr.Markdown("## 根據主題，思考段落的方向及內容，然後用兩個要點／關鍵字來呈現。例如主題：\"The Benefits of Learning a Second Language\" 「學習第二種語言的好處」，內容及方向：因為學習第二種語言，例如日語，就可以和日本人溝通，進而學習瞭解日本文化，因而要點／關鍵字就是 \"Improving communication skills\" 「提升溝通能力」及 \"Understanding other cultures\" 「瞭解其他文化」。")
                                    with gr.Row():
                                        gr.Markdown("## 如果不知道要寫什麼，也可以讓Jutor提供要點／關鍵字，以兩個要點／關鍵字為限。")
                                with gr.Column():
                                    with gr.Row():
                                        with gr.Accordion("📝 參考指引：要點／關鍵字的重要性？", open=False):
                                            gr.Markdown("""
                                                ### 寫段落時先決定要點／關鍵字很重要，因為這能確保段落內容連貫一致。
                                                1. 保持主題一致: 確定要點可以幫助作者集中在主題上，不會偏離主題，使段落更有一致性。
                                                2. 提高清晰度: 明確的要點能幫助讀者迅速理解段落的主旨，避免混淆。
                                                3. 組織結構: 有明確的要點，作者可以更容易組織自己的想法，使段落結構清晰、有邏輯。
                                                4. 省時省力: 先決定要點可以減少修改和重寫的次數，提高寫作效率。
                                            """)
                            with gr.Row():
                                with gr.Column():
                                    points_input = gr.Textbox(label="寫出要點／關鍵字")
                                with gr.Column():
                                    generate_points_button = gr.Button("✨ 找尋靈感？使用 JUTOR 產生要點／關鍵字", variant="primary")
                                    points_output = gr.Radio(label="AI 產出要點／關鍵字", visible=False, interactive=True)                        
                                    generate_points_button.click(
                                        fn=show_elements,
                                        inputs=[],
                                        outputs=[points_output]
                                    ).then(
                                        fn=generate_points,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            topic_input,
                                            user_generate_points_prompt
                                        ],
                                        outputs=points_output
                                    )
                                    
                                    points_output.select(
                                        fn=update_points_input,
                                        inputs=[points_output],
                                        outputs=[points_input]
                                    )
                    
                    # Step 3. 選定主題句
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as topic_sentences_params:
                                default_generate_topic_sentences_prompt = """
                                    Please provide one appropriate topic sentence that aptly introduces the subject for the given scenario and topic. 
                                    Additionally, provide two topic sentences that, while related to the topic, 
                                    would be considered inappropriate or less effective for the specified context. 
                                    Those sentences must include the three main points:". 
                                    Use English language and each sentence should not be too long.
                                    For each sentence, explain the reason in Traditional Chinese, Taiwan, 繁體中文 zh-TW. 
                                    Make sure the vocabulary you use is at level.

                                    Output use JSON format

                                    EXAMPLE:
                                    "results": 
                                        [
                                            {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }} , 
                                            {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }},
                                            {{ "topic-sentence": "#","appropriate": "Y/N", "reason": "#中文解釋" }}
                                        ]       
                                """
                                user_generate_topic_sentences_prompt = gr.Textbox(label="Topic Sentences Prompt", value=default_generate_topic_sentences_prompt, visible=False)

                            with gr.Row() as topic_sentences_html:    
                                gr.Markdown("# Step 3. 寫主題句")
                            with gr.Row():      
                                with gr.Column():
                                    gr.Markdown("## 主題句（Topic Sentence）通常位於段落的開頭，幫助讀者迅速理解段落的內容。是段落中最重要的句子，介紹主題並含括段落的所有要點／關鍵字。")
                                    gr.Markdown("## 書寫段落時，必須確保每個句子都支持和闡述主題句，避免引入無關或偏離主題的討論，否則就會影響段落的架構及內容的一致性及連貫性。")
                                with gr.Column():
                                    with gr.Accordion("📝 參考指引：主題句樣例", open=False):
                                        gr.Markdown("""
                                            ### 主題句應該清晰、具體、明確，讓讀者一眼就能明白段落的內容及方向。

                                            - ✅ 合適的主題句：
                                                - Learning a second language improves communication skills and helps you understand other cultures better.
                                                - `Benefits of learning a second language` 是主題， `improving communication skills和 understanding other cultures` 則是兩個要點／關鍵字。

                                            - ❌ 不合適的主題句：
                                                - 樣例1：Reading is important.
                                                    - 解釋: 主題句過於籠統，應具體說明讀書重要性或影響。
                                                    - 改寫: Reading helps improve our thinking, making it a very important habit.
                                                - 樣例2：Today is a sunny day.
                                                    - 解釋: 主題句缺乏主要論點，無法指引段落內容。
                                                    - 改寫: The sunny weather today is perfect for outdoor activities.
                                                - 樣例3：I watched a movie yesterday.
                                                    - 解釋: 主題句不夠具體也缺乏深度，應介紹電影內容或觀後感。
                                                    - 改寫: Yesterday, I watched an interesting movie that made me think about human relationships.
                                                - 樣例4：There are many restaurants in this city.
                                                    - 解釋: 主題句過於籠統，應具體說明餐廳的特色或影響。
                                                    - 改寫: This city has many different restaurants, each offering unique food to attract different customers.
                                                    """)
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        topic_sentence_input = gr.Textbox(label="根據主題、要點/關鍵字來寫主題句")
                                    with gr.Row():
                                        default_generate_topic_sentence_input_feedback_prompt = """
                                            Rules:
                                            - 主題句（Topic Sentence）通常位於段落的開頭，幫助讀者迅速理解段落的內容。是段落中最重要的句子，介紹主題(topic)並含括段落的所有要點／關鍵字(points)。
                                            - 例如："Learning a second language improves communication skills and helps you understand other cultures better." "The Benefits of Learning a second language"是主題， "improving communication skills" 和 "understanding other cultures" 則是兩個要點／關鍵字。
                                            - 書寫段落時，必須確保每個句子都支持和闡述主題句，避免引入無關或偏離主題的討論，否則就會影響段落的架構及內容的一致性及連貫性。
                                            
                                            Please check my written topic sentence, it should introduces the subject for the given topic and points and follow the rules.
                                            using Zh-TW to explain the reason. 
                                            please don't give any correct topic sentence as an example in the feedback.

                                            EXAMPLE:
                                            - 主題: "My Favorite Animal"
                                            - 要點/關鍵字： "Dogs are friendly," 
                                            - 你寫的主題句: {{xxxxxx}}
                                            
                                            - 分析結果：✅ 主題句合適/ ❌ 主題句並不合適 
                                            - 解釋： {{中文解釋}}
                                        """
                                        user_generate_topic_sentence_input_feedback_prompt = gr.Textbox(label="Feedback Prompt", value=default_generate_topic_sentence_input_feedback_prompt, visible=False)
                                        topic_sentence_input_feedback_button = gr.Button("✨ 提交主題句，獲得反饋", variant="primary")
                                    with gr.Row():
                                        topic_sentence_input_feedback_text = gr.Textbox(label="Feedback")

                                    topic_sentence_input_feedback_button.click(
                                        fn=generate_topic_sentence_feedback,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            topic_input,
                                            points_input,
                                            topic_sentence_input,
                                            user_generate_topic_sentence_input_feedback_prompt
                                        ],
                                        outputs=[topic_sentence_input_feedback_text]
                                    )
                                with gr.Column():
                                    generate_topic_sentences_button = gr.Button("✨ JUTOR 產出三個主題句，選出一個最合適的", variant="primary")
                                    topic_sentence_output_json = gr.JSON(label="AI 產出主題句", visible=False)
                                    topic_sentence_output_radio = gr.Radio(label="AI 產出主題句", interactive=True, visible=False)
                                    topic_sentences_suggestions = gr.HTML(visible=False)
                                    
                                    generate_topic_sentences_button.click(
                                        fn=show_elements,
                                        inputs=[],
                                        outputs=[topic_sentence_output_radio]
                                    ).then(
                                        fn=hide_elements,
                                        inputs=[],
                                        outputs=[topic_sentences_suggestions]
                                    ).then(
                                        fn=generate_topic_sentences,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            topic_input,
                                            points_input,
                                            user_generate_topic_sentences_prompt
                                        ],
                                        outputs=[topic_sentence_output_json, topic_sentence_output_radio]
                                    )

                                    topic_sentence_output_radio.select(
                                        fn=update_topic_sentence_input, 
                                        inputs=[topic_sentence_output_json, topic_sentence_output_radio], 
                                        outputs= [topic_sentence_input, topic_sentences_suggestions]
                                    )
                    
                    # Step 4.寫出支持句
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as supporting_sentences_params:
                                default_generate_supporting_sentences_prompt = """
                                    I'm aiming to improve my writing. I have a topic sentence as topic_sentence_input. 
                                    Please assist me by "Developing supporting detials" based on the keyword: points to write three sentences as an example.

                                    Rules:
                                    - Make sure any revised vocabulary aligns with the eng_level. 
                                    - Guidelines for Length and Complexity: 
                                    - Please keep the example concise and straightforward, 

                                    Restrictions:
                                    - avoiding overly technical language. 
                                    - Total word-count is around 50. no more explanation either no more extra non-relation sentences.
                                    - just output supporting sentences, don't output topic sentence at this step.
                                    - don't output bullet points, just output sentences.
                                    - don't number the sentences.

                                    EXAMPLE:
                                    - Washing your hands often helps you stay healthy. It removes dirt and germs that can make you sick. Clean hands prevent the spread of diseases. You protect yourself and others by washing your hands regularly.
                                """
                                user_generate_supporting_sentences_prompt = gr.Textbox(label="Supporting Sentences Prompt", value=default_generate_supporting_sentences_prompt, visible=False)
                            
                            with gr.Row() as supporting_sentences_html:
                                gr.Markdown("# Step 4. 寫出支持句")
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        gr.Image(value="https://storage.googleapis.com/jutor/jutor_support_image_1.jpg", show_label=False, show_download_button=False)
                                    with gr.Row():
                                        gr.Markdown("## 請根據主題句及段落要點／關鍵字，來寫支持句。")
                                    with gr.Row():
                                        gr.Markdown("## 支持句必須詳細描寫、記敘、説明、論證段落的要點／關鍵字，必要時舉例説明，來支持佐證主題句。支持句應該按照邏輯順序來組織，例如時間順序、空間順序、重要性順序、因果關係等。並使用轉折詞來引導讀者從一個 idea 到下一個 idea，讓讀者讀起來很順暢，不需反覆閱讀。")
                                with gr.Column():
                                    with gr.Accordion("📝 參考指引：撰寫支持句的方法？", open=False):
                                        gr.Markdown("""
                                            - Explanation 解釋説明：說明居住城市的優點，例如住在城市可享受便利的交通。
                                            - Fact 陳述事實：説明運動可以增強心肺功能和肌肉力量，對於身體健康有正面影響。
                                            - Cause and Effect 原因結果：解釋為何必須家事分工，例如家事分工更容易維護家庭環境的整齊清潔。
                                            - Compare and Contrast 比較與對比：將主題與其他相關事物進行比較。例如比較傳統教學與線上學習。
                                            - Incident 事件：利用事件來做説明。例如誤用表情符號造成困擾的事件，或葡式蛋塔風行的跟瘋事件。
                                            - Evidence 提供證據：引用相關數據、研究或事實來佐證。例如全球互聯網用戶數已經突破了 50 億人，佔全球總人口近 65%。
                                            - Example 舉例：舉自家為例，説明如何將家事的責任分配給每個家庭成員。
                                        """)
                                    with gr.Accordion("參考指引：針對要點/關鍵字的支持句，要寫幾句呢？", open=False):
                                        gr.Markdown("""
                                            - 一個要點/關鍵字，寫 3-6 句
                                            - 兩個要點/關鍵字，每個寫 2-3 句
                                            - 三個要點/關鍵字，每個寫 1-2 句
                                        """)
                            with gr.Row():
                                with gr.Column():
                                    supporting_sentences_input = gr.Textbox(label="根據要點/關鍵字來寫支持句")
                                with gr.Column():
                                    generate_supporting_sentences_button = gr.Button("✨ JUTOR 產出支持句，供參考並自行寫出支持句", variant="primary")
                                    supporting_sentences_output = gr.Radio(label="AI 產出支持句", elem_id="supporting_sentences_button", visible=False, interactive=True)
                                
                                    generate_supporting_sentences_button.click(
                                        fn=show_elements,
                                        inputs=[],
                                        outputs=[supporting_sentences_output]
                                    ).then(
                                        fn=generate_supporting_sentences,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            topic_input, 
                                            points_input,
                                            topic_sentence_input,
                                            user_generate_supporting_sentences_prompt
                                        ],
                                        outputs=supporting_sentences_output
                                    )

                                    supporting_sentences_output.select(
                                        fn=update_supporting_sentences_input, 
                                        inputs=[supporting_sentences_output], 
                                        outputs= [supporting_sentences_input]
                                    )
                    
                    # Step 5. 寫出結論句
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as conclusion_sentences_params:
                                default_generate_conclusion_sentence_prompt = """
                                    I'm aiming to improve my writing. 
                                    By the topic sentence, please assist me by "Developing conclusion sentences" 
                                    based on keywords of points to finish a paragrpah as an example.
                                    
                                    Rules:
                                    - Make sure any revised vocabulary aligns with the correctly eng_level. 
                                    - Guidelines for Length and Complexity: 
                                    - Please keep the example concise and straightforward, 
                                    - Total word-count is around 20. 

                                    Restrictions:
                                    - avoiding overly technical language. 
                                    - no more explanation either no more extra non-relation sentences. this is very important.

                                    Output use JSON format
                                    EXAMPLE:
                                    {{"results": "Thus, drinking water every day keeps us healthy and strong."}}
                                """
                                user_generate_conclusion_sentence_prompt = gr.Textbox(label="Conclusion Sentence Prompt", value=default_generate_conclusion_sentence_prompt, visible=False)
                            
                            with gr.Row() as conclusion_sentences_html:
                                gr.Markdown("# Step 5. 寫出結論句")
                            with gr.Row():
                                with gr.Column():
                                    gr.Markdown("## 簡潔重申段落主旨，可以用重述主題句、摘要支持句、回應或評論主題句（例如強調重要性或呼籲採取行動）等方式來寫。")
                                with gr.Column():
                                    with gr.Accordion("📝 參考指引：撰寫「結論句」的方法？", open=False):
                                        gr.Markdown("""
                                            - 以換句話說 (paraphrase) 的方式把主題句再說一次
                                            - 摘要段落要點方式寫結論句
                                            - 回應或評論主題句的方式來寫結論句（例如主題句要從事課外活動，就說課外活動有這麼多好處，應該多參加課外活動等等）
                                        """)
                            with gr.Row():
                                with gr.Column():
                                    conclusion_sentence_input = gr.Textbox(label="根據主題句、支持句來寫結論句")
                                with gr.Column():
                                    generate_conclusion_sentence_button = gr.Button("✨ JUTOR 產出結論句，供參考並自行寫出結論句", variant="primary")
                                    conclusion_sentence_output = gr.Radio(label="AI 產出結論句", visible=False, interactive=True)

                                    generate_conclusion_sentence_button.click(
                                        fn=show_elements,
                                        inputs=[],
                                        outputs=[conclusion_sentence_output]
                                    ).then(
                                        fn=generate_conclusion_sentences,
                                        inputs=[
                                            model, 
                                            max_tokens, 
                                            sys_content_input, 
                                            scenario_input, 
                                            eng_level_input,
                                            topic_input, 
                                            points_input,
                                            topic_sentence_input,
                                            user_generate_conclusion_sentence_prompt
                                        ],
                                        outputs=conclusion_sentence_output
                                    )

                                    conclusion_sentence_output.select(
                                        fn=update_conclusion_sentence_input, 
                                        inputs=[conclusion_sentence_output], 
                                        outputs= [conclusion_sentence_input]
                                    )
                    
                    # Step 6. 段落確認與修訂
                    with gr.Row():
                        with gr.Column():
                            with gr.Row():
                                gr.Markdown("# Step 6. 段落確認與修訂")
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        gr.Image(value="https://storage.googleapis.com/jutor/jutor_paragraph_evaluate.jpg", show_label=False, show_download_button=False)
                                    with gr.Row():
                                        gr.Markdown("""## 你已經完成段落草稿，可再檢視幾次：
                                                    ### 1. 找出文法、拼字或標點錯誤
                                                    ### 2. 需要之處加入合適的轉折詞，例如：first, second, however, moreover, etc.
                                                    ### 3. 整個段落是否連貫、流暢、容易理解
                                                """)
                                with gr.Column():
                                    with gr.Accordion("📝 參考指引：什麼是段落的連貫性？", open=False):
                                        gr.Markdown("""
                                            - 能夠以清晰、邏輯的方式表達自己的想法，使讀者易於理解。
                                            - 連貫的段落應該有一個清晰的主題句來介紹主要想法（main idea），接著是支持句，提供更多細節和例子來支持主題句。
                                            - 支持句應該按照邏輯制序，引導讀者從一個idea順利讀懂下一個idea。
                                            - 有些句子間邏輯關係不清楚，還需要使用轉折詞（邏輯膠水）做連結，來引導讀者，例如：
                                                - first, second, finally 表示段落要點的秩序
                                                - moreover, furthermore, additionally 表示介紹另外一個要點
                                                - however, nevertheless 表示下面句子是相反的關係
                                                - therefore, as a result表示下面句子是結果
                                                - in comparison, by contrast表示下面句子比較的關係
                                                - for example, for instance 表示下面句子是舉例
                                            - 最後，段落應該有一個結論句，總結主要觀點，強化所要傳遞的資訊。
                                        """)
                            with gr.Row():
                                generate_paragraph_button = gr.Button("請點擊此按鈕，合併已填寫的句子為草稿，供閱讀、下載及修訂", variant="primary")
                            with gr.Row():
                                with gr.Column():
                                    paragraph_output = gr.TextArea(label="完整段落", show_copy_button=True)
                                with gr.Column():
                                    paragraph_output_download = gr.File(label="下載段落草稿")

                                generate_paragraph_button.click(
                                    fn=show_elements,
                                    inputs=[],
                                    outputs=[paragraph_output]
                                ).then(
                                    fn=generate_paragraph,
                                    inputs=[
                                        topic_sentence_input,
                                        supporting_sentences_input, 
                                        conclusion_sentence_input
                                    ],
                                    outputs=paragraph_output
                                ).then(
                                    fn=download_content,
                                    inputs=[paragraph_output],
                                    outputs=[paragraph_output_download]
                                )
                            with gr.Row(visible=False) as paragraph_evaluate_params:
                                default_user_generate_paragraph_evaluate_prompt = """
                                    Based on the final paragraph provided, evaluate the writing in terms of content, organization, grammar, and vocabulary. Provide feedback in simple and supportive language.

                                    -- 根據上述的文章，以「內容（content）」層面評分。
                                    Assess the student's writing by focusing on the 'Content' category according to the established rubric. Determine the clarity of the theme or thesis statement and whether it is supported by specific and complete details relevant to the topic. Use the following levels to guide your evaluation:

                                    - Excellent (5-4 points): Look for a clear and pertinent theme or thesis, directly related to the topic, with detailed support.
                                    - Good (3 points): The theme should be present but may lack clarity or emphasis; some narrative development related to the theme should be evident.
                                    - Fair (2-1 points): Identify if the theme is unclear or if the majority of the narrative is undeveloped or irrelevant to the theme.
                                    - Poor (0 points): Determine if the response is off-topic or not written at all. Remember that any response that is off-topic or unwritten should receive zero points in all aspects.

                                    Your detailed feedback should explain the score you assign, including specific examples from the text to illustrate how well the student's content meets the criteria. 
                                    Translate your feedback into Traditional Chinese (zh-tw) as the final result (#中文解釋 zh-TW).

                                    評分結果以 JSON 格式輸出: content: { 
                                    "level": "#Excellent(5-4 pts)/Good(3 pts)/Fair(2-1 pts)/Poor(0 pts)", 
                                    "explanation": "#中文解釋 zh-TW"
                                    }

                                    -- 根據上述的文章，以「組織（organization）」層面評分。
                                    Evaluate the student's writing with a focus on 'Organization' according to the grading rubric. Consider the structure of the text, including the presence of a clear introduction, development, and conclusion, as well as the coherence throughout the piece and the use of transitional phrases. Use the following levels to structure your feedback:

                                    - Excellent (5-4 points): Look for clear key points with a logical introduction, development, and conclusion, and note whether transitions are coherent and effectively used.
                                    - Good (3 points): The key points should be identifiable but may not be well-arranged; observe any imbalance in development and transitional phrase usage.
                                    - Fair (2-1 points): Identify if the key points are unclear and if the text lacks coherence.
                                    - Poor (0 points): Check if the writing is completely unorganized or not written according to the prompts. Texts that are entirely unorganized should receive zero points.
                                    
                                    Your detailed feedback should explain the score you assign, including specific examples from the text to illustrate how well the student's Organization meets the criteria. Translate your feedback into Traditional Chinese (zh_tw) as the final result (#中文解釋).

                                    評分結果以 JSON 格式輸出: organization: { 
                                    "level": "#Excellent(5-4 pts)/Good(3 pts)/Fair(2-1 pts)/Poor(0 pts)", 
                                    "explanation": "#中文解釋 zh-TW" 
                                    }

                                    -- 根據上述的文章，以「文法和用法（Grammar and usage）」層面評分。
                                    Review the student's writing, paying special attention to 'Grammar/Sentence Structure'. Assess the accuracy of grammar and the variety of sentence structures throughout the essay. Use the rubric levels to judge the work as follows:

                                    - Excellent (5-4 points): Search for text with minimal grammatical errors and a diverse range of sentence structures.
                                    - Good (3 points): There may be some grammatical errors, but they should not affect the overall meaning or flow of the text.
                                    - Fair (2-1 points): Determine if grammatical errors are frequent and if they significantly affect the meaning of the text.
                                    - Poor (0 points): If the essay contains severe grammatical errors throughout, leading to an unclear meaning, it should be marked accordingly.

                                    Your detailed feedback should explain the score you assign, including specific examples from the text to illustrate how well the student's Grammar/Sentence Structure meets the criteria. Translate your feedback into Traditional Chinese (zh_tw) as the final result (#中文解釋).

                                    評分結果以 JSON 格式輸出: grammar_and_usage: { 
                                    "level": "#Excellent(5-4 pts)/Good(3 pts)/Fair(2-1 pts)/Poor(0 pts)", 
                                    "explanation": "#中文解釋 zh-TW" 
                                    }

                                    -- 根據上述的文章，以「詞彙（Vocabulary ）」層面評分。
                                    Assess the use of 'Vocabulary/Spelling' in the student's writing based on the criteria provided. Evaluate the precision and appropriateness of the vocabulary and the presence of spelling errors. Reference the following scoring levels in your analysis:

                                    - Excellent (5-4 points): The writing should contain accurate and appropriate vocabulary with almost no spelling mistakes.
                                    - Good (3 points): Vocabulary might be somewhat repetitive or mundane; there may be occasional misused words and minor spelling mistakes, but they should not impede understanding.
                                    - Fair (2-1 points): Notice if there are many vocabulary errors and spelling mistakes that clearly affect the clarity of the text's meaning.
                                    - Poor (0 points): Writing that only contains scattered words related to the topic or is copied should be scored as such.

                                    Your detailed feedback should explain the score you assign, including specific examples from the text to illustrate how well the student's Vocabulary/Spelling meets the criteria. Translate your feedback into Traditional Chinese (zh_tw) as the final result (#中文解釋).

                                    評分結果以 JSON 格式輸出: vocabulary: { 
                                    "level": "#Excellent(5-4 pts)/Good(3 pts)/Fair(2-1 pts)/Poor(0 pts)", 
                                    "explanation": "#中文解釋 zh-TW" 
                                    }

                                    -- 根據上述的文章，以「連貫性和連接詞（Coherence and Cohesion）」層面評分。
                                    - 評分等級有三級：beginner, intermediate, advanced.
                                    - 以繁體中文 zh-TW 解釋
                                    評分結果以 JSON 格式輸出: coherence_and_cohesion: { 
                                    "level": "#beginner/intermediate/advanced", 
                                    "explanation": "#中文解釋 zh-TW"
                                    }

                                    Restrictions:
                                    - the _explanation should be in Traditional Chinese (zh-TW), it's very important.

                                    Final Output JSON Format:
                                    {{
                                    “content“: {{content’s dict}},
                                    “organization“: {{organization'dict}},
                                    “grammar_and_usage“: {{grammar_and_usage'dict}},
                                    “vocabulary“: {{vocabulary'dict}},
                                    “coherence_and_cohesion“: {{coherence_and_cohesion'dict}}
                                    }}            
                                """
                                user_generate_paragraph_evaluate_prompt = gr.Textbox(label="Paragraph evaluate Prompt", value=default_user_generate_paragraph_evaluate_prompt, visible=False)
                            with gr.Row():
                                generate_paragraph_evaluate_button = gr.Button("✨ 段落分析", variant="primary")
                            with gr.Row():
                                paragraph_evaluate_output = gr.Dataframe(label="完整段落分析", wrap=True, column_widths=[35, 15, 50], interactive=False, visible=False)

                    # 修訂文法與拼字錯誤
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as paragraph_correct_grammatical_spelling_errors_params:
                                default_user_correct_grammatical_spelling_errors_prompt = """
                                    I'm aiming to improve my writing. 
                                    Please assist me by "Correcting Grammatical and Spelling Errors" in the provided paragraph. 
                                    For every correction you make, I'd like an "Explanation" to understand the reasoning behind it. 
                                    
                                    Rules:
                                    - Paragraph for Correction: [paragraph split by punctuation mark]    
                                    - The sentence to remain unchanged: [sentence_to_remain_unchanged]
                                    - When explaining, use Traditional Chinese (Taiwan, 繁體中文) for clarity. 
                                    - But others(original, Correction, revised_paragraph) in English.
                                    - Make sure any revised vocabulary aligns with the eng_level. 
                                    - Prepositions Followed by Gerunds: After a preposition, a gerund (the -ing form of a verb) should be used. For example: "interested in reading."
                                    - Two Main Verbs in a Sentence: When a sentence has two main verbs, it is necessary to use conjunctions, infinitives, clauses, or participles to correctly organize and connect the verbs, avoiding confusion in the sentence structure.
                                    
                                    Guidelines for Length and Complexity: 
                                    - Please keep explanations concise and straightforward
                                    - if there are no grammatical or spelling errors, don't need to revise either no more suggestions to show in the revised paragraph.
                                    
                                    Restrictions:
                                    - avoiding overly technical language.
                                    - don't give any suggestions about the sentence to remain unchanged.
                                    - don't give suggestions about the Period, Comma etc.
                                    - Do not change the original text's case.
                                    - if no mistakes, don't need to revise.

                                    The response should strictly be in the below JSON format and nothing else:

                                    EXAMPLE:
                                    {{ 
                                        "Corrections and Explanations": [ 
                                            {{ "original": "# original_sentence1", "correction": "#correction_1", "explanation": "#explanation_1(in_traditional_chinese ZH-TW)" }}, 
                                            {{ "original": "# original_sentence2", "correction": "#correction_2", "explanation": "#explanation_2(in_traditional_chinese ZH-TW)" }}, 
                                            ... 
                                        ], 
                                        "Revised Paragraph": "#revised_paragraph" 
                                    }}
                                """
                                user_correct_grammatical_spelling_errors_prompt = gr.Textbox(label="Correct Grammatical and Spelling Errors Prompt", value=default_user_correct_grammatical_spelling_errors_prompt, visible=False)
                            
                            with gr.Row() as paragraph_correct_grammatical_spelling_errors_html:
                                gr.Markdown("# Step 7. 修訂文法與拼字錯誤")
                                with gr.Accordion("📝 參考指引：AI 的混淆狀況？", open=False):
                                    gr.Markdown("""
                                        - 段落寫作的過程，如果全程採用 JUTOR 的建議例句，則不會有文法與拼字錯誤。JUTOR 有時後仍會挑出一些字詞修訂，並非原本字詞錯誤，而是改換不同說法，你可以參考。
                                        - 若是自行完成段落寫作，則不會發生自我修訂的混淆狀況。
                                    """)
                            with gr.Row():
                                with gr.Column():
                                    paragraph_correct_grammatical_spelling_errors_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的改正，你可以選擇是否修改：", show_copy_button=True)
                                with gr.Column():
                                    generate_correct_grammatical_spelling_errors_button = gr.Button("✨ 修訂文法與拼字錯誤", variant="primary")
                                    correct_grammatical_spelling_errors_output_table = gr.Dataframe(label="修訂文法與拼字錯誤", interactive=False, visible=False)
                                    revised_paragraph_output = gr.Textbox(label="Revised Paragraph", show_copy_button=True, visible=False)
                                    gr.Markdown("## 修改參考")
                                    revised_paragraph_diff = gr.HTML()

                    # 段落改善建議
                    with gr.Row():
                        with gr.Column():
                            with gr.Row() as paragraph_refine_params:
                                default_user_refine_paragraph_prompt = """
                                    I need assistance with revising a paragraph. Please Refine the paragraph and immediately "Provide Explanations" for each suggestion you made. 
                                    
                                    Rules:
                                    - Do not modify the sentence: topicSentence" 
                                    - Make sure any revised vocabulary aligns with the eng_level. 
                                    - When explaining, use Traditional Chinese (Taiwan, 繁體中文 zh-TW) for clarity.
                                    - But others(Origin, Suggestion, revised_paragraph_v2) use English, that's very important.
                                    
                                    Guidelines for Length and Complexity: 
                                    - Please keep explanations concise and straightforward
                                    - if there are no problems, don't need to revise either no more suggestions to show in the revised paragraph.
                                    
                                    Restrictions:
                                    - avoiding overly technical language.
                                    - don't change the text's case in the original text.
                                    
                                    The response should strictly be in the below JSON format and nothing else:
                                    
                                    EXAMPLE:
                                    {
                                    "Suggestions and Explanations": [ 
                                        { "origin": "#original_text_1", "suggestion": "#suggestion_1", "explanation": "#explanation_1(in_traditional_chinese zh-TW)" }, 
                                        { "origin": "#original_text_2", "suggestion": "#suggestion_2", "explanation": "#explanation_2(in_traditional_chinese zh-TW)" }, 
                                    ... ],
                                    "Revised Paragraph": "#revised_paragraph_v2"
                                    }  
                                """
                                user_refine_paragraph_prompt = gr.Textbox(label="Refine Paragraph Prompt", value=default_user_refine_paragraph_prompt, visible=False)
                            
                            with gr.Row() as paragraph_refine_html:
                                gr.Markdown("# Step 8. 段落改善建議")
                                with gr.Accordion("📝 參考指引：段落改善建議？", open=False ):
                                    gr.Markdown("""
                                        - 段落寫作的過程，如果全程採用 JUTOR 的建議例句，在這部分的批改可能會發生自我修訂的現象。例如：為了符合級別需求，JUTOR 會將自已建議的例句，以換句話說的方式再次修改，你可以忽略。
                                        - 若是自行完成段落寫作，則不會發生自我修訂的混淆狀況。
                                    """)
                            with gr.Row():
                                with gr.Column():
                                    paragraph_refine_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：", show_copy_button=True)
                                with gr.Column():
                                    generate_refine_paragraph_button = gr.Button("✨ 段落改善建議", variant="primary")
                                    refine_output_table = gr.Dataframe(label="段落改善建議", wrap=True, interactive=False, visible=False)
                                    refine_output = gr.HTML(label="修改建議", visible=False)
                                    gr.Markdown("## 修改參考")
                                    refine_output_diff = gr.HTML()

                    # 段落分析
                    generate_paragraph_evaluate_button.click(
                        fn=show_elements,
                        inputs=[],
                        outputs=[paragraph_evaluate_output]
                    ).then(
                        fn=generate_paragraph_evaluate,
                        inputs=[
                            model,
                            sys_content_input,
                            paragraph_output,
                            user_generate_paragraph_evaluate_prompt
                        ],
                        outputs=paragraph_evaluate_output
                    ).then(
                        fn=update_paragraph_correct_grammatical_spelling_errors_input,
                        inputs=[paragraph_output],
                        outputs=paragraph_correct_grammatical_spelling_errors_input
                    )

                    # 修訂文法與拼字錯誤
                    generate_correct_grammatical_spelling_errors_button.click(
                        fn=show_elements,
                        inputs=[],
                        outputs=[correct_grammatical_spelling_errors_output_table]
                    ).then(
                        fn=generate_correct_grammatical_spelling_errors,
                        inputs=[
                            model,
                            sys_content_input,
                            eng_level_input,
                            paragraph_output,
                            user_correct_grammatical_spelling_errors_prompt,
                        ],
                        outputs=[
                            correct_grammatical_spelling_errors_output_table, 
                            revised_paragraph_output
                        ]
                    ).then(
                        fn=highlight_diff_texts,
                        inputs=[correct_grammatical_spelling_errors_output_table, revised_paragraph_output],
                        outputs=revised_paragraph_diff
                    ).then(
                        fn=update_paragraph_refine_input,
                        inputs=[paragraph_correct_grammatical_spelling_errors_input],
                        outputs=paragraph_refine_input
                    )

                    # 段落改善建議
                    generate_refine_paragraph_button.click(
                        fn=show_elements,
                        inputs=[],
                        outputs=[refine_output_table]
                    ).then(
                        fn=generate_refine_paragraph,
                        inputs=[
                            model,
                            sys_content_input,
                            eng_level_input,
                            paragraph_correct_grammatical_spelling_errors_input,
                            user_refine_paragraph_prompt
                        ],
                        outputs=[refine_output_table, refine_output]
                    ).then(
                        fn=highlight_diff_texts,
                        inputs=[refine_output_table, refine_output],
                        outputs=refine_output_diff
                    )
                            
                    # Final Step. 寫作完成
                    with gr.Row():
                        with gr.Column():
                            with gr.Row():
                                gr.Markdown("# Step 9. 寫作完成 Save and Share")
                            with gr.Row():
                                paragraph_practice_save_button = gr.Button("點擊建立 doc", variant="primary")
                            with gr.Row():
                                # 顯示最後段落寫作結果
                                with gr.Column():
                                    paragraph_practice_save_output = gr.TextArea(label="最後結果", show_copy_button=True)
                                with gr.Column():
                                    paragraph_practice_download_link = gr.File(label="請點擊右下角連結(ex: 37KB)，進行下載")

                                    paragraph_practice_save_button.click(
                                        fn=download_content,
                                        inputs=[paragraph_refine_input],
                                        outputs=[paragraph_practice_download_link]
                                    ).then(
                                        fn=duplicate_element,
                                        inputs=[paragraph_refine_input],
                                        outputs=[paragraph_practice_save_output]
                                    )

                            with gr.Row():
                                gr.Markdown("## 完成修訂！你按部就班地完成了一次段落寫作練習，太棒了！")
                            with gr.Row():
                                paragraph_save_button = gr.Button("建立歷程回顧", variant="primary")
                            with gr.Row(elem_id="paragraph_save_output"):
                                with gr.Accordion("歷程回顧", open=False) as history_accordion:
                                    scenario_input_history = gr.Textbox(label="情境", visible=False)
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>主題</span>")
                                    topic_input_history = gr.Markdown(label="主題")
                                    gr.Markdown("<span style='color:#4e80ee'>要點/關鍵字</span>")
                                    points_input_history = gr.Markdown(label="要點/關鍵字")
                                    gr.Markdown("<span style='color:#4e80ee'>主題句</span>")
                                    topic_sentence_input_history = gr.Markdown(label="主題句")
                                    gr.Markdown("<span style='color:#4e80ee'>支持句</span>")
                                    supporting_sentences_input_history = gr.Markdown(label="支持句")
                                    gr.Markdown("<span style='color:#4e80ee'>結論句</span>")
                                    conclusion_sentence_input_history = gr.Markdown(label="結論句")
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>完整段落</span>")
                                    paragraph_output_history = gr.Markdown(label="完整段落")
                                    
                                    paragraph_evaluate_output_history = gr.Dataframe(label="完整段落分析", wrap=True, column_widths=[35, 15, 50], interactive=False)
                                    correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(label="修訂文法與拼字錯誤", interactive=False, wrap=True, column_widths=[30, 30, 40])
                                    refine_output_table_history = gr.Dataframe(label="段落改善建議", wrap=True, interactive=False, column_widths=[30, 30, 40])
                                    gr.Markdown("<span style='color:#4e80ee'>修改建議</span>")
                                    refine_output_history = gr.Markdown(label="修改建議")
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                                    paragraph_save_output = gr.Markdown(label="最後結果")
                            with gr.Row():
                                audio_output = gr.Audio(label="音檔", type="filepath")

                                paragraph_save_button.click(
                                    fn=generate_paragraph_history,
                                    inputs=[
                                        user_data,
                                        session_timestamp,
                                        request_origin,
                                        scenario_input,
                                        topic_input,
                                        points_input,
                                        topic_sentence_input,
                                        supporting_sentences_input,
                                        conclusion_sentence_input,
                                        paragraph_output,
                                        paragraph_evaluate_output,
                                        correct_grammatical_spelling_errors_output_table,
                                        refine_output_table,
                                        refine_output
                                    ],
                                    outputs=[
                                        scenario_input_history,
                                        topic_input_history,
                                        points_input_history,
                                        topic_sentence_input_history,
                                        supporting_sentences_input_history,
                                        conclusion_sentence_input_history,
                                        paragraph_output_history,
                                        paragraph_evaluate_output_history,
                                        correct_grammatical_spelling_errors_output_table_history,
                                        refine_output_table_history,
                                        refine_output_history,
                                    ]
                                ).then(
                                    fn=paragraph_save_and_tts,
                                    inputs=[
                                        paragraph_practice_save_output
                                    ],
                                    outputs=[
                                        paragraph_save_output, 
                                        audio_output
                                    ]
                                ).then(
                                    fn=update_history_accordion,
                                    inputs=[],
                                    outputs=history_accordion
                                )

            # ====="英文全文批改"=====
            with gr.Row(visible=False, elem_id="english_grapragh_evaluate_row") as english_grapragh_evaluate_row:
                with gr.Column():
                    with gr.Row(visible=False) as full_paragraph_params:
                        full_paragraph_sys_content_input = gr.Textbox(label="System Prompt", value="You are an English teacher who is practicing with me to improve my English writing skill.")
                        default_user_generate_full_paragraph_evaluate_prompt = default_user_generate_paragraph_evaluate_prompt
                        user_generate_full_paragraph_evaluate_prompt = gr.Textbox(label="Paragraph evaluate Prompt", value=default_user_generate_full_paragraph_evaluate_prompt, visible=False)
                    with gr.Row():
                        gr.Markdown("# 📊 英文段落寫作評分")
                    # 輸入段落全文
                    with gr.Row():
                        gr.Markdown("## 輸入段落全文")
                    with gr.Row():
                        with gr.Column():
                            full_paragraph_input = gr.TextArea(label="輸入段落全文")
                        with gr.Column():
                            with gr.Row():
                                full_paragraph_evaluate_button = gr.Button("✨ JUTOR 段落全文分析", variant="primary")
                            with gr.Row():
                                full_paragraph_evaluate_output = gr.Dataframe(label="段落全文分析", wrap=True, column_widths=[35, 15, 50], interactive=False)

                    # JUTOR 段落批改與整體建議
                    with gr.Row():
                        gr.Markdown("# JUTOR 修訂文法與拼字錯誤")
                    with gr.Row():
                        with gr.Column():
                            full_paragraph_correct_grammatical_spelling_errors_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：")
                        with gr.Column():
                            generate_full_paragraph_correct_grammatical_spelling_errors_button = gr.Button("✨ JUTOR 修訂文法與拼字錯誤", variant="primary")
                            full_paragraph_correct_grammatical_spelling_errors_output_table = gr.Dataframe(label="修訂文法與拼字錯誤", interactive=False, column_widths=[30, 30, 40])
                            revised_full_paragraph_output = gr.Textbox(label="Revised Paragraph", show_copy_button=True, visible=False)
                            gr.Markdown("## 修訂結果")
                            revised_full_paragraph_diff = gr.HTML()

                    # JUTOR 段落批改與整體建議
                    with gr.Row():
                        gr.Markdown("# JUTOR 段落改善建議")
                    with gr.Row():
                        with gr.Column():
                            full_paragraph_refine_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：", show_copy_button=True)
                        with gr.Column():
                            generate_full_paragraph_refine_button = gr.Button("✨ JUTOR 段落改善建議", variant="primary")
                            full_paragraph_refine_output_table = gr.DataFrame(label="段落改善建議", wrap=True, interactive=False)
                            full_paragraph_refine_output = gr.HTML(label="修改建議", visible=False)
                            gr.Markdown("## 修改結果")
                            full_paragraph_refine_output_diff = gr.HTML()

                    # 寫作完成
                    with gr.Row():
                        gr.Markdown("# 寫作完成")
                    with gr.Row():
                        full_paragraph_save_button = gr.Button("輸出結果", variant="primary")
                    with gr.Row():
                        full_paragraph_save_output = gr.TextArea(label="最後結果")
                        full_audio_output = gr.Audio(label="音檔", type="filepath")

                    # 建立歷程回顧
                    with gr.Row():
                        gr.Markdown("# 歷程回顧")
                    with gr.Row():
                        full_paragraph_history_save_button = gr.Button("建立歷程回顧", variant="primary")
                    with gr.Row():
                        with gr.Accordion("歷程回顧", open=False) as full_paragraph_history_accordion:
                            gr.Markdown("<span style='color:#4e80ee'>輸入段落全文</span>")
                            full_paragraph_input_history = gr.Markdown()
                            gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                            full_paragraph_evaluate_output_history = gr.Dataframe( wrap=True, column_widths=[35, 15, 50], interactive=False)
                            
                            gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤 輸入</span>")
                            full_paragraph_correct_grammatical_spelling_errors_input_history = gr.Markdown()
                            gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤</span>")
                            full_paragraph_correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(interactive=False, wrap=True, column_widths=[30, 30, 40])
                            
                            gr.Markdown("<span style='color:#4e80ee'>段落改善建議 輸入</span>")
                            full_paragraph_refine_input_history = gr.Markdown()
                            gr.Markdown("<span style='color:#4e80ee'>段落改善建議</span>")
                            full_paragraph_refine_output_table_history = gr.Dataframe(wrap=True, interactive=False, column_widths=[30, 30, 40])
                            
                            gr.Markdown("<span style='color:#4e80ee'>修改建議</span>")
                            full_paragraph_refine_output_history = gr.Markdown()
                            gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                            full_paragraph_save_output_history = gr.Markdown()
                           
                    full_paragraph_evaluate_button.click(
                        fn=generate_paragraph_evaluate,
                        inputs=[model, sys_content_input, full_paragraph_input, user_generate_full_paragraph_evaluate_prompt],
                        outputs=full_paragraph_evaluate_output
                    ).then(
                        fn=update_paragraph_correct_grammatical_spelling_errors_input,
                        inputs=[full_paragraph_input],
                        outputs=full_paragraph_correct_grammatical_spelling_errors_input
                    )
                    
                    generate_full_paragraph_correct_grammatical_spelling_errors_button.click(
                        fn=generate_correct_grammatical_spelling_errors,
                        inputs=[model, sys_content_input, eng_level_input, full_paragraph_correct_grammatical_spelling_errors_input, user_correct_grammatical_spelling_errors_prompt],
                        outputs=[full_paragraph_correct_grammatical_spelling_errors_output_table, revised_full_paragraph_output]
                    ).then(
                        fn=highlight_diff_texts,
                        inputs=[full_paragraph_correct_grammatical_spelling_errors_output_table, revised_full_paragraph_output],
                        outputs=revised_full_paragraph_diff
                    ).then(
                        fn=update_paragraph_refine_input,
                        inputs=[full_paragraph_correct_grammatical_spelling_errors_input],
                        outputs=full_paragraph_refine_input
                    )

                    generate_full_paragraph_refine_button.click(
                        fn=generate_refine_paragraph,
                        inputs=[
                            model, 
                            sys_content_input, 
                            eng_level_input, 
                            full_paragraph_refine_input, 
                            user_refine_paragraph_prompt
                        ],
                        outputs=[full_paragraph_refine_output_table, full_paragraph_refine_output]
                    ).then(
                        fn=highlight_diff_texts,
                        inputs=[full_paragraph_refine_output_table, full_paragraph_refine_output],
                        outputs=full_paragraph_refine_output_diff
                    )

                    full_paragraph_save_button.click(
                        fn=paragraph_save_and_tts,
                        inputs=[full_paragraph_refine_input],
                        outputs=[full_paragraph_save_output, full_audio_output]
                    )

                    full_paragraph_history_save_button.click(
                        fn=generate_paragraph_evaluate_history,
                        inputs=[
                            user_data,
                            user_email,
                            user_nickname,
                            session_timestamp,
                            request_origin,
                            assignment_id_input,
                            full_paragraph_input,
                            full_paragraph_evaluate_output,
                            full_paragraph_correct_grammatical_spelling_errors_input,
                            full_paragraph_correct_grammatical_spelling_errors_output_table,
                            full_paragraph_refine_input,
                            full_paragraph_refine_output_table,
                            full_paragraph_refine_output,
                            full_paragraph_save_output
                        ],
                        outputs=[
                            full_paragraph_input_history,
                            full_paragraph_evaluate_output_history,
                            full_paragraph_correct_grammatical_spelling_errors_input_history,
                            full_paragraph_correct_grammatical_spelling_errors_output_table_history,
                            full_paragraph_refine_input_history,
                            full_paragraph_refine_output_table_history,
                            full_paragraph_refine_output_history,
                            full_paragraph_save_output_history,
                        ]
                    ).then(
                        fn=update_history_accordion,
                        inputs=[],
                        outputs=full_paragraph_history_accordion
                    )


            # ====="英文考古題寫作練習====="   
            with gr.Row(visible=False, elem_id="english_exam_practice_row") as english_exam_practice_row:
                
                with gr.Column():
                    with gr.Row():
                        with gr.Column():
                            with gr.Row():
                                gr.Markdown("# 🎯 英文考古題寫作練習")
                            with gr.Row():
                                gr.Markdown("## 選擇考古題")
                            with gr.Row():
                                exams_data = load_exam_data()
                                past_exam_choices = [exam["title"] for exam in exams_data["exams"]]
                                past_exam_dropdown = gr.Radio(label="選擇考古題", choices=past_exam_choices)
                            with gr.Row():
                                past_exam_title = gr.Markdown()
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        past_exam_question = gr.Markdown()
                                    with gr.Row():
                                        with gr.Accordion("提示", open=False):
                                            with gr.Row():
                                                past_exam_hint = gr.Markdown()
                                with gr.Column():
                                    past_exam_image = gr.Image(show_label=False)
                                
                                past_exam_dropdown.select(
                                    fn=update_exam_contents,
                                    inputs=[past_exam_dropdown],
                                    outputs=[past_exam_title, past_exam_question, past_exam_hint, past_exam_image]
                                )

                            # 評分
                            with gr.Row():
                                with gr.Column():
                                    with gr.Row():
                                        past_exam_evaluation_sys_content_prompt = gr.Textbox(label="System Prompt", value="You are an English teacher who is practicing with me to improve my English writing skill.", visible=False)
                                        past_exam_evaluation_user_prompt = gr.Textbox(label="Paragraph evaluate Prompt", value=default_user_generate_paragraph_evaluate_prompt, visible=False)
                                        past_exam_evaluation_input = gr.TextArea("",label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：")
                                with gr.Column():
                                    with gr.Row():
                                        past_exam_evaluation_button = gr.Button("全文分析", variant="primary")
                                    with gr.Row():
                                        past_exam_evaluation_output = gr.Dataframe(label="全文分析結果", wrap=True, column_widths=[20, 15, 65], interactive=False)
                                
                            # 修正錯字、語法
                            with gr.Row():
                                with gr.Column():
                                    past_exam_correct_grammatical_spelling_errors_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：",lines= 10, show_copy_button=True)
                                with gr.Column():
                                    with gr.Row():
                                        with gr.Accordion("prompt 提供微調測試", open=False, elem_classes=['accordion-prompts'], visible=False):
                                            past_exam_correct_grammatical_spelling_errors_prompt = gr.Textbox(label="Correct Grammatical and Spelling Errors Prompt", value=default_user_correct_grammatical_spelling_errors_prompt, lines= 20)
                                    with gr.Row():
                                        past_exam_generate_correct_grammatical_spelling_errors_button = gr.Button("修訂文法與拼字錯誤", variant="primary")
                                    with gr.Row():
                                        past_exam_correct_grammatical_spelling_errors_output_table = gr.Dataframe(label="修訂文法與拼字錯誤", interactive=False, column_widths=[30, 30, 40])
                                    with gr.Row():
                                        past_exam_revised_output = gr.Textbox(label="Revised Paragraph", show_copy_button=True, visible=False)
                                    with gr.Row():
                                        gr.Markdown("## 修訂結果")
                                    with gr.Row():
                                        past_exam_revised_diff = gr.HTML()

                            # 修正段落
                            with gr.Row():
                                with gr.Column():
                                    past_exam_refine_input = gr.TextArea(label="這是你的原始寫作內容，參考 JUTOR 的建議，你可以選擇是否修改：", show_copy_button=True)
                                with gr.Column():
                                    with gr.Row():
                                        with gr.Accordion("prompt 提供微調測試", open=False, elem_classes=['accordion-prompts'], visible=False):
                                            past_exam_refine_paragraph_prompt = gr.Textbox(label="Refine Paragraph Prompt", value=default_user_refine_paragraph_prompt, lines= 20)
                                    with gr.Row():
                                        past_exam_generate_refine_button = gr.Button("段落改善建議", variant="primary")
                                    with gr.Row():
                                        past_exam_refine_output_table = gr.DataFrame(label="Refine Paragraph 段落改善建議", wrap=True, interactive=False)
                                    with gr.Row():
                                        past_exam_refine_output = gr.HTML(label="修改建議", visible=False)
                                    with gr.Row():
                                        gr.Markdown("## 修改結果")
                                    with gr.Row():
                                        past_exam_refine_output_diff = gr.HTML()

                            # 最後成果
                            with gr.Row():
                                gr.Markdown("# 寫作完成")
                            with gr.Row():
                                past_exam_save_button = gr.Button("輸出結果", variant="primary")
                            with gr.Row():
                                with gr.Column():
                                    past_exam_save_output = gr.TextArea(label="最後結果")
                                with gr.Column():
                                    past_exam_audio_output = gr.Audio(label="音檔", type="filepath")
                                
                                past_exam_save_button.click(
                                    fn=paragraph_save_and_tts,
                                    inputs=[past_exam_refine_input],
                                    outputs=[past_exam_save_output, past_exam_audio_output]
                                )

                            # 建立歷程回顧
                            with gr.Row():
                                gr.Markdown("# 建立歷程回顧")
                            with gr.Row():
                                past_exam_history_save_button = gr.Button("建立歷程回顧", variant="primary")
                            with gr.Row():
                                with gr.Accordion("歷程回顧", open=False) as past_exam_history_accordion:
                                    gr.Markdown("<span style='color:#4e80ee'>考古題</span>")
                                    past_exam_dropdown_history = gr.Markdown()

                                    gr.Markdown("<span style='color:#4e80ee'>段落全文</span>")
                                    past_exam_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                                    past_exam_evaluate_output_history = gr.Dataframe(wrap=True, column_widths=[35, 15, 50], interactive=False)
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>文法與拼字錯誤</span>")
                                    past_exam_correct_grammatical_spelling_errors_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤</span>")
                                    past_exam_correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(interactive=False, wrap=True, column_widths=[30, 30, 40])
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善</span>")
                                    past_exam_refine_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議</span>")
                                    past_exam_refine_output_table_history = gr.Dataframe(wrap=True, interactive=False, column_widths=[30, 30, 40])
                        
                                    gr.Markdown("<span style='color:#4e80ee'>修改建議</span>")
                                    past_exam_refine_output_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                                    past_exam_save_output_history = gr.Markdown()


                                past_exam_history_save_button.click(  
                                    fn=generate_past_exam_history,
                                    inputs=[
                                        user_data,
                                        session_timestamp,
                                        request_origin,
                                        past_exam_dropdown,
                                        past_exam_evaluation_input,
                                        past_exam_evaluation_output,
                                        past_exam_correct_grammatical_spelling_errors_input,
                                        past_exam_correct_grammatical_spelling_errors_output_table,
                                        past_exam_refine_input,
                                        past_exam_refine_output_table,
                                        past_exam_refine_output,
                                        past_exam_save_output
                                    ],
                                    outputs=[
                                        past_exam_dropdown_history,
                                        past_exam_input_history,
                                        past_exam_evaluate_output_history,
                                        past_exam_correct_grammatical_spelling_errors_input_history,
                                        past_exam_correct_grammatical_spelling_errors_output_table_history,
                                        past_exam_refine_input_history,
                                        past_exam_refine_output_table_history,
                                        past_exam_refine_output_history,
                                        past_exam_save_output_history
                                    ]
                                ).then(
                                    fn=update_history_accordion,
                                    inputs=[],
                                    outputs=past_exam_history_accordion
                                )

                                past_exam_evaluation_button.click(
                                    fn=generate_paragraph_evaluate,
                                    inputs=[model, past_exam_evaluation_sys_content_prompt, past_exam_evaluation_input, past_exam_evaluation_user_prompt],
                                    outputs=past_exam_evaluation_output
                                ).then(
                                    fn=update_paragraph_correct_grammatical_spelling_errors_input,
                                    inputs=[past_exam_evaluation_input],
                                    outputs=past_exam_correct_grammatical_spelling_errors_input
                                )

                                past_exam_generate_correct_grammatical_spelling_errors_button.click(
                                    fn=generate_correct_grammatical_spelling_errors,
                                    inputs=[model, past_exam_evaluation_sys_content_prompt, eng_level_input, past_exam_correct_grammatical_spelling_errors_input, past_exam_correct_grammatical_spelling_errors_prompt],
                                    outputs=[past_exam_correct_grammatical_spelling_errors_output_table, past_exam_revised_output]
                                ).then(
                                    fn=highlight_diff_texts,
                                    inputs=[past_exam_correct_grammatical_spelling_errors_output_table, past_exam_revised_output],
                                    outputs=past_exam_revised_diff
                                ).then(
                                    fn=update_paragraph_refine_input,
                                    inputs=[past_exam_correct_grammatical_spelling_errors_input],
                                    outputs=past_exam_refine_input
                                )
                                
                                past_exam_generate_refine_button.click(
                                    fn=generate_refine_paragraph,
                                    inputs=[model, past_exam_evaluation_sys_content_prompt, eng_level_input, past_exam_refine_input, past_exam_refine_paragraph_prompt],
                                    outputs=[past_exam_refine_output_table, past_exam_refine_output]
                                ).then(
                                    fn=highlight_diff_texts,
                                    inputs=[past_exam_refine_output_table, past_exam_refine_output],
                                    outputs=past_exam_refine_output_diff
                                )
                
            # ===== 英文歷程 ====
            with gr.Row(visible=False, elem_id="english_logs_row") as english_logs_row:
                with gr.Column():
                    with gr.Row():
                        gr.Markdown("# 📚 歷程回顧")
                    with gr.Row():
                        with gr.Accordion("📝 英文段落練習歷程回顧", open=False) as english_grapragh_practice_logs_accordion:
                            with gr.Row():
                                with gr.Column(scale=1):
                                    # 取得英文段落練習 log from GCS
                                    paragraph_practice_logs_type = gr.State("jutor_write_paragraph_practice")
                                    get_paragraph_practice_logs_button = gr.Button("👉 取得英文段落練習歷程", variant="primary")
                                    paragraph_practice_logs_session_list = gr.Radio(label="歷程時間列表")
                                with gr.Column(scale=3, variant="compact"):
                                    gr.Markdown("<span style='color:#4e80ee'>主題</span>")
                                    paragraph_log_topic_input_history = gr.Markdown(label="主題")
                                    gr.Markdown("<span style='color:#4e80ee'>要點/關鍵字</span>")
                                    paragraph_log_points_input_history = gr.Markdown(label="要點/關鍵字")
                                    gr.Markdown("<span style='color:#4e80ee'>主題句</span>")
                                    paragraph_log_topic_sentence_input_history = gr.Markdown(label="主題句")
                                    gr.Markdown("<span style='color:#4e80ee'>支持句</span>")
                                    paragraph_log_supporting_sentences_input_history = gr.Markdown(label="支持句")
                                    gr.Markdown("<span style='color:#4e80ee'>結論句</span>")
                                    paragraph_log_conclusion_sentence_input_history = gr.Markdown(label="結論句")
                                    gr.Markdown("<span style='color:#4e80ee'>完整段落</span>")
                                    paragraph_log_paragraph_output_history = gr.Markdown(label="完整段落")
                                    paragraph_log_paragraph_evaluate_output_history = gr.Dataframe(label="完整段落分析", wrap=True, column_widths=[35, 15, 50], interactive=False)
                                    paragraph_log_correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(label="修訂文法與拼字錯誤", interactive=False, wrap=True, column_widths=[30, 30, 40])
                                    paragraph_log_refine_output_table_history = gr.Dataframe(label="段落改善建議", wrap=True, interactive=False, column_widths=[30, 30, 40])
                                    gr.Markdown("<span style='color:#4e80ee'>修改建議</span>")
                                    paragraph_log_refine_output_history = gr.Markdown(label="修改建議")
                                    gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                                    paragraph_log_paragraph_save_output = gr.Markdown(label="最後結果")

                                    get_paragraph_practice_logs_button.click(
                                        fn=get_logs_sessions,
                                        inputs=[user_data, paragraph_practice_logs_type],
                                        outputs=[paragraph_practice_logs_session_list]
                                    )

                                    paragraph_practice_logs_session_list.select(
                                        fn=get_paragraph_practice_log_session_content,
                                        inputs=[paragraph_practice_logs_session_list],
                                        outputs=[
                                            paragraph_log_topic_input_history,
                                            paragraph_log_points_input_history,
                                            paragraph_log_topic_sentence_input_history,
                                            paragraph_log_supporting_sentences_input_history,
                                            paragraph_log_conclusion_sentence_input_history,
                                            paragraph_log_paragraph_output_history,
                                            paragraph_log_paragraph_evaluate_output_history,
                                            paragraph_log_correct_grammatical_spelling_errors_output_table_history,
                                            paragraph_log_refine_output_table_history,
                                            paragraph_log_refine_output_history,
                                            paragraph_log_paragraph_save_output
                                        ]
                                    )
                    with gr.Row():
                        with gr.Accordion("📊 英文段落寫作評分歷程回顧", open=False) as english_grapragh_evaluate_logs_accordion:
                            with gr.Row():
                                with gr.Column(scale=1):
                                    # 取得英文段落練習 log from GCS
                                    full_paragraph_evaluate_logs_type = gr.State("jutor_write_full_paragraph_evaluation")
                                    get_full_paragraph_evaluate_logs_button = gr.Button("👉 取得英文段落寫作評分歷程", variant="primary")
                                    full_paragraph_evaluate_logs_session_list = gr.Radio(label="歷程時間列表")
                                with gr.Column(scale=3, variant="compact"):
                                    gr.Markdown("<span style='color:#4e80ee'>輸入段落全文</span>")
                                    log_full_paragraph_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                                    log_full_paragraph_evaluate_output_history = gr.Dataframe( wrap=True, column_widths=[35, 15, 50], interactive=False)
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤 輸入</span>")
                                    log_full_paragraph_correct_grammatical_spelling_errors_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤</span>")
                                    log_full_paragraph_correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(interactive=False, wrap=True, column_widths=[30, 30, 40])
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議 輸入</span>")
                                    log_full_paragraph_refine_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議</span>")
                                    log_full_paragraph_refine_output_table_history = gr.Dataframe(wrap=True, interactive=False, column_widths=[30, 30, 40])
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>修改建議</span>")
                                    log_full_paragraph_refine_output_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                                    log_full_paragraph_save_output_history = gr.Markdown()

                                    get_full_paragraph_evaluate_logs_button.click(
                                        fn=get_logs_sessions,
                                        inputs=[user_data, full_paragraph_evaluate_logs_type],
                                        outputs=[full_paragraph_evaluate_logs_session_list]
                                    )

                                    full_paragraph_evaluate_logs_session_list.select(
                                        fn=get_full_paragraph_evaluate_log_session_content,
                                        inputs=[full_paragraph_evaluate_logs_session_list],
                                        outputs=[
                                            log_full_paragraph_input_history,
                                            log_full_paragraph_evaluate_output_history,
                                            log_full_paragraph_correct_grammatical_spelling_errors_input_history,
                                            log_full_paragraph_correct_grammatical_spelling_errors_output_table_history,
                                            log_full_paragraph_refine_input_history,
                                            log_full_paragraph_refine_output_table_history,
                                            log_full_paragraph_refine_output_history,
                                            log_full_paragraph_save_output_history
                                        ]
                                    )
                    with gr.Row():
                        with gr.Accordion("🎯 英文考古題寫作練習歷程回顧", open=False) as english_exam_practice_logs_accordion:
                            with gr.Row():
                                with gr.Column(scale=1):
                                    # 取得英文段落練習 log from GCS
                                    past_exam_logs_type = gr.State("jutor_write_past_exam")
                                    get_past_exam_logs_button = gr.Button("👉 取得英文考古題寫作練習歷程", variant="primary")
                                    past_exam_logs_session_list = gr.Radio(label="歷程時間列表")
                                with gr.Column(scale=3, variant="compact"):
                                    gr.Markdown("<span style='color:#4e80ee'>考古題</span>")
                                    past_exam_log_dropdown_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落全文</span>")
                                    past_exam_log_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                                    past_exam_log_evaluate_output_history = gr.Dataframe(wrap=True, column_widths=[35, 15, 50], interactive=False)
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>文法與拼字錯誤</span>")
                                    past_exam_log_correct_grammatical_spelling_errors_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>修訂文法與拼字錯誤</span>")
                                    past_exam_log_correct_grammatical_spelling_errors_output_table_history = gr.Dataframe(interactive=False, wrap=True, column_widths=[30, 30, 40])
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善</span>")
                                    past_exam_log_refine_input_history = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議</span>")
                                    past_exam_log_refine_output_table_history = gr.Dataframe(wrap=True, interactive=False, column_widths=[30, 30, 40])
                                    
                                    gr.Markdown("<span style='color:#4e80ee'>最後結果</span>")
                                    past_exam_log_save_output_history = gr.Markdown()

                                    get_past_exam_logs_button.click(
                                        fn=get_logs_sessions,
                                        inputs=[user_data, past_exam_logs_type],
                                        outputs=[past_exam_logs_session_list]
                                    )

                                    past_exam_logs_session_list.select(
                                        fn=get_past_exam_practice_log_session_content,
                                        inputs=[past_exam_logs_session_list],
                                        outputs=[
                                            past_exam_log_dropdown_history,
                                            past_exam_log_input_history,
                                            past_exam_log_evaluate_output_history,
                                            past_exam_log_correct_grammatical_spelling_errors_input_history,
                                            past_exam_log_correct_grammatical_spelling_errors_output_table_history,
                                            past_exam_log_refine_input_history,
                                            past_exam_log_refine_output_table_history,
                                            past_exam_log_save_output_history
                                        ]
                                    )
                                                
            english_grapragh_practice_button.click(
                None,
                None,
                None,
                js=english_grapragh_practice_button_js
            )
            english_grapragh_evaluate_button.click(
                None,
                None,
                None,
                js=english_grapragh_evaluate_button_js
            )
            english_exam_practice_tab_button.click(
                None,
                None,
                None,
                js=english_exam_practice_tab_button_js
            )
            english_logs_tab_button.click(
                None,
                None,
                None,
                js=english_logs_tab_button_js
            )

    # 中文寫作練習
    with gr.Row(visible=False) as chinese_group:
        with gr.Column():
            with gr.Row() as page_title_chinese:
                gr.Markdown("# 🍄 CUTOR 國文段落寫作練習")
            with gr.Accordion("💡 提醒", open=True):
                gr.Markdown("### Cutor 是你得力的作文批改小幫手，但它不是老師，和你一樣都在學習，偶爾也會出錯。如果你對於 Cutor 給你的建議有疑問，請提出和老師討論喔")            
            with gr.Row(visible=True) as chinese_admin:
                chinese_thread_id_state = gr.State()

            with gr.Row(visible=False) as chinese_assignment_row:
                with gr.Column():
                    with gr.Row():
                        gr.Markdown("# 作業模式")
                    with gr.Row():
                        chinese_assignment_grade = gr.Textbox(label="年級", interactive=False, visible=False)
                        chinese_assignment_topic = gr.Textbox(label="主題", interactive=False)
                        chinese_assignment_introduction = gr.Textbox(label="寫作引文", interactive=False)
                        chinese_assignment_description = gr.Textbox(label="作業說明", interactive=False)
                        chinese_assignment_submission_deadline = gr.Textbox(label="截止日期", interactive=False)

            # =====中文全文批改=====
            with gr.Tab("中文全文批改") as chinese_full_paragraph_tab:
                with gr.Row():
                    gr.Markdown("# 輸入段落全文")
                with gr.Row():
                    with gr.Column():
                        chinese_full_paragraph_input = gr.Textbox(label="輸入段落全文", lines=5)
                    with gr.Column():
                        with gr.Row():
                            chinese_full_paragraph_evaluate_button = gr.Button("段落全文分析", variant="primary")
                        with gr.Row():
                            chinese_full_paragraph_evaluate_output_text = gr.Markdown(label="段落全文分析")
                        with gr.Row():
                            chinese_full_paragraph_evaluate_output_table = gr.Dataframe(label="段落全文分析表格", wrap=True, column_widths=[20, 15, 65], interactive=False)

                # 修改文章
                with gr.Row():
                    gr.Markdown("# 根據建議修改文章")
                with gr.Row():
                    with gr.Column():
                        chinese_full_paragraph_refine_input = gr.TextArea(label="這是你的原始寫作內容，參考建議，你可以選擇是否修改：", show_copy_button=True)
                    with gr.Column():
                        with gr.Row():
                            generate_chinese_full_paragraph_refine_button = gr.Button("段落全文分析", variant="primary")
                        with gr.Row():
                            chinese_full_paragraph_refine_output_text = gr.Markdown(label="段落全文分析")
                        with gr.Row():
                            chinese_full_paragraph_refine_output_table = gr.Dataframe(label="段落全文分析表格", wrap=True, column_widths=[20, 15, 65], interactive=False)
                # 寫作完成
                with gr.Row():
                    gr.Markdown("# 寫作完成")
                with gr.Row():
                    chinese_full_paragraph_save_button = gr.Button("輸出結果", variant="primary")
                with gr.Row():
                    chinese_full_paragraph_save_output = gr.TextArea(label="最後結果")
                    chinese_full_audio_output = gr.Audio(label="音檔", type="filepath")

                # 建立歷程回顧
                with gr.Row():
                    chinese_paragraph_save_history_button = gr.Button("建立歷程回顧", variant="primary")
                with gr.Row():
                    with gr.Accordion("歷程回顧", open=False) as chinese_grapragh_practice_history_accordion:
                        gr.Markdown("<span style='color:#4e80ee'>輸入段落全文</span>")
                        chinese_full_paragraph_input_history = gr.Markdown()
                        gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                        chinese_full_paragraph_evaluate_output_text_history = gr.Markdown()
                        chinese_full_paragraph_evaluate_output_table_history = gr.Dataframe(wrap=True, column_widths=[35, 15, 50], interactive=False)
                        
                        # 根據建議修改文章
                        gr.Markdown("<span style='color:#4e80ee'>根據建議修改文章 輸入</span>")
                        chinese_full_paragraph_refine_input_history = gr.Markdown()
                        gr.Markdown("<span style='color:#4e80ee'>全文分析</span>")
                        chinese_full_paragraph_refine_output_text_history = gr.Markdown()
                        chinese_full_paragraph_refine_output_table_history = gr.Dataframe(interactive=False, wrap=True, column_widths=[30, 30, 40])

                        gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                        chinese_full_paragraph_save_output_history = gr.Markdown()

                    chinese_paragraph_save_history_button.click(
                        fn=disable_elements,
                        inputs=[],
                        outputs=[
                            chinese_paragraph_save_history_button
                        ]
                    ).then(
                        fn=update_history_accordion,
                        inputs=[],
                        outputs=[chinese_grapragh_practice_history_accordion]
                    ).then(
                        fn=generate_chinese_paragraph_practice_history,
                        inputs=[
                            user_data,
                            user_email,
                            user_nickname,
                            session_timestamp,
                            request_origin,
                            assignment_id_input,
                            chinese_full_paragraph_input,
                            chinese_full_paragraph_evaluate_output_text,
                            chinese_full_paragraph_evaluate_output_table,
                            chinese_full_paragraph_refine_input,
                            chinese_full_paragraph_refine_output_text,
                            chinese_full_paragraph_refine_output_table,
                            chinese_full_paragraph_save_output
                        ],
                        outputs=[
                            chinese_full_paragraph_input_history,
                            chinese_full_paragraph_evaluate_output_text_history,
                            chinese_full_paragraph_evaluate_output_table_history,
                            chinese_full_paragraph_refine_input_history,
                            chinese_full_paragraph_refine_output_text_history,
                            chinese_full_paragraph_refine_output_table_history,
                            chinese_full_paragraph_save_output_history
                        ]
                    ).then(
                        fn=enable_elements,
                        inputs=[],
                        outputs=[chinese_paragraph_save_history_button]
                    )

                chinese_full_paragraph_evaluate_button.click(
                    fn=disable_elements,
                    inputs=[],
                    outputs=[
                        chinese_full_paragraph_evaluate_button
                    ]
                ).then(
                    fn=get_chinese_conversation_thread_id,
                    inputs=[chinese_thread_id_state],
                    outputs=[chinese_thread_id_state]
                ).then(
                    fn=get_chinese_paragraph_1st_evaluate_content,
                    inputs=[
                        chinese_thread_id_state,
                        model,
                        chinese_assignment_topic,
                        chinese_assignment_introduction,
                        chinese_assignment_description,
                        chinese_full_paragraph_input,
                    ],
                    outputs=[
                        chinese_full_paragraph_evaluate_output_text, 
                        chinese_full_paragraph_evaluate_output_table
                    ]
                ).then(
                    fn=duplicate_element,
                    inputs=[chinese_full_paragraph_input],
                    outputs=chinese_full_paragraph_refine_input
                ).then(
                    fn=enable_elements,
                    inputs=[],
                    outputs=[chinese_full_paragraph_evaluate_button]
                )

                generate_chinese_full_paragraph_refine_button.click(
                    fn=disable_elements,
                    inputs=[],
                    outputs=[
                        generate_chinese_full_paragraph_refine_button
                    ]
                ).then(
                    fn=get_chinese_conversation_thread_id,
                    inputs=[chinese_thread_id_state],
                    outputs=[chinese_thread_id_state]
                ).then(
                    fn=get_chinese_paragraph_refine_evaluate_content,
                    inputs=[
                        chinese_thread_id_state,
                        model, 
                        chinese_assignment_topic,
                        chinese_assignment_introduction,
                        chinese_assignment_description,
                        chinese_full_paragraph_refine_input,                    ],
                    outputs=[chinese_full_paragraph_refine_output_text, chinese_full_paragraph_refine_output_table]
                ).then(
                    fn=enable_elements,
                    inputs=[],
                    outputs=[generate_chinese_full_paragraph_refine_button]
                )

                chinese_full_paragraph_save_button.click(
                    fn=paragraph_save_and_tts,
                    inputs=[chinese_full_paragraph_refine_input],
                    outputs=[chinese_full_paragraph_save_output, chinese_full_audio_output]
                )

            # === 歷程 session 列表
            with gr.Tab("歷程回顧"):
                with gr.Accordion("📚 中文段落練習歷程回顧", open=True) as chinese_grapragh_practice_logs_accordion:
                    with gr.Row():
                        with gr.Column(scale=1):
                            # 取得中文段落練習 log from GCS
                            chinese_paragraph_practice_logs_type = gr.State("jutor_write_chinese_full_paragraph_evaluation")
                            get_chinese_paragraph_practice_logs_button = gr.Button("👉 取得中文段落寫作練習歷程", variant="primary")    
                            chinese_paragraph_practice_logs_session_list = gr.Radio(label="歷程時間列表")
                        with gr.Column(scale=3, variant="compact"):
                            with gr.Row(visible=False) as chinese_assignment_content:
                                with gr.Column():
                                    gr.Markdown("# 作業模式")
                                    gr.Markdown("<span style='color:#4e80ee'>年級</span>", visible=False)
                                    chinese_assignment_grade_history_log = gr.Markdown(visible=False)
                                    gr.Markdown("<span style='color:#4e80ee'>主題</span>")
                                    chinese_assignment_topic_history_log = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>寫作引文</span>")
                                    chinese_assignment_introduction_history_log = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>作業說明</span>")
                                    chinese_assignment_description_history_log = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>作業繳交截止時間</span>")
                                    chinese_assignment_submission_deadline_history_log = gr.Markdown()
                                    gr.Markdown("---")
                                    gr.Markdown("# 回傳作業內容")

                            with gr.Row():
                                with gr.Column():
                                    gr.Markdown("<span style='color:#4e80ee'>輸入段落全文</span>")
                                    chinese_full_paragraph_input_history_log = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落全文分析</span>")
                                    chinese_full_paragraph_evaluate_output_text_history_log = gr.Markdown()
                                    chinese_full_paragraph_evaluate_output_table_history_log = gr.Dataframe(wrap=True, column_widths=[35, 15, 50], interactive=False)

                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議 輸入</span>")
                                    chinese_full_paragraph_refine_input_history_log = gr.Markdown()
                                    gr.Markdown("<span style='color:#4e80ee'>段落改善建議</span>")
                                    chinese_full_paragraph_refine_output_text_history_log = gr.Markdown()
                                    chinese_full_paragraph_refine_output_table_history_log = gr.Dataframe(wrap=True, interactive=False, column_widths=[30, 30, 40])

                                    gr.Markdown("<span style='color:#4e80ee'>修改結果</span>")
                                    chinese_full_paragraph_save_output_history_log = gr.Markdown()

                            get_chinese_paragraph_practice_logs_button.click(
                                fn=get_logs_sessions,
                                inputs=[user_data, chinese_paragraph_practice_logs_type],
                                outputs=[chinese_paragraph_practice_logs_session_list]
                            )

                            chinese_paragraph_practice_logs_session_list.select(
                                fn=get_chinese_paragraph_practice_log_session_content,
                                inputs=[chinese_paragraph_practice_logs_session_list],
                                outputs=[
                                    chinese_full_paragraph_input_history_log,
                                    chinese_full_paragraph_evaluate_output_text_history_log,
                                    chinese_full_paragraph_evaluate_output_table_history_log,
                                    chinese_full_paragraph_refine_input_history_log,
                                    chinese_full_paragraph_refine_output_text_history_log,
                                    chinese_full_paragraph_refine_output_table_history_log,
                                    chinese_full_paragraph_save_output_history_log,

                                    chinese_assignment_content,
                                    chinese_assignment_grade_history_log,
                                    chinese_assignment_topic_history_log,
                                    chinese_assignment_introduction_history_log,
                                    chinese_assignment_description_history_log,
                                    chinese_assignment_submission_deadline_history_log
                                ]
                            )

            # =====中文作文工具=====
            with gr.Tab("中文作文工具") as chinese_idea_tab:
                # 輸入題目、輸出靈感
                with gr.Row():
                    chinese_write_idea_prompt = """
                        你是一位國文老師，善於引導學生寫作。請根據以下的題目，幫助學生生成靈感：
                    """
                    chinese_write_idea_prompt_input = gr.TextArea(label="System Prompt", value=chinese_write_idea_prompt, visible=False)
                    with gr.Column():
                        with gr.Row():
                            gr.Markdown("# 中文作文工具")
                        with gr.Row():
                            chinese_essay_title_input = gr.TextArea(label="輸入題目")
                    with gr.Column():
                        with gr.Row():
                            chinese_essay_generate_button = gr.Button("生成靈感", variant="primary")
                        with gr.Row():
                            chinese_essay_idea_output = gr.Markdown(label="生成靈感")
                    
                    chinese_essay_generate_button.click(
                        fn=generate_chinese_essay_idea,
                        inputs=[model, chinese_write_idea_prompt_input, chinese_essay_title_input],
                        outputs=chinese_essay_idea_output
                    )
 
            # 批改回饋檢測
            with gr.Tab("批改回饋檢測") as chinese_essay_feedback_check_tab:
                with gr.Row():
                    gr.Markdown("# 批改回饋檢測")
                with gr.Row():
                    with gr.Accordion("批改回饋檢測規範", open=False):
                        feedback_check_prompt = gr.Markdown("""
                                    1. 本篇佳句對該篇文章的正向肯定或佳句摘選 > 10 字
                                    2. 潤飾句子、刪冗詞贅字與修正錯別字、標點符號(提取文中使用得當的詞彙/提供不適合的詞綴替代字)  > 5 字
                                    3. 檢視文章結構、段落安排是否完整、具有連貫性  > 10 字
                                    4. 評語:予以鼓勵，指出可精進方向  > 100 字
                                    5. 以上字數計算都不包含標點符號與空格
                        """)
                with gr.Row():
                    with gr.Column():
                        chinese_essay_from_student_input = gr.TextArea(label="學生作文原文")
                        chinese_essay_feedback_check_input = gr.TextArea(label="批改回饋")
                    with gr.Column():
                        chinese_essay_feedback_check_button = gr.Button("檢測", variant="primary")
                        chinese_essay_feedback_check_output = gr.Markdown(label="檢測結果")

                    chinese_essay_feedback_check_button.click(
                        fn=check_chinese_essay_feedback,
                        inputs=[feedback_check_prompt, chinese_essay_from_student_input, chinese_essay_feedback_check_input],
                        outputs=[chinese_essay_feedback_check_output]
                    )

    with gr.Row(visible=False) as assignment_group:
        with gr.Column():
            with gr.Row():
                gr.Markdown("# 📝 作業管理")
            with gr.Accordion("💡 提醒", open=True):
                gr.Markdown("Cutor 是你得力的作文批改小幫手，但它不是老師，和你一樣都在學習，偶爾也會出錯。如果你對於 Cutor 給你的建議有疑問，請提出和平台討論喔")
            with gr.Row():
                assignment_interface = create_assignment_ui(user_data, user_email, user_nickname, _AssignmentService, _SubmissionService, _DashboardService)

    demo.load(
        init_params, 
        inputs =[],
        outputs = [
            user_data,
            user_email,
            user_nickname,
            admin_group,
            session_timestamp,
            request_origin,
            assignment_id_input,
            assignment_json,
            chinese_assignment_row,
            chinese_assignment_grade, 
            chinese_assignment_topic, 
            chinese_assignment_introduction, 
            chinese_assignment_description,
            chinese_assignment_submission_deadline,
            english_group,
            chinese_group,
            assignment_group
        ]
    )

demo.launch(server_name="0.0.0.0", server_port=7860)