import gradio as gr
import pandas as pd
import requests
from bs4 import BeautifulSoup
from docx import Document
import os
from openai import OpenAI
from groq import Groq
import uuid
from gtts import gTTS
import math
from pydub import AudioSegment


from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import NoTranscriptFound
import yt_dlp

from moviepy.editor import VideoFileClip
from pytube import YouTube
import os
import io
import time
import json
from urllib.parse import urlparse, parse_qs

from google.cloud import storage
from google.oauth2 import service_account
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload
from googleapiclient.http import MediaIoBaseDownload
from googleapiclient.http import MediaIoBaseUpload

from educational_material import EducationalMaterial
from storage_service import GoogleCloudStorage

import boto3

from chatbot import Chatbot

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

print("===gr__version__===")
print(gr.__version__)


if is_env_local:
    with open("local_config.json") as f:
        config = json.load(f)
        PASSWORD = config["PASSWORD"] 
        GCS_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
        DRIVE_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
        OPEN_AI_KEY = config["OPEN_AI_KEY"]
        GROQ_API_KEY = config["GROQ_API_KEY"]
        JUTOR_CHAT_KEY = config["JUTOR_CHAT_KEY"]
        AWS_ACCESS_KEY = config["AWS_ACCESS_KEY"]
        AWS_SECRET_KEY = config["AWS_SECRET_KEY"]
        AWS_REGION_NAME = config["AWS_REGION_NAME"]
        OUTPUT_PATH = config["OUTPUT_PATH"]
else:
    PASSWORD = os.getenv("PASSWORD")
    GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
    DRIVE_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
    OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
    JUTOR_CHAT_KEY = os.getenv("JUTOR_CHAT_KEY")
    AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY")
    AWS_SECRET_KEY = os.getenv("AWS_SECRET_KEY")
    AWS_REGION_NAME = 'us-west-2'
    OUTPUT_PATH = 'videos'

TRANSCRIPTS = []
CURRENT_INDEX = 0

OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)
GROQ_CLIENT = Groq(api_key=GROQ_API_KEY)
GCS_SERVICE = GoogleCloudStorage(GCS_KEY)
GCS_CLIENT = GCS_SERVICE.client
BEDROCK_CLIENT = boto3.client(
    service_name="bedrock-runtime",
    aws_access_key_id=AWS_ACCESS_KEY,
    aws_secret_access_key=AWS_SECRET_KEY,
    region_name=AWS_REGION_NAME,
)

# 驗證 password
def verify_password(password):
    if password == PASSWORD:
        return True
    else:
        raise gr.Error("密碼錯誤")

# ====gcs====
def gcs_check_file_exists(gcs_client, bucket_name, file_name):
    """
    检查 GCS 存储桶中是否存在指定的文件
    file_name 格式：{folder_name}/{file_name}
    """
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(file_name)
    return blob.exists()

def upload_file_to_gcs(gcs_client, bucket_name, destination_blob_name, file_path):
    """上传文件到指定的 GCS 存储桶"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)
    blob.upload_from_filename(file_path)
    print(f"File {file_path} uploaded to {destination_blob_name} in GCS.")

def upload_file_to_gcs_with_json_string(gcs_client, bucket_name, destination_blob_name, json_string):
    """上传字符串到指定的 GCS 存储桶"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)
    blob.upload_from_string(json_string)
    print(f"JSON string uploaded to {destination_blob_name} in GCS.")

def download_blob_to_string(gcs_client, bucket_name, source_blob_name):
    """从 GCS 下载文件内容到字符串"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(source_blob_name)
    return blob.download_as_text()

def make_blob_public(gcs_client, bucket_name, blob_name):
    """将指定的 GCS 对象设置为公共可读"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    blob.make_public()
    print(f"Blob {blob_name} is now publicly accessible at {blob.public_url}")

def get_blob_public_url(gcs_client, bucket_name, blob_name):
    """获取指定 GCS 对象的公开 URL"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    return blob.public_url

def upload_img_and_get_public_url(gcs_client, bucket_name, file_name, file_path):
    """上传图片到 GCS 并获取其公开 URL"""
    # 上传图片
    upload_file_to_gcs(gcs_client, bucket_name, file_name, file_path)
    # 将上传的图片设置为公开
    make_blob_public(gcs_client, bucket_name, file_name)
    # 获取图片的公开 URL
    public_url = get_blob_public_url(gcs_client, bucket_name, file_name)
    print(f"Public URL for the uploaded image: {public_url}")
    return public_url

def copy_all_files_from_drive_to_gcs(drive_service, gcs_client, drive_folder_id, bucket_name, gcs_folder_name):
    # Get all files from the folder
    query = f"'{drive_folder_id}' in parents and trashed = false"
    response = drive_service.files().list(q=query).execute()
    files = response.get('files', [])
    for file in files:
        # Copy each file to GCS
        file_id = file['id']
        file_name = file['name']
        gcs_destination_path = f"{gcs_folder_name}/{file_name}"
        copy_file_from_drive_to_gcs(drive_service, gcs_client, file_id, bucket_name, gcs_destination_path)

def copy_file_from_drive_to_gcs(drive_service, gcs_client, file_id, bucket_name, gcs_destination_path):
    # Download file content from Drive
    request = drive_service.files().get_media(fileId=file_id)
    fh = io.BytesIO()
    downloader = MediaIoBaseDownload(fh, request)
    done = False
    while not done:
        status, done = downloader.next_chunk()
    fh.seek(0)
    file_content = fh.getvalue()

    # Upload file content to GCS
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(gcs_destination_path)
    blob.upload_from_string(file_content)
    print(f"File {file_id} copied to GCS at {gcs_destination_path}.")

def delete_blob(gcs_client, bucket_name, blob_name):
    """删除指定的 GCS 对象"""
    bucket = gcs_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    blob.delete()
    print(f"Blob {blob_name} deleted from GCS.")

# # ====drive====初始化
def init_drive_service():
    credentials_json_string = DRIVE_KEY
    credentials_dict = json.loads(credentials_json_string)
    SCOPES = ['https://www.googleapis.com/auth/drive']
    credentials = service_account.Credentials.from_service_account_info(
            credentials_dict, scopes=SCOPES)
    service = build('drive', 'v3', credentials=credentials)
    return service

def create_folder_if_not_exists(service, folder_name, parent_id):
    print("检查是否存在特定名称的文件夹，如果不存在则创建")
    query = f"mimeType='application/vnd.google-apps.folder' and name='{folder_name}' and '{parent_id}' in parents and trashed=false"
    response = service.files().list(q=query, spaces='drive', fields="files(id, name)").execute()
    folders = response.get('files', [])
    if not folders:
        # 文件夹不存在，创建新文件夹
        file_metadata = {
            'name': folder_name,
            'mimeType': 'application/vnd.google-apps.folder',
            'parents': [parent_id]
        }
        folder = service.files().create(body=file_metadata, fields='id').execute()
        return folder.get('id')
    else:
        # 文件夹已存在
        return folders[0]['id']

# 检查Google Drive上是否存在文件
def check_file_exists(service, folder_name, file_name):
    query = f"name = '{file_name}' and '{folder_name}' in parents and trashed = false"
    response = service.files().list(q=query).execute()
    files = response.get('files', [])
    return len(files) > 0, files[0]['id'] if files else None

def upload_content_directly(service, file_name, folder_id, content):
    """
    直接将内容上传到Google Drive中的新文件。
    """
    if not file_name:
        raise ValueError("文件名不能为空")
    if not folder_id:
        raise ValueError("文件夹ID不能为空")
    if content is None:  # 允许空字符串上传，但不允许None
        raise ValueError("内容不能为空")
    
    file_metadata = {'name': file_name, 'parents': [folder_id]}
    # 使用io.BytesIO为文本内容创建一个内存中的文件对象
    try:
        with io.BytesIO(content.encode('utf-8')) as fh:
            media = MediaIoBaseUpload(fh, mimetype='text/plain', resumable=True)
            
            print("==content==")
            print(content)
            print("==content==")

            print("==media==")
            print(media)
            print("==media==")
            # 执行上传
            file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
            return file.get('id')
    except Exception as e:
        print(f"上传文件时发生错误: {e}")
        raise  # 重新抛出异常，调用者可以根据需要处理或忽略

def upload_file_directly(service, file_name, folder_id, file_path):
    # 上傳 .json to Google Drive
    file_metadata = {'name': file_name, 'parents': [folder_id]}
    media = MediaFileUpload(file_path, mimetype='application/json')
    file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
    
    
    # return file.get('id')  # 返回文件ID
    return True

def upload_img_directly(service, file_name, folder_id, file_path):
    file_metadata = {'name': file_name, 'parents': [folder_id]}
    media = MediaFileUpload(file_path, mimetype='image/jpeg')
    file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
    return file.get('id')  # 返回文件ID

def download_file_as_string(service, file_id):
    """
    从Google Drive下载文件并将其作为字符串返回。
    """
    request = service.files().get_media(fileId=file_id)
    fh = io.BytesIO()
    downloader = MediaIoBaseDownload(fh, request)
    done = False
    while done is False:
        status, done = downloader.next_chunk()
    fh.seek(0)
    content = fh.read().decode('utf-8')
    return content

def set_public_permission(service, file_id):
    service.permissions().create(
        fileId=file_id,
        body={"type": "anyone", "role": "reader"},
        fields='id',
    ).execute()

def update_file_on_drive(service, file_id, file_content):
    """
    更新Google Drive上的文件内容。
    
    参数:
    - service: Google Drive API服务实例。
    - file_id: 要更新的文件的ID。
    - file_content: 新的文件内容，字符串格式。
    """
    # 将新的文件内容转换为字节流
    fh = io.BytesIO(file_content.encode('utf-8'))
    media = MediaIoBaseUpload(fh, mimetype='application/json', resumable=True)
    
    # 更新文件
    updated_file = service.files().update(
        fileId=file_id,
        media_body=media
    ).execute()
    
    print(f"文件已更新，文件ID: {updated_file['id']}")

# ---- Text file ----
def process_file(password, file):
    verify_password(password)
    
    # 读取文件
    if file.name.endswith('.csv'):
        df = pd.read_csv(file)
        text = df_to_text(df)
    elif file.name.endswith('.xlsx'):
        df = pd.read_excel(file)
        text = df_to_text(df)
    elif file.name.endswith('.docx'):
        text = docx_to_text(file)
    else:
        raise ValueError("Unsupported file type")

    df_string = df.to_string()
    # 宜蘭：移除@XX@符号 to |
    df_string = df_string.replace("@XX@", "|")

    # 根据上传的文件内容生成问题
    questions = generate_questions(df_string)
    summary = generate_summarise(df_string)

    # 返回按钮文本和 DataFrame 字符串
    return questions[0] if len(questions) > 0 else "", \
           questions[1] if len(questions) > 1 else "", \
           questions[2] if len(questions) > 2 else "", \
           summary, \
           df_string

def df_to_text(df):
    # 将 DataFrame 转换为纯文本
    return df.to_string()

def docx_to_text(file):
    # 将 Word 文档转换为纯文本
    doc = Document(file)
    return "\n".join([para.text for para in doc.paragraphs])


# ---- YouTube link ----
def format_seconds_to_time(seconds):
    """将秒数格式化为 时:分:秒 的形式"""
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    seconds = int(seconds % 60)
    return f"{hours:02}:{minutes:02}:{seconds:02}"

def extract_youtube_id(url):
    parsed_url = urlparse(url)
    
    if "youtube.com" in parsed_url.netloc:
        # 对于标准链接，视频ID在查询参数'v'中
        query_params = parse_qs(parsed_url.query)
        return query_params.get("v")[0] if "v" in query_params else None
    elif "youtu.be" in parsed_url.netloc:
        # 对于短链接，视频ID是路径的一部分
        return parsed_url.path.lstrip('/')
    else:
        return None

def get_transcript(video_id):
    languages = ['zh-TW', 'zh-Hant', 'zh', 'en']  # 優先順序列表
    for language in languages:
        try:
            transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
            print("===transcript===")
            print(transcript)
            print("===transcript===")
            return transcript  # 成功獲取字幕，直接返回結果
        except NoTranscriptFound:
            continue  # 當前語言的字幕沒有找到，繼續嘗試下一個語言
    return None  # 所有嘗試都失敗，返回None

def generate_transcription(video_id):
    youtube_url = f'https://www.youtube.com/watch?v={video_id}'
    codec_name = "mp3"
    outtmpl = f"{OUTPUT_PATH}/{video_id}.%(ext)s"
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': codec_name,
            'preferredquality': '192'
        }],
        'outtmpl': outtmpl,
    }

    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        ydl.download([youtube_url])

    audio_path = f"{OUTPUT_PATH}/{video_id}.{codec_name}"
    full_audio = AudioSegment.from_mp3(audio_path)

    max_part_duration = 10 * 60 * 1000  # 10 minutes
    full_duration = len(full_audio)  # in milliseconds
    parts = math.ceil(full_duration / max_part_duration)
    print(f"parts: {parts}")
    transcription = []

    for i in range(parts):
        print(f"== i: {i}==")
        start_time = i * max_part_duration
        end_time = min((i + 1) * max_part_duration, full_duration)
        print(f"time: {start_time/1000} - {end_time/1000}")
        chunk = full_audio[start_time:end_time]
        chunk_path = f"{OUTPUT_PATH}/{video_id}_part_{i}.{codec_name}"
        chunk.export(chunk_path, format=codec_name)

        try:
            with open(chunk_path, "rb") as chunk_file:
                response = OPEN_AI_CLIENT.audio.transcriptions.create(
                    model="whisper-1",
                    file=chunk_file,
                    response_format="verbose_json",
                    timestamp_granularities=["segment"],
                    prompt="Transcribe the following audio file. if content is chinese, please using 'language: zh-TW' ",
                )
                
                # Adjusting the timestamps for the chunk based on its position in the full audio
                adjusted_segments = [{
                    'text': segment['text'],
                    'start': math.ceil(segment['start'] + start_time / 1000.0),  # Converting milliseconds to seconds
                    'end': math.ceil(segment['end'] + start_time / 1000.0),
                    'duration': math.ceil(segment['end'] - segment['start'])
                } for segment in response.segments]

                transcription.extend(adjusted_segments)
        except Exception as e:
            print(f"Error processing chunk {i}: {str(e)}")

        # Remove temporary chunk files after processing
        os.remove(chunk_path)

    return transcription
 
def process_transcript_and_screenshots_on_gcs(video_id):
    print("====process_transcript_and_screenshots_on_gcs====")
    # GCS
    gcs_client = GCS_CLIENT
    bucket_name = 'video_ai_assistant'
    # 逐字稿文件名
    transcript_file_name = f'{video_id}_transcript.json'
    transcript_blob_name = f"{video_id}/{transcript_file_name}"
    # 检查逐字稿是否存在
    is_new_transcript = False
    is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
    if not is_transcript_exists:
        print("逐字稿文件不存在于GCS中，重新建立")
        # 从YouTube获取逐字稿并上传
        try:
            transcript = get_transcript(video_id)
        except:
            # call open ai whisper
            print("===call open ai whisper===")
            transcript = generate_transcription(video_id)

        if transcript:
            print("成功獲取字幕")
        else:
            print("沒有找到字幕")
            transcript = generate_transcription(video_id)

        transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, transcript_text)
        is_new_transcript = True
    else:
        # 逐字稿已存在，下载逐字稿内容
        print("逐字稿已存在于GCS中")
        transcript_text = download_blob_to_string(gcs_client, bucket_name, transcript_blob_name)
        transcript = json.loads(transcript_text)

    # print("===確認其他衍生文件===")
    # source = "gcs"
    # get_questions(video_id, transcript_text, source)
    # get_video_id_summary(video_id, transcript_text, source)
    # get_mind_map(video_id, transcript_text, source)
    # print("===確認其他衍生文件 end ===")


    # 處理截圖
    for entry in transcript:
        if 'img_file_id' not in entry:
            # 檢查 OUTPUT_PATH 是否存在 video_id.mp4
            video_path = f'{OUTPUT_PATH}/{video_id}.mp4'
            if not os.path.exists(video_path):
                # try 5 times 如果都失敗就 raise
                for i in range(5):
                    try:
                        download_youtube_video(video_id)
                        break
                    except Exception as e:
                        if i == 4:
                            raise gr.Error(f"下载视频失败: {str(e)}")
                        time.sleep(5)
            # 截图                    
            screenshot_path = screenshot_youtube_video(video_id, entry['start'])
            screenshot_blob_name = f"{video_id}/{video_id}_{entry['start']}.jpg"
            img_file_id = upload_img_and_get_public_url(gcs_client, bucket_name, screenshot_blob_name, screenshot_path)
            entry['img_file_id'] = img_file_id
            print(f"截图已上传到GCS: {img_file_id}")
            is_new_transcript = True
    
    # 確認是否更新逐字稿文件
    if is_new_transcript:
        # 更新逐字稿文件
        print("===更新逐字稿文件===")
        print(transcript)
        print("===更新逐字稿文件===")
        updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, updated_transcript_text)
        print("逐字稿已更新，包括截图链接")
        updated_transcript_json = json.loads(updated_transcript_text)
    else:
        updated_transcript_json = transcript

    return updated_transcript_json

def process_youtube_link(password, link):
    verify_password(password)

    # 使用 YouTube API 获取逐字稿
    # 假设您已经获取了 YouTube 视频的逐字稿并存储在变量 `transcript` 中
    video_id = extract_youtube_id(link)
    
    try:
        transcript = process_transcript_and_screenshots_on_gcs(video_id)
    except Exception as e:
        error_msg = f" {video_id} 逐字稿錯誤: {str(e)}"
        print("===process_youtube_link error===")
        print(error_msg)
        raise gr.Error(error_msg)

    original_transcript = json.dumps(transcript, ensure_ascii=False, indent=2)
    formatted_transcript = []
    formatted_simple_transcript =[]
    for entry in transcript:
        start_time = format_seconds_to_time(entry['start'])
        end_time = format_seconds_to_time(entry['start'] + entry['duration'])
        embed_url = get_embedded_youtube_link(video_id, entry['start'])
        img_file_id = entry['img_file_id']
        screenshot_path = img_file_id
        line = {
            "start_time": start_time,
            "end_time": end_time,
            "text": entry['text'],
            "embed_url": embed_url,
            "screenshot_path": screenshot_path
        }
        formatted_transcript.append(line)
        # formatted_simple_transcript 只要 start_time, end_time, text
        simple_line = {
            "start_time": start_time,
            "end_time": end_time,
            "text": entry['text']
        }
        formatted_simple_transcript.append(simple_line)

    global TRANSCRIPTS
    TRANSCRIPTS = formatted_transcript

    # 基于逐字稿生成其他所需的输出
    source = "gcs"
    questions = get_questions(video_id, formatted_simple_transcript, source)
    questions_json = json.dumps(questions, ensure_ascii=False, indent=2)
    summary_json = get_video_id_summary(video_id, formatted_simple_transcript, source)
    summary = summary_json["summary"]
    key_moments_json = get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source)
    key_moments = key_moments_json["key_moments"]
    key_moments_text = json.dumps(key_moments, ensure_ascii=False, indent=2)
    key_moments_html = get_key_moments_html(key_moments)
    html_content = format_transcript_to_html(formatted_transcript)
    simple_html_content = format_simple_transcript_to_html(formatted_simple_transcript)
    first_image = formatted_transcript[0]['screenshot_path']
    # first_image = "https://www.nameslook.com/names/dfsadf-nameslook.png"
    first_text = formatted_transcript[0]['text']
    mind_map_json = get_mind_map(video_id, formatted_simple_transcript, source)
    mind_map = mind_map_json["mind_map"]
    mind_map_html = get_mind_map_html(mind_map)
    reading_passage_json = get_reading_passage(video_id, formatted_simple_transcript, source)
    reading_passage = reading_passage_json["reading_passage"]
    meta_data = get_meta_data(video_id)
    subject = meta_data["subject"]
    grade = meta_data["grade"]

    # 确保返回与 UI 组件预期匹配的输出
    return video_id, \
        questions_json, \
        questions[0] if len(questions) > 0 else "", \
        questions[1] if len(questions) > 1 else "", \
        questions[2] if len(questions) > 2 else "", \
        original_transcript, \
        summary, \
        key_moments_text, \
        key_moments_html, \
        mind_map, \
        mind_map_html, \
        html_content, \
        simple_html_content, \
        first_image, \
        first_text, \
        reading_passage, \
        subject, \
        grade
            
def create_formatted_simple_transcript(transcript):
    formatted_simple_transcript = []
    for entry in transcript:
        start_time = format_seconds_to_time(entry['start'])
        end_time = format_seconds_to_time(entry['start'] + entry['duration'])
        line = {
            "start_time": start_time,
            "end_time": end_time,
            "text": entry['text']
        }
        formatted_simple_transcript.append(line)
    return formatted_simple_transcript

def create_formatted_transcript(video_id, transcript):
    formatted_transcript = []
    for entry in transcript:
        start_time = format_seconds_to_time(entry['start'])
        end_time = format_seconds_to_time(entry['start'] + entry['duration'])
        embed_url = get_embedded_youtube_link(video_id, entry['start'])
        img_file_id = entry['img_file_id']
        screenshot_path = img_file_id
        line = {
            "start_time": start_time,
            "end_time": end_time,
            "text": entry['text'],
            "embed_url": embed_url,
            "screenshot_path": screenshot_path
        }
        formatted_transcript.append(line)
    return formatted_transcript

def format_transcript_to_html(formatted_transcript):
    html_content = ""
    for entry in formatted_transcript:
        html_content += f"<h3>{entry['start_time']} - {entry['end_time']}</h3>"
        html_content += f"<p>{entry['text']}</p>"
        html_content += f"<img src='{entry['screenshot_path']}' width='500px' />"
    return html_content

def format_simple_transcript_to_html(formatted_transcript):
    html_content = ""
    for entry in formatted_transcript:
        html_content += f"<h3>{entry['start_time']} - {entry['end_time']}</h3>"
        html_content += f"<p>{entry['text']}</p>"
    return html_content

def get_embedded_youtube_link(video_id, start_time):
    int_start_time = int(start_time)
    embed_url = f"https://www.youtube.com/embed/{video_id}?start={int_start_time}&autoplay=1"
    return embed_url

def download_youtube_video(youtube_id, output_path=OUTPUT_PATH):
    # Construct the full YouTube URL
    youtube_url = f'https://www.youtube.com/watch?v={youtube_id}'

    # Create the output directory if it doesn't exist
    if not os.path.exists(output_path):
        os.makedirs(output_path)

    # Download the video
    yt = YouTube(youtube_url)
    video_stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
    video_stream.download(output_path=output_path, filename=youtube_id+".mp4")

    print(f"Video downloaded successfully: {output_path}/{youtube_id}.mp4")

def screenshot_youtube_video(youtube_id, snapshot_sec):    
    video_path = f'{OUTPUT_PATH}/{youtube_id}.mp4'
    file_name = f"{youtube_id}_{snapshot_sec}.jpg"
    with VideoFileClip(video_path) as video:
        screenshot_path = f'{OUTPUT_PATH}/{file_name}'
        video.save_frame(screenshot_path, snapshot_sec)
    
    return screenshot_path


# ---- Web ----
# def process_web_link(link):
#     # 抓取和解析网页内容
#     response = requests.get(link)
#     soup = BeautifulSoup(response.content, 'html.parser')
#     return soup.get_text()


# ---- LLM Generator ----
def get_reading_passage(video_id, df_string, source):
    if source == "gcs":
        print("===get_reading_passage on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_reading_passage.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查 reading_passage 是否存在
        is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_file_exists:
            reading_passage = generate_reading_passage(df_string)
            reading_passage_json = {"reading_passage": str(reading_passage)}
            reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
            print("reading_passage已上传到GCS")
        else:
            # reading_passage已存在，下载内容
            print("reading_passage已存在于GCS中")
            reading_passage_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
            reading_passage_json = json.loads(reading_passage_text)

    elif source == "drive":
        print("===get_reading_passage on drive===")
        service = init_drive_service()
        parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
        folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
        file_name = f'{video_id}_reading_passage.json'

        # 检查 reading_passage 是否存在
        exists, file_id = check_file_exists(service, folder_id, file_name)
        if not exists:
            reading_passage = generate_reading_passage(df_string)
            reading_passage_json = {"reading_passage": str(reading_passage)}
            reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
            upload_content_directly(service, file_name, folder_id, reading_passage_text)
            print("reading_passage已上傳到Google Drive")
        else:
            # reading_passage已存在，下载内容
            print("reading_passage已存在于Google Drive中")
            reading_passage_text = download_file_as_string(service, file_id)

    return reading_passage_json

def generate_reading_passage(df_string):
    # 使用 OpenAI 生成基于上传数据的问题
    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
    user_content = f"""
        請根據 {df_string} 
        文本自行判斷資料的種類
        幫我組合成 Reading Passage
        並潤稿讓文句通順
        請一定要使用繁體中文 zh-TW，並用台灣人的口語
        產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
        只需要專注提供 Reading Passage，字數在 500 字以內
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": "gpt-4-1106-preview",
        "messages": messages,
        "max_tokens": 4000,
    }

    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
    reading_passage = response.choices[0].message.content.strip()
    print("=====reading_passage=====")
    print(reading_passage)
    print("=====reading_passage=====")

    return reading_passage

def text_to_speech(video_id, text):
    tts = gTTS(text, lang='en')
    filename = f'{video_id}_reading_passage.mp3'
    tts.save(filename)
    return filename

def get_mind_map(video_id, df_string, source):
    if source == "gcs":
        print("===get_mind_map on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_mind_map.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查檔案是否存在
        is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_file_exists:
            mind_map = generate_mind_map(df_string)
            mind_map_json = {"mind_map": str(mind_map)}
            mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, mind_map_text)
            print("mind_map已上傳到GCS")
        else:
            # mindmap已存在，下载内容
            print("mind_map已存在于GCS中")
            mind_map_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
            mind_map_json = json.loads(mind_map_text)

    elif source == "drive":
        print("===get_mind_map on drive===")
        service = init_drive_service()
        parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
        folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
        file_name = f'{video_id}_mind_map.json'

        # 检查檔案是否存在
        exists, file_id = check_file_exists(service, folder_id, file_name)
        if not exists:
            mind_map = generate_mind_map(df_string)
            mind_map_json = {"mind_map": str(mind_map)}
            mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
            upload_content_directly(service, file_name, folder_id, mind_map_text)
            print("mind_map已上傳到Google Drive")
        else:
            # mindmap已存在，下载内容
            print("mind_map已存在于Google Drive中")
            mind_map_text = download_file_as_string(service, file_id)
            mind_map_json = json.loads(mind_map_text)

    return mind_map_json

def generate_mind_map(df_string):
    # 使用 OpenAI 生成基于上传数据的问题
    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
    user_content = f"""
        請根據 {df_string} 文本建立 markdown 心智圖
        注意：不需要前後文敘述，直接給出 markdown 文本即可
        這對我很重要
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": "gpt-4-1106-preview",
        "messages": messages,
        "max_tokens": 4000,
    }

    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
    mind_map = response.choices[0].message.content.strip()
    print("=====mind_map=====")
    print(mind_map)
    print("=====mind_map=====")

    return mind_map

def get_mind_map_html(mind_map):
    mind_map_markdown = mind_map.replace("```markdown", "").replace("```", "")

    mind_map_html = f"""
    <div class="markmap">
        <script type="text/template">
            {mind_map_markdown}
        </script>
    </div>
    """
    return mind_map_html

def get_video_id_summary(video_id, df_string, source):
    if source == "gcs":
        print("===get_video_id_summary on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_summary.json'
        summary_file_blob_name = f"{video_id}/{file_name}"
        # 检查 summary_file 是否存在
        is_summary_file_exists = GCS_SERVICE.check_file_exists(bucket_name, summary_file_blob_name)
        if not is_summary_file_exists:
            summary = generate_summarise(df_string)
            summary_json = {"summary": str(summary)}
            summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, summary_file_blob_name, summary_text)
            print("summary已上传到GCS")
        else:
            # summary已存在，下载内容
            print("summary已存在于GCS中")
            summary_text = download_blob_to_string(gcs_client, bucket_name, summary_file_blob_name)
            summary_json = json.loads(summary_text)

    elif source == "drive":
        print("===get_video_id_summary===")
        service = init_drive_service()
        parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
        folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
        file_name = f'{video_id}_summary.json'

        # 检查逐字稿是否存在
        exists, file_id = check_file_exists(service, folder_id, file_name)
        if not exists:
            summary = generate_summarise(df_string)
            summary_json = {"summary": str(summary)}
            summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
            
            try:
                upload_content_directly(service, file_name, folder_id, summary_text)
                print("summary已上傳到Google Drive")

            except Exception as e:
                error_msg = f" {video_id} 摘要錯誤: {str(e)}"
                print("===get_video_id_summary error===")
                print(error_msg)
                print("===get_video_id_summary error===")
        else:
            # 逐字稿已存在，下载逐字稿内容
            print("summary已存在Google Drive中")
            summary_text = download_file_as_string(service, file_id)
            summary_json = json.loads(summary_text)
        
    return summary_json
    
def generate_summarise(df_string):
    # 使用 OpenAI 生成基于上传数据的问题
    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
    user_content = f"""
        請根據 {df_string}，判斷這份文本
        如果是資料類型，請提估欄位敘述、資料樣態與資料分析，告訴學生這張表的意義，以及可能的結論與對應方式
        
        如果是影片類型，請提估影片內容，告訴學生這部影片的意義，
        整體摘要在一百字以內
        小範圍切出不同段落的相對應時間軸的重點摘要，最多不超過五段
        注意不要遺漏任何一段時間軸的內容
        格式為 【start - end】: 摘要
        以及可能的結論與結尾延伸小問題提供學生作反思

        整體格式為：
        🗂️ 1. 內容類型：？
        📚 2. 整體摘要
        🔖 3. 重點概念
        🔑 4. 關鍵時刻
        💡 5. 為什麼我們要學這個？
        ❓ 6. 延伸小問題
    """

    # 🗂️ 1. 內容類型：？
    #     📚 2. 整體摘要
    #     🔖 3. 條列式重點
    #     🔑 4. 關鍵時刻（段落摘要）
    #     💡 5. 結論反思（為什麼我們要學這個？）
    #     ❓ 6. 延伸小問題

    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]

    request_payload = {
        "model": "gpt-4-turbo-preview",
        "messages": messages,
        "max_tokens": 4000,
    }

    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
    df_summarise = response.choices[0].message.content.strip()
    print("=====df_summarise=====")
    print(df_summarise)
    print("=====df_summarise=====")

    return df_summarise

def get_questions(video_id, df_string, source="gcs"):
    if source == "gcs":
        # 去 gcs 確認是有有 video_id_questions.json
        print("===get_questions on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_questions.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查檔案是否存在
        is_questions_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_questions_exists:
            questions = generate_questions(df_string)
            questions_text = json.dumps(questions, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_text)
            print("questions已上傳到GCS")
        else:
            # 逐字稿已存在，下载逐字稿内容
            print("questions已存在于GCS中")
            questions_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
            questions = json.loads(questions_text)
    
    elif source == "drive":
        # 去 g drive 確認是有有 video_id_questions.json
        print("===get_questions===")
        service = init_drive_service()
        parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
        folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
        file_name = f'{video_id}_questions.json'

        # 检查檔案是否存在
        exists, file_id = check_file_exists(service, folder_id, file_name)
        if not exists:
            questions = generate_questions(df_string)
            questions_text = json.dumps(questions, ensure_ascii=False, indent=2)
            upload_content_directly(service, file_name, folder_id, questions_text)
            print("questions已上傳到Google Drive")
        else:
            # 逐字稿已存在，下载逐字稿内容
            print("questions已存在于Google Drive中")
            questions_text = download_file_as_string(service, file_id)
            questions = json.loads(questions_text)

    q1 = questions[0] if len(questions) > 0 else ""
    q2 = questions[1] if len(questions) > 1 else ""
    q3 = questions[2] if len(questions) > 2 else ""
    print("=====get_questions=====")
    print(f"q1: {q1}")
    print(f"q2: {q2}")
    print(f"q3: {q3}")
    print("=====get_questions=====")
    return q1, q2, q3

def generate_questions(df_string):
    # 使用 OpenAI 生成基于上传数据的问题

    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
    user_content = f"請根據 {df_string} 生成三個問題，並用 JSON 格式返回 questions:[q1的敘述text, q2的敘述text, q3的敘述text]"
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]
    response_format = { "type": "json_object" }

    print("=====messages=====")
    print(messages)
    print("=====messages=====")


    request_payload = {
        "model": "gpt-4-1106-preview",
        "messages": messages,
        "max_tokens": 4000,
        "response_format": response_format
    }

    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
    questions = json.loads(response.choices[0].message.content)["questions"]
    print("=====json_response=====")
    print(questions)
    print("=====json_response=====")

    return questions

def change_questions(password, df_string):
    verify_password(password)

    questions = generate_questions(df_string)
    q1 = questions[0] if len(questions) > 0 else ""
    q2 = questions[1] if len(questions) > 1 else ""
    q3 = questions[2] if len(questions) > 2 else ""
    print("=====get_questions=====")
    print(f"q1: {q1}")
    print(f"q2: {q2}")
    print(f"q3: {q3}")
    print("=====get_questions=====")
    return q1, q2, q3

# 「關鍵時刻」另外獨立成一個 tab，時間戳記和文字的下方附上對應的截圖，重點摘要的「關鍵時刻」加上截圖資訊
def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source):
    if source == "gcs":
        print("===get_key_moments on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_key_moments.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查檔案是否存在
        is_key_moments_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_key_moments_exists:
            key_moments = generate_key_moments(formatted_simple_transcript, formatted_transcript)
            key_moments_json = {"key_moments": key_moments}
            key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
            print("key_moments已上傳到GCS")
        else:
            # key_moments已存在，下载内容
            print("key_moments已存在于GCS中")
            key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
            key_moments_json = json.loads(key_moments_text)
             # 檢查 key_moments 是否有 keywords
            print("===檢查 key_moments 是否有 keywords===")
            has_keywords_added = False
            for key_moment in key_moments_json["key_moments"]:
                if "keywords" not in key_moment:
                    transcript = key_moment["transcript"]
                    key_moment["keywords"] = generate_key_moments_keywords(transcript)
                    print("===keywords===")
                    print(key_moment["keywords"])
                    print("===keywords===")
                    has_keywords_added = True
            if has_keywords_added:
                key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
                upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
                key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
                key_moments_json = json.loads(key_moments_text)

    elif source == "drive":
        print("===get_key_moments on drive===")
        service = init_drive_service()
        parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
        folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
        file_name = f'{video_id}_key_moments.json'

        # 检查檔案是否存在
        exists, file_id = check_file_exists(service, folder_id, file_name)
        if not exists:
            key_moments = generate_key_moments(formatted_simple_transcript, formatted_transcript)
            key_moments_json = {"key_moments": key_moments}
            key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
            upload_content_directly(service, file_name, folder_id, key_moments_text)
            print("key_moments已上傳到Google Drive")
        else:
            # key_moments已存在，下载内容
            print("key_moments已存在于Google Drive中")
            key_moments_text = download_file_as_string(service, file_id)
            key_moments_json = json.loads(key_moments_text)
    
    return key_moments_json

def generate_key_moments(formatted_simple_transcript, formatted_transcript):
    # 使用 OpenAI 生成基于上传数据的问题
    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
    user_content = f"""
        請根據 {formatted_simple_transcript} 文本，提取出重點摘要，並給出對應的時間軸
        1. 小範圍切出不同段落的相對應時間軸的重點摘要，
        2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
        3. 注意不要遺漏任何一段時間軸的內容 從零秒開始
        4. 如果頭尾的情節不是重點，就併入到附近的段落，特別是打招呼或是介紹人物就是不重要的情節
        5. transcript 逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略
        以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
        6. 關鍵字從transcript  extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
        7. text, transcript, keywords please use or transfer zh-TW, it's very important

        並用 JSON 格式返回 key_moments:[{{
            "start": "00:00", 
            "end": "01:00", 
            "text": "逐字稿的重點摘要",
            "transcript": "逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略",
            "keywords": ["關鍵字", "關鍵字"]
        }}]
    """
    messages = [
        {"role": "system", "content": sys_content},
        {"role": "user", "content": user_content}
    ]
    response_format = { "type": "json_object" }

    request_payload = {
        "model": "gpt-4-1106-preview",
        "messages": messages,
        "max_tokens": 4096,
        "response_format": response_format
    }

    try:
        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
        print("===response===")
        print(dict(response))
        key_moments = json.loads(response.choices[0].message.content)["key_moments"]
    except Exception as e:
        error_msg = f" {video_id} 關鍵時刻錯誤: {str(e)}"
        print("===generate_key_moments error===")
        print(error_msg)
        print("===generate_key_moments error===")
        raise Exception(error_msg)

    print("=====key_moments=====")
    print(key_moments)
    print("=====key_moments=====")
    image_links = {entry['start_time']: entry['screenshot_path'] for entry in formatted_transcript}
    for moment in key_moments:
        start_time = moment['start']
        end_time = moment['end']
        moment_images = [image_links[time] for time in image_links if start_time <= time <= end_time]
        moment['images'] = moment_images

    return key_moments

def generate_key_moments_keywords(transcript):
    system_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請根據以下文本提取關鍵字"
    user_content = f"""transcript  extract to keyword
        保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式、數學表示式、物理化學符號，
        不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
        transcript：{transcript}
    """
    messages = [
        {"role": "system", "content": system_content},
        {"role": "user", "content": user_content}
    ]
    request_payload = {
        "model": "gpt-4-1106-preview",
        "messages": messages,
        "max_tokens": 100,
    }

    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
    keywords = response.choices[0].message.content.strip().split(", ")
    
    return keywords

def get_key_moments_html(key_moments):
    css = """
    <style>
    #gallery-main {
        display: flex;
        align-items: center;
        margin-bottom: 20px;
    }

    #gallery {
        position: relative;
        width: 50%;
        flex: 1;
    }

    #text-content {
        flex: 2;
        margin-left: 20px;
    }


    #gallery #gallery-container{
        position: relative;
        width: 100%;
        height: 0px;
        padding-bottom: 56.7%; /* 16/9 ratio */
        background-color: blue;
    }
    #gallery #gallery-container #gallery-content{
        position: absolute;
        top: 0px;
        right: 0px;
        bottom: 0px;
        left: 0px;
        height: 100%;
        display: flex;
        scroll-snap-type: x mandatory;
        overflow-x: scroll;
        scroll-behavior: smooth;
    }
    #gallery #gallery-container #gallery-content .gallery__item{
        width: 100%;
        height: 100%;
        flex-shrink: 0;
        scroll-snap-align: start;
        scroll-snap-stop: always;
        position: relative;
    }
    #gallery #gallery-container #gallery-content .gallery__item img{
        display: block;
        width: 100%;
        height: 100%;
        object-fit: contain;
        background-color: white;
    }

    .click-zone{
        position: absolute;
        width: 20%;
        height: 100%;
        z-index: 3;
    }
    .click-zone.click-zone-prev{
        left: 0px;
    }
    .click-zone.click-zone-next{
        right: 0px;
    }
    #gallery:not(:hover) .arrow{
        opacity: 0.8;
    }
    .arrow{
        text-align: center;
        z-index: 3;
        position: absolute;
        display: block;
        width: 25px;
        height: 25px;
        line-height: 25px;
        background-color: black;
        border-radius: 50%;
        text-decoration: none;
        color: black;
        opacity: 0.8; 
        transition: opacity 200ms ease;
    }
    .arrow:hover{
        opacity: 1;
    }
    .arrow span{
        position: relative;
        top: 2px;
    }
    .arrow.arrow-prev{
        top: 50%;
        left: 5px;
    }
    .arrow.arrow-next{
        top: 50%;
        right: 5px;
    }
    .arrow.arrow-disabled{
        opacity:0.8;
    }

    #text-content {
        padding: 0px 36px;
    }
    #text-content p {
        margin-top: 10px;
    }

    body{
        font-family: sans-serif;
        margin: 0px;
        padding: 0px;
    }
    main{
        padding: 0px;
        margin: 0px;
        max-width: 900px;
        margin: auto;
    }
    .hidden{
        border: 0;
        clip: rect(0 0 0 0);
        height: 1px;
        margin: -1px;
        overflow: hidden;
        padding: 0;
        position: absolute;
        width: 1px;
    }

    @media (max-width: 768px) {
        #gallery-main {
            flex-direction: column; /* 在小屏幕上堆叠元素 */
        }

        #gallery {
            width: 100%; /* 让画廊占满整个容器宽度 */
        }

        #text-content {
            margin-left: 0; /* 移除左边距，让文本内容占满宽度 */
            margin-top: 20px; /* 为文本内容添加顶部间距 */
        }

        #gallery #gallery-container {
            height: 350px; /* 或者你可以设置一个固定的高度，而不是用 padding-bottom */
            padding-bottom: 0; /* 移除底部填充 */
        }
    }
    </style>
    """

    key_moments_html = css

    for i, moment in enumerate(key_moments):
        images = moment['images']
        image_elements = ""
        
        for j, image in enumerate(images):
            current_id = f"img_{i}_{j}"
            prev_id = f"img_{i}_{j-1}" if j-1 >= 0 else f"img_{i}_{len(images)-1}"
            next_id = f"img_{i}_{j+1}" if j+1 < len(images) else f"img_{i}_0"

            image_elements += f"""
                <div id="{current_id}" class="gallery__item">
                    <a href="#{prev_id}" class="click-zone click-zone-prev">
                        <div class="arrow arrow-disabled arrow-prev"> < </div>
                    </a> 
                    <a href="#{next_id}" class="click-zone click-zone-next">
                        <div class="arrow arrow-next"> > </div>
                    </a>
                    <img src="{image}">
                </div>
            """

        gallery_content = f"""
            <div id="gallery-content">
                {image_elements}
            </div>
        """

        key_moments_html += f"""
        <div class="gallery-container" id="gallery-main">
            <div id="gallery"><!-- gallery start -->
                <div id="gallery-container">
                    {gallery_content}
                </div>
            </div>
            <div id="text-content">
                <h3>{moment['start']} - {moment['end']}</h3>
                <p><strong>摘要: {moment['text']} </strong></p>
                <p>內容: {moment['transcript']}</p>
            </div>
        </div>
        """

    return key_moments_html

# ---- LLM CRUD ----
def enable_edit_mode():
    return gr.update(interactive=True)

def delete_LLM_content(video_id, kind):
    print(f"===delete_{kind}===")
    gcs_client = GCS_CLIENT
    bucket_name = 'video_ai_assistant'
    file_name = f'{video_id}_{kind}.json'
    blob_name = f"{video_id}/{file_name}"
    # 检查 file 是否存在
    is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
    if is_file_exists:
        delete_blob(gcs_client, bucket_name, blob_name)
        print(f"{file_name}已从GCS中删除")
    return gr.update(value="", interactive=False)

def update_LLM_content(video_id, new_content, kind):
    print(f"===upfdate kind on gcs===")
    gcs_client = GCS_CLIENT
    bucket_name = 'video_ai_assistant'
    file_name = f'{video_id}_{kind}.json'
    blob_name = f"{video_id}/{file_name}"

    if kind == "reading_passage":
        reading_passage_json = {"reading_passage": str(new_content)}
        reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
        updated_content = reading_passage_text
    elif kind == "summary":
        summary_json = {"summary": str(new_content)}
        summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, summary_text)
        updated_content = summary_text
    elif kind == "mind_map":
        mind_map_json = {"mind_map": str(new_content)}
        mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, mind_map_text)
        updated_content = mind_map_text
    elif kind == "key_moments":
        # from update_LLM_btn  -> new_content is a string
        # create_LLM_content -> new_content is a list
        if isinstance(new_content, str):
            key_moments_list = json.loads(new_content)
        else:
            key_moments_list = new_content
        key_moments_json = {"key_moments": key_moments_list}
        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
        updated_content = key_moments_text
    elif kind == "transcript":
        if isinstance(new_content, str):
            transcript_json = json.loads(new_content)
        else:
            transcript_json = new_content
        transcript_text = json.dumps(transcript_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, transcript_text)
        updated_content = transcript_text
    elif kind == "questions":
        # from update_LLM_btn  -> new_content is a string
        # create_LLM_content -> new_content is a list
        if isinstance(new_content, str):
            questions_json = json.loads(new_content)
        else:
            questions_json = new_content
        questions_text = json.dumps(questions_json, ensure_ascii=False, indent=2)
        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_text)
        updated_content = questions_text

    print(f"{kind} 已更新到GCS")
    return gr.update(value=updated_content, interactive=False)

def create_LLM_content(video_id, df_string, kind):
    print(f"===create_{kind}===")
    print(f"video_id: {video_id}")

    if kind == "reading_passage":
        content = generate_reading_passage(df_string)
        update_LLM_content(video_id, content, kind)
    elif kind == "summary":
        content = generate_summarise(df_string)
        update_LLM_content(video_id, content, kind)
    elif kind == "mind_map":
        content = generate_mind_map(df_string)
        update_LLM_content(video_id, content, kind)
    elif kind == "key_moments":
        if isinstance(df_string, str):
            transcript = json.loads(df_string)
        else:
            transcript = df_string
        formatted_simple_transcript = create_formatted_simple_transcript(transcript)
        formatted_transcript = create_formatted_transcript(video_id, transcript)
        content = generate_key_moments(formatted_simple_transcript, formatted_transcript)
        update_LLM_content(video_id, content, kind)
        content = json.dumps(content, ensure_ascii=False, indent=2)
    elif kind == "transcript":
        content = process_transcript_and_screenshots_on_gcs(video_id)
        update_LLM_content(video_id, content, kind)
        content = json.dumps(content, ensure_ascii=False, indent=2)
    elif kind == "questions":
        content = generate_questions(df_string)
        update_LLM_content(video_id, content, kind)
        content = json.dumps(content, ensure_ascii=False, indent=2)

    return gr.update(value=content, interactive=False)


# AI 生成教學素材
def get_meta_data(video_id, source="gcs"):
    if source == "gcs":
        print("===get_meta_data on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_meta_data.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查檔案是否存在
        is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_file_exists:
            meta_data_json = {
                "subject": "",
                "grade": "",
            }
            print("meta_data empty return")
        else:
            # meta_data已存在，下载内容
            print("meta_data已存在于GCS中")
            meta_data_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
            meta_data_json = json.loads(meta_data_text)

    # meta_data_json grade 數字轉換成文字
    grade = meta_data_json["grade"]
    case = {
        1: "一年級",
        2: "二年級",
        3: "三年級",
        4: "四年級",
        5: "五年級",
        6: "六年級",
        7: "七年級",
        8: "八年級",
        9: "九年級",
        10: "十年級",
        11: "十一年級",
        12: "十二年級",
    }
    grade_text = case.get(grade, "")
    meta_data_json["grade"] = grade_text

    return meta_data_json

def get_ai_content(password, video_id, df_string, topic, grade, level, specific_feature, content_type, source="gcs"):
    verify_password(password)
    if source == "gcs":
        print("===get_ai_content on gcs===")
        gcs_client = GCS_CLIENT
        bucket_name = 'video_ai_assistant'
        file_name = f'{video_id}_ai_content_list.json'
        blob_name = f"{video_id}/{file_name}"
        # 检查檔案是否存在
        is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
        if not is_file_exists: 
            # 先建立一個 ai_content_list.json
            ai_content_list = []
            ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, ai_content_text)
            print("ai_content_list [] 已上傳到GCS")

        # 此時 ai_content_list 已存在
        ai_content_list_string = download_blob_to_string(gcs_client, bucket_name, blob_name)
        ai_content_list = json.loads(ai_content_list_string)
        # by key 找到 ai_content （topic, grade, level, specific_feature, content_type）
        target_kvs = {
            "video_id": video_id,
            "level": level,
            "specific_feature": specific_feature,
            "content_type": content_type
        }
        ai_content_json = [
            item for item in ai_content_list
            if all(item[k] == v for k, v in target_kvs.items())
        ]         
            
        if len(ai_content_json) == 0:
            ai_content, prompt = generate_ai_content(password, df_string, topic, grade, level, specific_feature, content_type)
            ai_content_json = {
                "video_id": video_id,
                "content": str(ai_content),
                "prompt": prompt,
                "level": level,
                "specific_feature": specific_feature,
                "content_type": content_type
            }

            ai_content_list.append(ai_content_json)
            ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, ai_content_text)
            print("ai_content已上傳到GCS")
        else:
            ai_content_json = ai_content_json[-1]
            ai_content = ai_content_json["content"]
            prompt = ai_content_json["prompt"]

    return ai_content, ai_content, prompt, prompt

def generate_ai_content(password, df_string, topic, grade, level, specific_feature, content_type):
    verify_password(password)
    material = EducationalMaterial(df_string, topic, grade, level, specific_feature, content_type)
    prompt = material.generate_content_prompt()
    user_content = material.build_user_content()
    messages = material.build_messages(user_content)
    ai_model_name = "gpt-4-1106-preview"
    request_payload = {
        "model": ai_model_name,
        "messages": messages,
        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
    }
    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
    return ai_content, prompt

def generate_exam_fine_tune_result(password, exam_result_prompt , df_string_output, exam_result, exam_result_fine_tune_prompt):
    verify_password(password)
    material = EducationalMaterial(df_string_output, "", "", "", "", "")
    user_content = material.build_fine_tune_user_content(exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
    messages = material.build_messages(user_content)
    ai_model_name = "gpt-4-1106-preview"
    request_payload = {
        "model": ai_model_name,
        "messages": messages,
        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
    }
    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
    return ai_content

def return_original_exam_result(exam_result_original):
    return exam_result_original

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_exam_result(content):
    word_path = create_word(content)
    return word_path

# ---- Chatbot ----
def get_instructions(content_subject, content_grade, key_moments):
    instructions = f"""
        subject: {content_subject}
        grade: {content_grade}
        context: {key_moments}
        Assistant Role: you are a {content_subject} teacher
        User Role: {content_grade} th-grade student.
        Method: Socratic style, guide thinking, no direct answers. this is very important, please be seriously following.
        Language: Traditional Chinese ZH-TW (it's very important), suitable for {content_grade} th-grade level.
        Response: 
        - Single question, under 100 characters
        - include math symbols (use LaTeX $ to cover before and after)
        - hint with video timestamp which format 【參考：00:00:00】. 
        - Sometimes encourage user by Taiwanese style with relaxing atmosphere.
        - if user ask questions not include in context, 
        - just tell them to ask the question in context and give them example question.
        Restrictions: Answer within video content, no external references
    """
    return instructions

def chat_with_ai(ai_name, password, video_id, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
    verify_password(password)

    if chat_history is not None and len(chat_history) > 10:
        error_msg = "此次對話超過上限"
        raise gr.Error(error_msg)

    if ai_name == "jutor":
        ai_client = ""
    elif ai_name == "claude3":
        ai_client = BEDROCK_CLIENT
    elif ai_name == "groq":
        ai_client = GROQ_CLIENT
    if isinstance(trascript_state, str):
        simple_transcript = json.loads(trascript_state)
    else:
        simple_transcript = trascript_state
  
    if isinstance(key_moments, str):
        key_moments_json = json.loads(key_moments)
    else:
        key_moments_json = key_moments
    # key_moments_json remove images
    for moment in key_moments_json:
        moment.pop('images', None)
        moment.pop('end', None)
        moment.pop('text', None)
    key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

    instructions = get_instructions(content_subject, content_grade, key_moments_text)

    chatbot_config = {
        "video_id": video_id,
        "transcript": simple_transcript,
        "key_moments": key_moments,
        "content_subject": content_subject,
        "content_grade": content_grade,
        "jutor_chat_key": JUTOR_CHAT_KEY,
        "ai_name": ai_name,
        "ai_client": ai_client,
        "instructions": instructions
    }

    try:
        chatbot = Chatbot(chatbot_config)
        response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
    except Exception as e:
        print(f"Error: {e}")
        response_completion = "學習精靈有點累，請稍後再試！"

    try:
        # 更新聊天历史
        new_chat_history = (user_message, response_completion)
        if chat_history is None:
            chat_history = [new_chat_history]
        else:
            chat_history.append(new_chat_history)

        # 返回聊天历史和空字符串清空输入框
        return "", chat_history
    except Exception as e:
        # 处理错误情况
        print(f"Error: {e}")
        return "请求失败，请稍后再试！", chat_history

def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
    verify_password(password)

    # 先計算 user_message 是否超過 500 個字
    if len(user_message) > 1500:
        error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
        raise gr.Error(error_msg)
    
    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
    if chat_history is not None and len(chat_history) > 10:
        error_msg = "此次對話超過上限"
        raise gr.Error(error_msg)

    try:
        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq" #GPT 4 turbo
        # assistant_id = "asst_5SaUElqvL3U0ybSi9PRM8x3P" #GPT 3.5 turbo

        client = OPEN_AI_CLIENT
        # 直接安排逐字稿資料 in instructions
        if isinstance(trascript_state, str):
            trascript_json = json.loads(trascript_state)
        else:
            trascript_json = trascript_state
        # 移除 embed_url, screenshot_path
        for entry in trascript_json:
            entry.pop('end_time', None)
        trascript_text = json.dumps(trascript_json, ensure_ascii=False)

        if isinstance(key_moments, str):
            key_moments_json = json.loads(key_moments)
        else:
            key_moments_json = key_moments
        # key_moments_json remove images
        for moment in key_moments_json:
            moment.pop('images', None)
            moment.pop('end', None)
            moment.pop('text', None)
        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
        
        instructions = get_instructions(content_subject, content_grade, key_moments_text)
        print("=== instructions ===")
        print(instructions)

        # 创建线程
        if not thread_id:
            thread = client.beta.threads.create()
            thread_id = thread.id
        else:
            thread = client.beta.threads.retrieve(thread_id)
        
        user_msg_note = """\n (請一定要用繁體中文回答 zh-TW，
            請嚴格遵循instructions，擔任一位蘇格拉底家教，
            並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，
            不用提到「逐字稿」這個詞，用「內容」代替)，
            回答時請用數學符號代替文字（Latex 用 $ 字號 render)
        """
        user_msg_note = user_msg_note.replace(" ","").replace("\n","")
        # 向线程添加用户的消息
        client.beta.threads.messages.create(
            thread_id=thread.id,
            role="user",
            content=user_message + user_msg_note
        )

        # 运行助手，生成响应
        run = client.beta.threads.runs.create(
            thread_id=thread.id,
            assistant_id=assistant_id,
            instructions=instructions,
        )

        # 等待助手响应，设定最大等待时间为 30 秒
        run_status = poll_run_status(run.id, thread.id, timeout=30)
        # 获取助手的响应消息
        if run_status == "completed":
            messages = client.beta.threads.messages.list(thread_id=thread.id)
            # [MessageContentText(text=Text(annotations=[], value='您好！有什麼我可以幫助您的嗎？如果有任何問題或需要指導，請隨時告訴我！'), type='text')]
            response_text = messages.data[0].content[0].text.value
        else:
            response_text = "學習精靈有點累，請稍後再試！"

        # 更新聊天历史
        new_chat_history = (user_message, response_text)
        if chat_history is None:
            chat_history = [new_chat_history]
        else:
            chat_history.append(new_chat_history)
    except Exception as e:
        print(f"Error: {e}")
        raise gr.Error(f"Error: {e}")

    # 返回聊天历史和空字符串清空输入框
    return "", chat_history, thread.id

def process_open_ai_audio_to_chatbot(password, audio_url):
    verify_password(password)
    if audio_url:
        with open(audio_url, "rb") as audio_file:
            file_size = os.path.getsize(audio_url)
            if file_size > 2000000:
                raise gr.Error("檔案大小超過，請不要超過 60秒")
            else:
                response = OPEN_AI_CLIENT.audio.transcriptions.create(
                    model="whisper-1",
                    file=audio_file,
                    response_format="text"
                )   
                # response 拆解 dict
                print("=== response ===")
                print(response)
                print("=== response ===")
    else:
        response = ""

    return response

def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
    """
    Polls the status of a Run and handles different statuses appropriately.

    :param run_id: The ID of the Run to poll.
    :param thread_id: The ID of the Thread associated with the Run.
    :param timeout: Maximum time to wait for the Run to complete, in seconds.
    :param poll_interval: Time to wait between each poll, in seconds.
    """
    client = OPEN_AI_CLIENT
    start_time = time.time()
    while time.time() - start_time < timeout:
        run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)

        if run.status in ["completed", "cancelled", "failed"]:
            print(f"Run completed with status: {run.status}")
            break
        elif run.status == "requires_action":
            print("Run requires action. Performing required action...")
            # Here, you would perform the required action, e.g., running functions
            # and then submitting the outputs. This is simplified for this example.
            # After performing the required action, you'd complete the action:
            # OPEN_AI_CLIENT.beta.threads.runs.complete_required_action(...)
        elif run.status == "expired":
            print("Run expired. Exiting...")
            break
        else:
            print(f"Run status is {run.status}. Waiting for updates...")
        
        time.sleep(poll_interval)
    else:
        print("Timeout reached. Run did not complete in the expected time.")

    # Once the Run is completed, handle the result accordingly
    if run.status == "completed":
        # Retrieve and handle messages or run steps as needed
        messages = client.beta.threads.messages.list(thread_id=thread_id)
        for message in messages.data:
            if message.role == "assistant":
                print(f"Assistant response: {message.content}")
    elif run.status in ["cancelled", "failed"]:
        # Handle cancellation or failure
        print(f"Run ended with status: {run.status}")
    elif run.status == "expired":
        # Handle expired run
        print("Run expired without completion.")
    
    return run.status

def streaming_chat_with_open_ai(user_message, chat_history, password, thread_id, trascript, key_moments, content_subject, content_grade):
    verify_password(password)

    print("===streaming_chat_with_open_ai===")
    print(thread_id)
    
    # 先計算 user_message 是否超過 500 個字
    if len(user_message) > 1500:
        error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
        raise gr.Error(error_msg)
    
    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
    if chat_history is not None and len(chat_history) > 10:
        error_msg = "此次對話超過上限"
        raise gr.Error(error_msg)

    try:
        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq" #GPT 4 turbo
        # assistant_id = "asst_5SaUElqvL3U0ybSi9PRM8x3P" #GPT 3.5 turbo
        client = OPEN_AI_CLIENT
        # 直接安排逐字稿資料 in instructions
        if isinstance(trascript, str):
            trascript_json = json.loads(trascript)
        else:
            trascript_json = trascript
        trascript_text = json.dumps(trascript_json, ensure_ascii=False)
        # trascript_text 移除 \n, 空白
        trascript_text = trascript_text.replace("\n", "").replace(" ", "")

        if isinstance(key_moments, str):
            key_moments_json = json.loads(key_moments)
        else:
            key_moments_json = key_moments
        # key_moments_json remove images
        for moment in key_moments_json:
            moment.pop('images', None)
        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)

        instructions = get_instructions(content_subject, content_grade, key_moments_text)
        # 创建线程
        if not thread_id:
            thread = client.beta.threads.create()
            thread_id = thread.id
            print(f"new thread_id: {thread_id}")
        else:
            thread = client.beta.threads.retrieve(thread_id)
            print(f"old thread_id: {thread_id}")
        
        # 向线程添加用户的消息
        client.beta.threads.messages.create(
            thread_id=thread.id,
            role="user",
            content=user_message + "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替))，請在回答的最後標註【參考資料：（時）:（分）:（秒）】，（如果是反問學生，就只問一個問題，請幫助學生更好的理解資料，字數在100字以內）"
        )

        with client.beta.threads.runs.stream(
            thread_id=thread.id,
            assistant_id=assistant_id,
            instructions=instructions,
        ) as stream:
            partial_messages = ""
            for event in stream:
                if event.data and event.data.object == "thread.message.delta":
                    message = event.data.delta.content[0].text.value
                    partial_messages += message
                    yield partial_messages

    except Exception as e:
        print(f"Error: {e}")
        raise gr.Error(f"Error: {e}")

def create_thread_id():
    thread = OPEN_AI_CLIENT.beta.threads.create()
    thread_id = thread.id
    print(f"create new thread_id: {thread_id}")
    return thread_id

# --- Slide mode ---
def update_slide(direction):
    global TRANSCRIPTS
    global CURRENT_INDEX

    print("=== 更新投影片 ===")
    print(f"CURRENT_INDEX: {CURRENT_INDEX}")
    # print(f"TRANSCRIPTS: {TRANSCRIPTS}")

    CURRENT_INDEX += direction
    if CURRENT_INDEX < 0:
        CURRENT_INDEX = 0  # 防止索引小于0
    elif CURRENT_INDEX >= len(TRANSCRIPTS):
        CURRENT_INDEX = len(TRANSCRIPTS) - 1  # 防止索引超出范围
    
    # 获取当前条目的文本和截图 URL
    current_transcript = TRANSCRIPTS[CURRENT_INDEX]
    slide_image = current_transcript["screenshot_path"]
    slide_text = current_transcript["text"]
    
    return slide_image, slide_text

def prev_slide():
    return update_slide(-1)

def next_slide():
    return update_slide(1)


# --- Init params ---
def init_params(text, 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)

        youtube_link = ""
        password_text = ""
        admin = gr.update(visible=True)
        reading_passage_admin = gr.update(visible=True)
        summary_admin = gr.update(visible=True)
        see_detail = gr.update(visible=True)

        # if youtube_link in query_params
        if "youtube_id" in request.query_params:
            youtube_id = request.query_params["youtube_id"]
            youtube_link = f"https://www.youtube.com/watch?v={youtube_id}"
            print(f"youtube_link: {youtube_link}")

        # check if origin is from junyiacademy
        origin = request.headers.get("origin", "")
        if "junyiacademy" in origin:
            password_text = "6161"
            admin = gr.update(visible=False)
            reading_passage_admin = gr.update(visible=False)
            summary_admin = gr.update(visible=False)
            see_detail = gr.update(visible=False)

    return admin, reading_passage_admin, summary_admin, see_detail, password_text, youtube_link

def update_state(content_subject, content_grade, trascript, key_moments, question_1, question_2, question_3):
    # inputs=[content_subject, content_grade, df_string_output],
    # outputs=[content_subject_state, content_grade_state, trascript_state]
    content_subject_state = content_subject
    content_grade_state = content_grade
    trascript_json = json.loads(trascript)
    formatted_simple_transcript = create_formatted_simple_transcript(trascript_json)
    trascript_state = formatted_simple_transcript
    key_moments_state = key_moments
    streaming_chat_thread_id_state = create_thread_id()
    ai_chatbot_question_1 = question_1
    ai_chatbot_question_2 = question_2
    ai_chatbot_question_3 = question_3

    return content_subject_state, content_grade_state, trascript_state, key_moments_state, \
        streaming_chat_thread_id_state, \
        ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3


HEAD = """
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
    svg.markmap {{
        width: 100%;
        height: 100vh;
    }}
    </style>
    <script src="https://cdn.jsdelivr.net/npm/markmap-autoloader@0.15.2"></script>

    <script>
        const mind_map_tab_button = document.querySelector("#mind_map_tab-button");
        
        if (mind_map_tab_button) {
            mind_map_tab_button.addEventListener('click', function() {
                const mind_map_markdown = document.querySelector("#mind_map_markdown > label > textarea");
                if (mind_map_markdown) {
                // 当按钮被点击时，打印当前的textarea的值
                console.log('Value changed to: ' + mind_map_markdown.value);
                markmap.autoLoader.renderAll();
                }
            });
        }
    </script>

    <script>
        function changeImage(direction, count, galleryIndex) {
            // Find the current visible image by iterating over possible indices
            var currentImage = null;
            var currentIndex = -1;
            for (var i = 0; i < count; i++) {
                var img = document.querySelector('.slide-image-' + galleryIndex + '-' + i);
                if (img && img.style.display !== 'none') {
                    currentImage = img;
                    currentIndex = i;
                    break;
                }
            }

            // If no current image is visible, show the first one and return
            if (currentImage === null) {
                document.querySelector('.slide-image-' + galleryIndex + '-0').style.display = 'block';
                console.error('No current image found for galleryIndex ' + galleryIndex + ', defaulting to first image.');
                return;
            }

            // Hide the current image
            currentImage.style.display = 'none';

            // Calculate the index of the next image to show
            var newIndex = (currentIndex + direction + count) % count;

            // Select the next image and show it
            var nextImage = document.querySelector('.slide-image-' + galleryIndex + '-' + newIndex);
            if (nextImage) {
                nextImage.style.display = 'block';
            } else {
                console.error('No image found for galleryIndex ' + galleryIndex + ' and newIndex ' + newIndex);
            }
        }
    </script>
"""

with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, secondary_hue=gr.themes.colors.amber, text_size = gr.themes.sizes.text_lg), head=HEAD) as demo:
    with gr.Row() as admin:
        password = gr.Textbox(label="Password", type="password", elem_id="password_input", visible=True)
        youtube_link = gr.Textbox(label="Enter YouTube Link", elem_id="youtube_link_input", visible=True)
        video_id = gr.Textbox(label="video_id", visible=True)
        # file_upload = gr.File(label="Upload your CSV or Word file", visible=False)
        # web_link = gr.Textbox(label="Enter Web Page Link", visible=False)
        user_data = gr.Textbox(label="User Data", elem_id="user_data_input", visible=True)
        youtube_link_btn = gr.Button("Submit_YouTube_Link", elem_id="youtube_link_btn", visible=True)
    with gr.Row() as data_state:
        content_subject_state = gr.State()  # 使用 gr.State 存储 content_subject
        content_grade_state = gr.State()  # 使用 gr.State 存储 content_grade
        trascript_state = gr.State()  # 使用 gr.State 存储 trascript
        key_moments_state = gr.State()  # 使用 gr.State 存储 key_moments
        streaming_chat_thread_id_state = gr.State()  # 使用 gr.State 存储 streaming_chat_thread_id
    with gr.Tab("AI小精靈"):
        with gr.Row():
            with gr.Tab("飛特精靈"):
                bot_avatar = "https://junyi-avatar.s3.ap-northeast-1.amazonaws.com/live/%20%20foxcat-star-18.png?v=20231113095823614"
                user_avatar = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
                latex_delimiters = [{"left": "$", "right": "$", "display": False}]
                chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="OPEN AI", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters)
                thread_id = gr.Textbox(label="thread_id", visible=False)
                socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=False)
                with gr.Row():
                    with gr.Accordion("你也有類似的問題想問嗎？", open=False) as ask_questions_accordion:
                        btn_1 = gr.Button("問題一")
                        btn_2 = gr.Button("問題一")
                        btn_3 = gr.Button("問題一")
                        gr.Markdown("### 重新生成問題")
                        btn_create_question = gr.Button("生成其他問題", variant="primary")
                    openai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60)
                with gr.Row():
                    msg = gr.Textbox(label="訊息",scale=3)
                    send_button = gr.Button("送出", variant="primary", scale=1)
            with gr.Tab("飛特音速"):
                additional_inputs = [password, streaming_chat_thread_id_state, trascript_state, key_moments_state, content_subject_state, content_grade_state]
                streaming_chat = gr.ChatInterface(
                    fn=streaming_chat_with_open_ai,
                    additional_inputs=additional_inputs,
                    submit_btn="送出",
                    retry_btn=None,
                    undo_btn="⏪ 上一步",
                    clear_btn="🗑️ 清除全部",
                    stop_btn="🛑 停止",
                )
            with gr.Tab("其他精靈"):
                ai_name = gr.Dropdown(label="選擇 AI 助理", choices=["jutor", "claude3", "groq"], value="jutor")
                ai_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="ai_chatbot", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters)
                ai_chatbot_socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=False)
                with gr.Row():
                    with gr.Accordion("你也有類似的問題想問嗎？", open=False) as ask_questions_accordion_2:
                        ai_chatbot_question_1 = gr.Button("問題一")
                        ai_chatbot_question_2 = gr.Button("問題一")
                        ai_chatbot_question_3 = gr.Button("問題一")
                    ai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60)
                with gr.Row():
                    ai_msg = gr.Textbox(label="訊息輸入",scale=3)
                    ai_send_button = gr.Button("送出", variant="primary",scale=1)              
    with gr.Tab("文章模式"):
        with gr.Row() as reading_passage_admin:
            reading_passage_kind = gr.Textbox(value="reading_passage", show_label=False)
            reading_passage_edit_button = gr.Button("編輯", size="sm", variant="primary")
            reading_passage_update_button = gr.Button("更新", size="sm", variant="primary")
            reading_passage_delete_button = gr.Button("刪除", size="sm", variant="primary")
            reading_passage_create_button = gr.Button("建立", size="sm", variant="primary")
        with gr.Row():
            reading_passage = gr.Textbox(label="Reading Passage", lines=40, show_label=False)
            reading_passage_speak_button = gr.Button("Speak", visible=False)
            reading_passage_audio_output = gr.Audio(label="Audio Output", visible=False) 
    with gr.Tab("重點摘要"):
        with gr.Row() as summary_admmin:
            summary_kind = gr.Textbox(value="summary", show_label=False)
            summary_edit_button = gr.Button("編輯", size="sm", variant="primary")
            summary_update_button = gr.Button("更新", size="sm", variant="primary")
            summary_delete_button = gr.Button("刪除", size="sm", variant="primary")
            summary_create_button = gr.Button("建立", size="sm", variant="primary")
        with gr.Row():
            df_summarise = gr.Textbox(container=True, show_copy_button=True, lines=40, show_label=False)
    with gr.Tab("關鍵時刻"):
        with gr.Row():
            key_moments_html = gr.HTML(value="")
    with gr.Tab("教學備課"):
        with gr.Row():
            content_subject = gr.Dropdown(label="選擇主題", choices=["數學", "自然", "國文", "英文", "社會","物理", "化學", "生物", "地理", "歷史", "公民"], value="", visible=False)             
            content_grade = gr.Dropdown(label="選擇年級", choices=["一年級", "二年級", "三年級", "四年級", "五年級", "六年級", "七年級", "八年級", "九年級", "十年級", "十一年級", "十二年級"], value="", visible=False)
            content_level = gr.Dropdown(label="差異化教學", choices=["基礎", "中級", "進階"], value="基礎")
        with gr.Row():
            with gr.Tab("學習單"):
                with gr.Row():
                    with gr.Column(scale=1):
                        with gr.Row():
                            worksheet_content_type_name = gr.Textbox(value="worksheet", visible=False)
                            worksheet_algorithm = gr.Dropdown(label="選擇教學策略或理論", choices=["Bloom認知階層理論", "Polya數學解題法", "CRA教學法"], value="Bloom認知階層理論", visible=False)
                            worksheet_content_btn = gr.Button("生成學習單 📄", variant="primary")
                        with gr.Accordion("微調", open=False):
                            worksheet_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                            worksheet_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
                            worksheet_exam_result_retrun_original = gr.Button("返回原始結果")
                        with gr.Accordion("prompt", open=False):
                            worksheet_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
                    with gr.Column(scale=2):
                        # 生成對應不同模式的結果
                        worksheet_exam_result_prompt = gr.Textbox(visible=False)
                        worksheet_exam_result_original = gr.Textbox(visible=False)
                        worksheet_exam_result = gr.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
                        worksheet_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
                        worksheet_exam_result_word_link = gr.File(label="Download Word")

            with gr.Tab("課程計畫"):
                with gr.Row():
                    with gr.Column(scale=1):
                        with gr.Row():
                            lesson_plan_content_type_name = gr.Textbox(value="lesson_plan", visible=False)                    
                            lesson_plan_time = gr.Slider(label="選擇課程時間(分鐘)", minimum=10, maximum=120, step=5, value=40)
                            lesson_plan_btn = gr.Button("生成課程計畫 📕", variant="primary")
                        with gr.Accordion("微調", open=False):
                            lesson_plan_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                            lesson_plan_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
                            lesson_plan_exam_result_retrun_original = gr.Button("返回原始結果")
                        with gr.Accordion("prompt", open=False):
                            lesson_plan_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
                    with gr.Column(scale=2):
                        # 生成對應不同模式的結果
                        lesson_plan_exam_result_prompt = gr.Textbox(visible=False)
                        lesson_plan_exam_result_original = gr.Textbox(visible=False)
                        lesson_plan_exam_result = gr.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
                        
                        lesson_plan_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
                        lesson_plan_exam_result_word_link = gr.File(label="Download Word")
            
            with gr.Tab("出場券"):
                with gr.Row():
                    with gr.Column(scale=1):
                        with gr.Row():
                            exit_ticket_content_type_name = gr.Textbox(value="exit_ticket", visible=False)
                            exit_ticket_time = gr.Slider(label="選擇出場券時間(分鐘)", minimum=5, maximum=10, step=1, value=8)
                            exit_ticket_btn = gr.Button("生成出場券 🎟️", variant="primary")
                        with gr.Accordion("微調", open=False):
                            exit_ticket_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                            exit_ticket_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
                            exit_ticket_exam_result_retrun_original = gr.Button("返回原始結果")
                        with gr.Accordion("prompt", open=False):
                            exit_ticket_prompt = gr.Textbox(label="worksheet_prompt", show_copy_button=True, lines=40)
                    with gr.Column(scale=2):
                        # 生成對應不同模式的結果
                        exit_ticket_exam_result_prompt = gr.Textbox(visible=False)
                        exit_ticket_exam_result_original = gr.Textbox(visible=False)
                        exit_ticket_exam_result = gr.Textbox(label="初次生成結果", show_copy_button=True, interactive=True, lines=40)
                        
                        exit_ticket_download_exam_result_button = gr.Button("轉成 word，完成後請點擊右下角 download 按鈕", variant="primary")
                        exit_ticket_exam_result_word_link = gr.File(label="Download Word")


                # with gr.Tab("素養導向閱讀題組"):
                #     literacy_oriented_reading_content = gr.Textbox(label="輸入閱讀材料")
                #     literacy_oriented_reading_content_btn = gr.Button("生成閱讀理解題")

                # with gr.Tab("自我評估"):
                #     self_assessment_content = gr.Textbox(label="輸入自評問卷或檢查表")
                #     self_assessment_content_btn = gr.Button("生成自評問卷")
                # with gr.Tab("自我反思評量"):
                #     self_reflection_content = gr.Textbox(label="輸入自我反思活動")
                #     self_reflection_content_btn = gr.Button("生成自我反思活動")
                # with gr.Tab("後設認知"):
                #     metacognition_content = gr.Textbox(label="輸入後設認知相關問題")
                #     metacognition_content_btn = gr.Button("生成後設認知問題")

    with gr.Accordion("See Details", open=False) as see_details:
        with gr.Tab("逐字稿本文"):
            with gr.Row() as transcript_admmin:
                transcript_kind = gr.Textbox(value="transcript", show_label=False)
                transcript_edit_button = gr.Button("編輯", size="sm", variant="primary")
                transcript_update_button = gr.Button("更新", size="sm", variant="primary")
                transcript_delete_button = gr.Button("刪除", size="sm", variant="primary")
                transcript_create_button = gr.Button("建立", size="sm", variant="primary")
            with gr.Row():
                df_string_output = gr.Textbox(lines=40, label="Data Text", interactive=False, show_copy_button=True)
        with gr.Tab("關鍵時刻本文"):
            with gr.Row() as key_moments_admin:
                key_moments_kind = gr.Textbox(value="key_moments", show_label=False)
                key_moments_edit_button = gr.Button("編輯", size="sm", variant="primary")
                key_moments_update_button = gr.Button("更新", size="sm", variant="primary")
                key_moments_delete_button = gr.Button("刪除", size="sm", variant="primary")
                key_moments_create_button = gr.Button("建立", size="sm", variant="primary")
            with gr.Row():
                key_moments = gr.Textbox(label="Key Moments", lines=40, interactive=False, show_copy_button=True)
        with gr.Tab("問題本文"):
            with gr.Row() as question_list_admin:
                questions_kind = gr.Textbox(value="questions", show_label=False)
                questions_edit_button = gr.Button("編輯", size="sm", variant="primary")
                questions_update_button = gr.Button("更新", size="sm", variant="primary")
                questions_delete_button = gr.Button("刪除", size="sm", variant="primary")
                questions_create_button = gr.Button("建立", size="sm", variant="primary")
            with gr.Row():
                questions_json = gr.Textbox(label="Questions", lines=40, interactive=False, show_copy_button=True)
        with gr.Tab("逐字稿"):
            simple_html_content = gr.HTML(label="Simple Transcript")
        with gr.Tab("圖文"):
            transcript_html = gr.HTML(label="YouTube Transcript and Video") 
        with gr.Tab("投影片"):
            slide_image = gr.Image()
            slide_text = gr.Textbox()
            with gr.Row():
                prev_button = gr.Button("Previous")
                next_button = gr.Button("Next")
            prev_button.click(fn=prev_slide, inputs=[], outputs=[slide_image, slide_text])
            next_button.click(fn=next_slide, inputs=[], outputs=[slide_image, slide_text])  
        with gr.Tab("markdown"):
            gr.Markdown("## 請複製以下 markdown 並貼到你的心智圖工具中，建議使用：https://markmap.js.org/repl")
            mind_map = gr.Textbox(container=True, show_copy_button=True, lines=40, elem_id="mind_map_markdown") 
        with gr.Tab("心智圖",elem_id="mind_map_tab"):
            mind_map_html = gr.HTML()
       
    # --- Event ---
    # OPENAI ASSISTANT CHATBOT 模式
    send_button.click(
        chat_with_opan_ai_assistant,
        inputs=[password, video_id, thread_id, trascript_state, key_moments, msg, chatbot, content_subject, content_grade, socratic_mode_btn],
        outputs=[msg, chatbot, thread_id]
    )
    openai_chatbot_audio_input.change(
        process_open_ai_audio_to_chatbot,
        inputs=[password, openai_chatbot_audio_input],
        outputs=[msg]
    )
    # OPENAI ASSISTANT CHATBOT 連接按鈕點擊事件
    btn_1_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_1, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    btn_2_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_2, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    btn_3_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_3, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    btn_1.click(
        chat_with_opan_ai_assistant,
        inputs=btn_1_chat_with_opan_ai_assistant_input, 
        outputs=[msg, chatbot, thread_id]
    )
    btn_2.click(
        chat_with_opan_ai_assistant,
        inputs=btn_2_chat_with_opan_ai_assistant_input, 
        outputs=[msg, chatbot, thread_id]
    )
    btn_3.click(
        chat_with_opan_ai_assistant,
        inputs=btn_3_chat_with_opan_ai_assistant_input, 
        outputs=[msg, chatbot, thread_id]
    )
    btn_create_question.click(
        change_questions, 
        inputs = [password, df_string_output], 
        outputs = [btn_1, btn_2, btn_3]
    )

    # ai_chatbot 模式
    ai_send_button.click(
        chat_with_ai,
        inputs=[ai_name, password, video_id, trascript_state, key_moments, ai_msg, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn],
        outputs=[ai_msg, ai_chatbot]
    )
    # ai_chatbot 连接按钮点击事件
    ai_chatbot_question_1_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_1, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    ai_chatbot_question_2_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_2, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    ai_chatbot_question_3_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_3, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
    ai_chatbot_question_1.click(
        chat_with_ai,
        inputs=ai_chatbot_question_1_chat_with_ai_input,
        outputs=[ai_msg, ai_chatbot]
    )
    ai_chatbot_question_2.click(
        chat_with_ai,
        inputs=ai_chatbot_question_2_chat_with_ai_input,
        outputs=[ai_msg, ai_chatbot]
    )
    ai_chatbot_question_3.click(
        chat_with_ai,
        inputs=ai_chatbot_question_3_chat_with_ai_input,
        outputs=[ai_msg, ai_chatbot]
    )

    # file_upload.change(process_file, inputs=file_upload, outputs=df_string_output)
    # file_upload.change(process_file, inputs=file_upload, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])

    # 当输入 YouTube 链接时触发
    process_youtube_link_inputs = [password, youtube_link]
    process_youtube_link_outputs = [
        video_id,
        questions_json,
        btn_1, 
        btn_2, 
        btn_3, 
        df_string_output, 
        df_summarise,
        key_moments,
        key_moments_html,
        mind_map, 
        mind_map_html,
        transcript_html,
        simple_html_content, 
        slide_image, 
        slide_text,
        reading_passage,
        content_subject,
        content_grade,
    ]
    update_state_inputs = [
        content_subject,
        content_grade,
        df_string_output,
        key_moments,
        btn_1, 
        btn_2, 
        btn_3
    ]
    update_state_outputs = [
        content_subject_state, 
        content_grade_state, 
        trascript_state,
        key_moments_state,
        streaming_chat_thread_id_state,
        ai_chatbot_question_1,
        ai_chatbot_question_2,
        ai_chatbot_question_3
    ]

    youtube_link.change(
        process_youtube_link, 
        inputs=process_youtube_link_inputs, 
        outputs=process_youtube_link_outputs
    ).then(
        update_state,
        inputs=update_state_inputs,
        outputs=update_state_outputs
    )

    youtube_link_btn.click(
        process_youtube_link, 
        inputs=process_youtube_link_inputs, 
        outputs=process_youtube_link_outputs
    ).then(
        update_state,
        inputs=update_state_inputs,
        outputs=update_state_outputs
    )
    

    # 当输入网页链接时触发
    # web_link.change(process_web_link, inputs=web_link, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])

    # reading_passage event
    reading_passage_create_button.click(
        create_LLM_content,
        inputs=[video_id, df_string_output, reading_passage_kind],
        outputs=[reading_passage]
    )
    reading_passage_delete_button.click(
        delete_LLM_content,
        inputs=[video_id, reading_passage_kind],
        outputs=[reading_passage]
    )
    reading_passage_edit_button.click(
        enable_edit_mode,
        inputs=[],
        outputs=[reading_passage]
    )
    reading_passage_update_button.click(
        update_LLM_content,
        inputs=[video_id, reading_passage, reading_passage_kind],
        outputs=[reading_passage]
    )

    # summary event
    summary_create_button.click(
        create_LLM_content,
        inputs=[video_id, df_string_output, summary_kind],
        outputs=[df_summarise]
    )
    summary_delete_button.click(
        delete_LLM_content,
        inputs=[video_id, summary_kind],
        outputs=[df_summarise]
    )
    summary_edit_button.click(
        enable_edit_mode,
        inputs=[],
        outputs=[df_summarise]
    )
    summary_update_button.click(
        update_LLM_content,
        inputs=[video_id, df_summarise, summary_kind],
        outputs=[df_summarise]
    )

    # transcript event
    transcript_create_button.click(
        create_LLM_content,
        inputs=[video_id, df_string_output, transcript_kind],
        outputs=[df_string_output]
    )
    transcript_delete_button.click(
        delete_LLM_content,
        inputs=[video_id, transcript_kind],
        outputs=[df_string_output]
    )
    transcript_edit_button.click(
        enable_edit_mode,
        inputs=[],
        outputs=[df_string_output]
    )
    transcript_update_button.click(
        update_LLM_content,
        inputs=[video_id, df_string_output, transcript_kind],
        outputs=[df_string_output]
    )
    
    # key_moments event
    key_moments_create_button.click(
        create_LLM_content,
        inputs=[video_id, df_string_output, key_moments_kind],
        outputs=[key_moments]
    )
    key_moments_delete_button.click(
        delete_LLM_content,
        inputs=[video_id, key_moments_kind],
        outputs=[key_moments]
    )
    key_moments_edit_button.click(
        enable_edit_mode,
        inputs=[],
        outputs=[key_moments]
    )
    key_moments_update_button.click(
        update_LLM_content,
        inputs=[video_id, key_moments, key_moments_kind],
        outputs=[key_moments]
    )
    
    # question_list event
    questions_create_button.click(
        create_LLM_content,
        inputs=[video_id, df_string_output, questions_kind],
        outputs=[questions_json]
    )
    questions_delete_button.click(
        delete_LLM_content,
        inputs=[video_id, questions_kind],
        outputs=[questions_json]
    )
    questions_edit_button.click(
        enable_edit_mode,
        inputs=[],
        outputs=[questions_json]
    )
    questions_update_button.click(
        update_LLM_content,
        inputs=[video_id, questions_json, questions_kind],
        outputs=[questions_json]
    ) 

    # 教師版
    worksheet_content_btn.click(
        get_ai_content,
        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, worksheet_algorithm, worksheet_content_type_name],
        outputs=[worksheet_exam_result_original, worksheet_exam_result, worksheet_prompt, worksheet_exam_result_prompt]
    )
    lesson_plan_btn.click(
        get_ai_content,
        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, lesson_plan_time, lesson_plan_content_type_name],
        outputs=[lesson_plan_exam_result_original, lesson_plan_exam_result, lesson_plan_prompt, lesson_plan_exam_result_prompt]
    )
    exit_ticket_btn.click(
        get_ai_content,
        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, exit_ticket_time, exit_ticket_content_type_name],
        outputs=[exit_ticket_exam_result_original, exit_ticket_exam_result, exit_ticket_prompt, exit_ticket_exam_result_prompt]
    )

    # 生成結果微調
    worksheet_exam_result_fine_tune_btn.click(
        generate_exam_fine_tune_result,
        inputs=[password, worksheet_exam_result_prompt, df_string_output, worksheet_exam_result, worksheet_exam_result_fine_tune_prompt],
        outputs=[worksheet_exam_result]
    )
    worksheet_download_exam_result_button.click(
        download_exam_result,
        inputs=[worksheet_exam_result],
        outputs=[worksheet_exam_result_word_link]
    )
    worksheet_exam_result_retrun_original.click(
        return_original_exam_result,
        inputs=[worksheet_exam_result_original],
        outputs=[worksheet_exam_result]
    )
    lesson_plan_exam_result_fine_tune_btn.click(
        generate_exam_fine_tune_result,
        inputs=[password, lesson_plan_exam_result_prompt, df_string_output, lesson_plan_exam_result, lesson_plan_exam_result_fine_tune_prompt],
        outputs=[lesson_plan_exam_result]
    )
    lesson_plan_download_exam_result_button.click(
        download_exam_result,
        inputs=[lesson_plan_exam_result],
        outputs=[lesson_plan_exam_result_word_link]
    )
    lesson_plan_exam_result_retrun_original.click(
        return_original_exam_result,
        inputs=[lesson_plan_exam_result_original],
        outputs=[lesson_plan_exam_result]
    )
    exit_ticket_exam_result_fine_tune_btn.click(
        generate_exam_fine_tune_result,
        inputs=[password, exit_ticket_exam_result_prompt, df_string_output, exit_ticket_exam_result, exit_ticket_exam_result_fine_tune_prompt],
        outputs=[exit_ticket_exam_result]
    )
    exit_ticket_download_exam_result_button.click(
        download_exam_result,
        inputs=[exit_ticket_exam_result],
        outputs=[exit_ticket_exam_result_word_link]
    )
    exit_ticket_exam_result_retrun_original.click(
        return_original_exam_result,
        inputs=[exit_ticket_exam_result_original],
        outputs=[exit_ticket_exam_result]
    )

    # init_params
    demo.load(
        init_params, 
        inputs =[youtube_link],
        outputs = [admin, reading_passage_admin, summary_admmin, see_details, password , youtube_link]
    )

demo.launch(allowed_paths=["videos"])