app.py

import os
import sys
import subprocess
import re
import time
import zipfile
import json
import shutil
from concurrent.futures import ThreadPoolExecutor, as_completed

# 1. 自动安装依赖
def ensure_dependencies():
    try:
        import gradio
        import requests
    except ImportError:
        # 确保安装所需库
        print("Installing required packages: gradio, requests...")
        subprocess.check_call([sys.executable, "-m", "pip", "install", "gradio", "requests"])

ensure_dependencies()

import gradio as gr
import requests

# ================= 默认配置 =================
# 1. 文本/思考专用 Key (架构师 + 导演)
DEFAULT_LLM_API_KEY = "sk-DZ5g7Zu0lFDlR7mBkbNsZLFTt1KBqA8ocsAH1mcvsZDWtydx"
# 2. 视频生成专用 Key (Veo 渲染) -> [新增]
DEFAULT_VIDEO_API_KEY = "sk-G6LN0uC2BVclZjx1ObDJPkMZTZvtjau1Ss7GjCvRLJyI5euU"

MERCHANT_BASE_URL = "https://xingjiabiapi.com"
VEO_MODEL = "veo_3_1-fast"
VIDEO_SIZE = "16x9"
TEXT_MODEL = "gemini-3-pro-preview-thinking"

# ===============================================
# --- 角色1：首席工艺工程师 (The Chief Process Engineer) ---
# ===============================================
DEFAULT_ARCHITECT_PROMPT = """
你是一家顶级工厂的**首席工艺工程师 (Chief Process Engineer)**。
你**完全不懂**电影制作，你的唯一职责是设计一条**“逻辑严密、设备真实、物理过程详尽”**的工业生产线。

**你的任务：**
为指定产品设计一份《全生命周期工艺说明书》(Full Lifecycle Process Protocol)。

**⚠️ 工程师铁律 (Engineering Laws)：**
1.  **全链路覆盖 (Full Lifecycle Scope)**：
    * **起点必须是源头**：严禁只从工厂门口写起。必须包含**“原材料获取 (Acquisition)”**（例如：果园采摘、矿山开采、原木砍伐）。
    * **终点必须是成品**：必须包含**“最终成品形态 (Final Product)”**（例如：装瓶、装箱、码垛完成）。
2.  **物理真实性**：必须使用真实的工业设备名称（如：Harvester, Hammer Mill, Optical Sorter）。
3.  **流程闭环**：Step N 的输出必须是 Step N+1 的输入。严禁逻辑断层。
4.  **微观物理描述**：你必须详细描述原料在每一道工序中发生了什么**物理或化学变化**。
    * *Input State*: 进入机器前的状态。
    * *Mechanism*: 机器施加的力。
    * *Output State*: 离开机器后的状态。

**流程结构要求 (Standard Operating Procedure)**：
请列出 **30-40 个关键工序**（为了满足200个镜头的细节支撑，工序必须足够细致），必须严格涵盖以下四个物理阶段：
1.  **Raw Material Acquisition (源头获取)**: 采摘、开采、收割。
2.  **Preprocessing (预处理)**: 运输、清洗、去皮、除杂、分拣。
3.  **Core Processing (核心加工)**: 改变物质形态的关键步骤（粉碎、混合、加热、成型、装配）。**这是物理变化的中心。**
4.  **Final Packaging (成品封装)**: 灌装/装箱、贴标、封箱、码垛入库。

**输出格式 (严禁修改)**：
请输出一份技术列表，不要写成剧本。

Step [序号] | [工序名称]
* **Equipment**: [真实机器名称]
* **Physics Input**: [原料进入时的状态]
* **Mechanism**: [机器运作原理与物理动作描述]
* **Physics Output**: [原料离开时的物理变化结果]
"""

# ===============================================
# --- 角色2：IMAX 细节狂魔导演 (Director & Editor) ---
# --- 核心修改：200+长视频节奏 + 10%前奏限制 + 史诗开篇 ---
# ===============================================
DEFAULT_DIRECTOR_PROMPT = """
你是一位追求**“极致真实与细节”**的 IMAX 纪录片导演，同时也是一位**金牌剪辑师**。
你拿到了一份由“首席工程师”编写的枯燥《工艺说明书》。
你的任务是：**基于这份技术文档，通过“剪辑配比”和“视觉转译”，生成一部节奏完美的“解压沉浸式 (Decompressive Immersion)”长视频工业大片脚本。**

**⚠️ 优先级说明：以下【五大终极死令】拥有最高优先级，必须 100% 执行！⚠️**

**💀 死令一：长视频剪辑配比与节奏法则 (The Long-Form Editorial Ratio) [★核心节奏控制★]**
* **背景**：这部视频总长度将超过 **200个8秒镜头**。你必须精细规划节奏，防止观众疲劳。
* **强制执行 (10-90 Rule)**：
    * **Phase A: 史诗开篇与物流 (The Epic Intro & Logistics)**：[**严格限制在总量的 10% 以内**]
        * **开篇要求**：原材料采集（Acquisition）必须是**“大片级解压沉浸”**。
        * *❌ 拒绝*：普通的果农摘果子。
        * *✅ 必须*：宏大的机械收割阵列、慢动作果实坠落特写、极致的自然光影。让观众前3秒就起鸡皮疙瘩。
        * **物流压缩**：运输和卸货要快、准、狠。不要在路上浪费时间。
    * **Phase B: 极致沉浸核心区 (The Deep Immersion Core)**：[**必须占据总量的 90% 以上**]
        * 核心加工环节（切、碎、炸、流）是绝对主角。**无限膨胀**这些步骤。

**💀 死令二：架构微观膨胀法则 (The Law of Architectural Expansion) [★长视频填充术★]**
* **原则**：为了填满 200+ 个镜头，工程师的一个 `Step` 必须被极度展开。
* **强制执行**：
    * **核心步骤 (Core Processing)**：必须**膨胀**为 4-6 个连续的 `Shots` (Entry -> Process Slow-mo -> Highlight Detail -> Exit)。
    * **非核心步骤**：用 1-2 个镜头交代。

**💀 死令三：三段式微观动作拆解 (The Tri-Phase Action Protocol) [★拒绝原子化★]**
* **原则**：对于任何核心物理处理，必须拆解为 **Entry -> Process -> Exit**。
* **强制执行**：
    * **Phase 1 (Entry/Impact)**: 交代**“进入/倾泻”**。例如：原料**倾倒**进机器。
    * **Phase 2 (Process/Turmoil)**: 交代**“作用/剧变”**。例如：刀片**高速旋转**，原料被**瞬间切碎**，汁液/火花飞溅。
    * **Phase 3 (Exit/Transfer)**: 交代**“撤出/结果”**。例如：成品被传送带**带离**，进入下一环。

**💀 死令四：X光负载锁定与防空车 (Visual Load Enforcement) [★拒绝空车BUG★]**
* **原则**：解决“车辆/容器到站变空”的逻辑断层。
* **强制执行**：在描述“车辆到达”、“倒车入库”或“停靠”时，**严禁**只写车辆外观。
* **必须包含动作**：Prompt 必须包含 **"The rear doors SWING OPEN to reveal the massive cargo inside."** (车门打开露出货物)。

**💀 死令五：绝对状态继承与防回退 (Absolute State Inheritance) [★拒绝物体复原★]**
* **原则**：Veo 看不见上一条视频。你必须在 Prompt 开头显式描述“上一个镜头造成的改变”。
* **形容词前置锁死**：
    * ❌ 严禁写 "The apple" -> 必须写 "The **SLICED and CUBED** apple pieces"。
    * ❌ 严禁写 "The truck" -> 必须写 "The **HEAVILY LOADED** truck"。
* **动势接龙**：Shot N 的 **(Start_Frame_Visual)** 必须完美衔接 Shot N-1 的结束画面。

# ---------------------------------------------------------------------
# 导演执行手册：常规铁律 (The Execution Manual)
# ---------------------------------------------------------------------

**🔥 铁律一：解压沉浸流派的极致执行 (The Execution of Decompressive Immersion)**
根据工程师描述的物理动作，必须分配并执行以下流派：
* **[SLICE] (切削沉浸)**：侧面微距，展示阻力与丝滑。
* **[CRUSH] (破坏沉浸)**：慢动作，展示崩裂与形变。
* **[PEEL] (剥离沉浸)**：拉伸运镜，展示反光。
* **[FLOW] (流体沉浸)**：高光特写，展示粘稠无气泡。
* **[CLEAN] (净化沉浸)**：对比运镜，展示污渍剥离。
* **[SYNC] (循环沉浸)**：阵列同步，展示宏大规模。

**🔥 铁律二：视觉内容铁律**
1. **绝对饱和密度 (Absolute Saturation)**：拒绝留白。产品必须**铺满屏幕 (Edge-to-Edge)**。
2. **暴力冗余 (Brute-Force Redundancy)**：**严禁代词**。必须在每个镜头里**全称复述主语及其状态**。

**🔥 铁律三：逻辑与连贯性铁律**
3. **剪辑思维**：使用“Continuing the motion...”桥接。
4. **场景一致性**：同一阶段环境描述必须**复制粘贴**。

# ==================== 输出格式 (严禁修改) ====================
请严格按照以下格式生成脚本。**格式已包含状态继承、三段式检查与逻辑负载检查。**

Shot [序号]/[总数] | [中文标题-用于文件名]
Sora Prompt (English): (Action_Phase): [CRITICAL CHECK: Entry/Process/Exit? ENFORCE 3-SHOT RULE] (Start_Frame_Visual): [Visual Bridge from prev shot. IF TRUCK ARRIVAL -> DOORS OPEN REVEALING CARGO] (Object_State_Adjectives): [MANDATORY: Sliced/Crushed/Liquid/Packed - DO NOT USE RAW NOUNS] (Engineering_Source): [Ref Step # from Engineer] (Satisfaction_Genre): [SLICE/CRUSH/FLOW/SYNC/PEEL/FIT/CLEAN - DIRECTOR DECIDES] (Execution_Focus): [Macro Resistance/Glossy Flow/Zero Error Sync...] (Scene_Environment): [LOCKED CONSISTENT DESCRIPTION] (Visual_Action_Trajectory): [DETAILED: Start -> Arc -> Impact -> Release. RE-STATE SUBJECT FULLY.] (Screen_Density): [Edge-to-Edge Filling/Infinite Array] (Audio_Decompressive_Immersion): [Specific Mechanical Sound, NO MUSIC] (Asset_Consistency): [Repeat Product Description] (Human_Interaction): [Hands retracting/Eyes monitoring/Sterile Suit]
"""

# ===============================================

def generate_process_architecture(topic, api_key, architect_prompt):
    """阶段一：生成工艺说明书 (使用 LLM Key)"""
    if not topic: return "❌ 请先输入产品名称"
    if not api_key: return "❌ 请先输入 LLM API Key"
        
    print(f"🧠 [{TEXT_MODEL}] 正在构建《{topic}》的全生命周期工艺流程...")
        
    user_content = f"""
    Design a rigorous, physically accurate Full Lifecycle Industrial Process Protocol for: {topic}.
     
    ROLE: You are the Chief Process Engineer.
    GOAL: Create a technical blueprint covering Raw Material Acquisition -> Final Product.
    
    REQUIREMENTS:
    1.  **Scope**: MUST Start from **Source Acquisition** (Harvesting/Mining) -> End at **Final Packaging**.
    2.  **Logic**: Step-by-step physical transformation. No gaps.
    3.  **Equipment**: Use real industrial machine names.
    4.  **Objective Reality**: Describe the process objectively. No camera angles.
    """
        
    url = f"{MERCHANT_BASE_URL}/v1/chat/completions"
    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key.strip()}"}
    data = {
        "model": TEXT_MODEL,
        "messages": [
            {"role": "system", "content": architect_prompt},
            {"role": "user", "content": user_content}
        ],
        "temperature": 0.5, 
        "max_tokens": 4096
    }
        
    try:
        response = requests.post(url, headers=headers, json=data, timeout=240)
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            return f"Error: {response.text}"
    except Exception as e:
        return f"Request Failed: {e}"

def generate_script_batch(topic, architecture, start_shot, end_shot, total_shots, system_prompt, api_key):
    """阶段二：分批循环生成脚本 (使用 LLM Key)"""
    
    print(f"🔄 正在生成分镜 {start_shot} - {end_shot} ...")
        
    user_content = f"""
    Product: {topic}
    Engineering Blueprint Reference:
    {architecture}
        
    Task: Generate ONLY shots #{start_shot} to #{end_shot} (out of {total_shots} total).
    
    IMPORTANT CONTEXT:
    * You are the IMAX DIRECTOR & EDITOR. 
    * This is a LONG-FORM video ({total_shots} shots total). 
    * **GOAL**: Create "Decompressive Immersion" visuals.
     
    CRITICAL INSTRUCTIONS:
    1. **APPLY THE 10% RULE**: 
       - IF this batch is part of the first 10% ({int(total_shots*0.1)} shots): Focus on **BLOCKBUSTER ACQUISITION** (Harvesting/Mining). Make it EPIC but FAST (Total Acquisition+Logistics <= 10%).
       - IF this batch is past the first 10%: Focus on **CORE PROCESSING**. Expand every step massively.
    2. **TRI-PHASE PROTOCOL**: For core steps, you MUST use Entry->Process->Exit.
    3. **VISUAL CONTINUITY**: Fix any logic gaps.
    4. **DENSITY**: Edge-to-Edge Filling.
    5. **AUDIO**: Only use "Decompressive Immersion" sounds.
    """
        
    url = f"{MERCHANT_BASE_URL}/v1/chat/completions"
    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key.strip()}"}
    data = {
        "model": TEXT_MODEL,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_content}
        ],
        "temperature": 0.7, 
        "max_tokens": 64000 # [核心修改] 取消限制！设置极大值以确保一次生成大量内容不截断
    }
        
    try:
        response = requests.post(url, headers=headers, json=data, timeout=360)
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            return None
    except Exception as e:
        return None

def step2_generate_script(topic, architecture, count, system_prompt, api_key):
    """阶段二：分批循环生成脚本 (使用 LLM Key)"""
    if not architecture: return "❌ 请先生成并确认工艺架构", None
    if not api_key: return "❌ 请先输入 LLM API Key", None
    
    logs = [f"🚀 [任务启动] 目标: 生成 {count} 个 IMAX 级分镜脚本...", "------------------------------------------------"]
    yield "\n".join(logs), None
    
    full_script_text = ""
    # 根据用户要求，虽然代码支持分批，但因为Token限制已取消，实际上LLM可能一次性输出很多。
    # 这里保持逻辑不变，但确保 prompt 里的 token 足够大。
    batch_size = 10 
    total_batches = (count + batch_size - 1) // batch_size
    MAX_RETRIES = 3 
    
    for i in range(total_batches):
        start_num = i * batch_size + 1
        end_num = min((i + 1) * batch_size, count)
        batch_success = False 
        
        for attempt in range(MAX_RETRIES):
            if attempt == 0:
                logs.append(f"🔵 [Batch {i+1}/{total_batches}] 正在初始化 Shot {start_num}-{end_num}...")
                yield "\n".join(logs), full_script_text
                time.sleep(0.5)
                logs.append(f"🧠 [导演思维] 正在回溯上文并应用【死令】(10%开篇 / 三段式 / 负载锁定)...")
                yield "\n".join(logs), full_script_text
                logs.append(f"📡 [云端通讯] 正在请求 Thinking 模型撰写剧本 (使用 LLM Key)...")
                yield "\n".join(logs), full_script_text
            else:
                logs.append(f"⚠️ [网络重试] 第 {i+1} 批次生成失败，正在进行第 {attempt+1}/{MAX_RETRIES} 次重试...")
                yield "\n".join(logs), full_script_text
            
            # 使用传入的 api_key (即 LLM Key)
            batch_script = generate_script_batch(topic, architecture, start_num, end_num, count, system_prompt, api_key)
            
            if batch_script and len(batch_script) > 100: 
                full_script_text += f"\n{batch_script}\n"
                logs.append(f"✅ [成功] 第 {i+1} 批次脚本已写入内存。")
                logs.append("------------------------------------------------")
                batch_success = True
                yield "\n".join(logs), full_script_text
                break 
            else:
                logs.append(f"❌ [失败] 返回数据为空或格式错误。等待冷却...")
                yield "\n".join(logs), full_script_text
                time.sleep(2) 
        
        if not batch_success:
            return "\n".join(logs) + "\n❌❌❌ [严重错误] 任务熔断停止。", full_script_text 
            
    prompts_data = extract_prompts_with_titles(full_script_text)
    logs.append(f"\n🎉 [全部完成] 脚本生成完毕！共解析出 {len(prompts_data)} 个有效镜头。")
    logs.append(f"👉 准备进入第三步渲染 (将使用 Video API Key)。")
    return "\n".join(logs), full_script_text

def extract_prompts_with_titles(script_text):
    """提取 Prompt 和 标题 (支持 Markdown)"""
    if not script_text: return []
    pattern = r"(?:[\*\#]*\s*)Shot\s+(\d+).*?\|\s*([^\n]+).*?Sora Prompt \(English\):\s*(.*?)(?=\n\s*(?:[\*\#]*\s*)Shot|::END::|$)"
    matches = re.findall(pattern, script_text, re.DOTALL | re.IGNORECASE)
    results = []
    for shot_num, title, content in matches:
        clean_title = title.replace("**", "").replace("##", "").strip()
        safe_title = re.sub(r'[\\/*?:"<>|]', "", clean_title).strip().replace(" ", "_")
        if len(safe_title) > 40: safe_title = safe_title[:40]
        filename_base = f"Shot_{int(shot_num):03d}_{safe_title}"
        clean_p = content.replace("\n", " ").replace("**", "").replace("##", "").strip()
        clean_p = re.sub(r'\s+', ' ', clean_p)
        if len(clean_p) > 10:
            results.append({"filename": filename_base, "prompt": clean_p})
    return results

def generate_single_video_task(prompt, filename_base, save_dir, video_api_key, topic):
    """生成单视频：使用 VIDEO API KEY"""
    if not prompt: return None
    clean_prompt = prompt.replace("--ar 16:9", "").replace("16:9", "")
    final_prompt = (
        f"Wide screen 16x9 video. {topic} manufacturing documentary blockbuster. "
        f"**BBC/Discovery Style, Hyper-Realistic, 8K, No Sci-Fi.** " 
        f"**Ultimate Decompressive Immersion, Massive Screen Density, Edge-to-Edge Filling.** "
        f"**Editorial Continuity, Smooth Transitions, Perfect Loop.** "
        f"**Completed Action Trajectory, Object Lands Successfully.** "
        f"**Pure Diegetic Audio, No Music, Decompressive Immersion Sounds.** "
        f"**Extremely Detailed Texture, Physics-based Motion, Human-Machine Collaboration.** "
        f"{clean_prompt} --ar 16x9"
    )
    url = f"{MERCHANT_BASE_URL}/v1/chat/completions"
    # === 核心修改：使用 video_api_key ===
    headers = {"Content-Type": "application/json", "Authorization": f"Bearer {video_api_key.strip()}"}
    data = {
        "model": VEO_MODEL,
        "messages": [{"role": "user", "content": final_prompt}],
        "stream": False, "size": VIDEO_SIZE, "seconds": 8, "aspect_ratio": "16:9" 
    }
    fname = f"{filename_base}.mp4"
    save_path = os.path.join(save_dir, fname)
    try:
        resp = requests.post(url, headers=headers, json=data, timeout=300)
        if resp.status_code != 200: return {"status": "error", "msg": f"[{filename_base}] ❌ API Error: {resp.status_code}"}
        try:
            content = resp.json()['choices'][0]['message']['content']
            url_match = re.search(r'(https?://[^\s)"]+)', content)
            if not url_match: return {"status": "error", "msg": f"[{filename_base}] ❌ No URL found"}
            vid_data = requests.get(url_match.group(1).split(')')[0]).content
            with open(save_path, "wb") as f: f.write(vid_data)
            return {"status": "success", "file": save_path, "msg": f"✅ [渲染成功] {fname}"} 
        except Exception as e: return {"status": "error", "msg": f"[{filename_base}] ❌ Parse Error: {e}"}
    except Exception as e: return {"status": "error", "msg": f"[{filename_base}] ❌ Network Error: {e}"}

def step3_generate_videos(topic, script_text, video_api_key, progress=gr.Progress()):
    """阶段三：批量生成视频 (传入 Video API Key)"""
    if not script_text: yield "❌ 脚本内容为空，请先执行第二步", None, None; return
    if not video_api_key: yield "❌ 请先输入 Video API Key", None, None; return

    timestamp = int(time.time())
    safe_topic = re.sub(r'[\\/*?:"<>|]', "", topic).replace(" ", "_") if topic else "Untitled"
    base_dir = "AutoSaved_Videos"
    session_dir = os.path.join(base_dir, f"{safe_topic}_{timestamp}")
    os.makedirs(session_dir, exist_ok=True)
    
    logs = [f"🚀 [渲染启动] 开始批量生成视频 (使用 Veo 专用 Key)...", f"📂 归档目录: {os.path.abspath(session_dir)}"]
    yield "\n".join(logs), None, None
    
    with open(os.path.join(session_dir, "script.txt"), "w", encoding="utf-8") as f:
        f.write(script_text)
    
    prompts_data = extract_prompts_with_titles(script_text)
    if not prompts_data:
        logs.append("❌ 脚本格式解析失败，未找到有效 Prompt"); yield "\n".join(logs), None, None; return

    logs.append(f"🎥 任务队列建立完成：共 {len(prompts_data)} 个镜头。正在向 Veo 发送并发请求...")
    yield "\n".join(logs), None, None
    
    work_list = prompts_data
    generated_files = []
    
    # [核心修改] 确保一次性提交所有视频 (max_workers=len(work_list))
    # 只要系统资源允许，这将同时发起 200 个请求
    with ThreadPoolExecutor(max_workers=len(work_list)) as executor:
        futures = {
            # === 核心修改：传入 video_api_key ===
            executor.submit(generate_single_video_task, item['prompt'], item['filename'], session_dir, video_api_key, topic): item['filename'] 
            for item in work_list
        }
        
        completed = 0
        for future in as_completed(futures):
            res = future.result()
            completed += 1
            progress(completed/len(work_list), desc=f"渲染中 {completed}/{len(work_list)}")
            if res:
                if res['status'] == 'success':
                    logs.append(f"✅ [{completed}/{len(work_list)}] 视频就绪: {res['msg'].split(' ')[-1]}")
                    generated_files.append(res['file'])
                else:
                    logs.append(f"❌ [{completed}/{len(work_list)}] 失败: {res['msg']}")
                
                yield "\n".join(logs[-15:]), generated_files, None 

    if generated_files:
        generated_files.sort()
        zip_name = f"{session_dir}.zip"
        shutil.make_archive(session_dir, 'zip', session_dir)
        logs.append(f"\n🎉 [全部完成] 已打包 ZIP，请点击右侧下载。"); 
        yield "\n".join(logs), generated_files, zip_name
    else:
        logs.append("\n❌ 全部失败，无视频生成"); yield "\n".join(logs), None, None

# === 界面 ===
with gr.Blocks(title="Veo Ultimate + Viral Decompressive Immersion (超级全量版)") as app:
    gr.Markdown("# 🏭 终极工业大片 + 极致解压 (Super Hybrid V14 - 双引擎版)")
    gr.Markdown("核心升级：**[独立 Video API]** + **[超长视频(200+镜头)]** + **[无限制生成]**")
        
    with gr.Row(variant="panel"):
        # 1. LLM 专用 Key
        api_key_input = gr.Textbox(
            label="🔑 LLM API Key (架构师+导演)", 
            value=DEFAULT_LLM_API_KEY, 
            type="password",
            placeholder="用于生成架构和剧本 (Gemini)"
        )
        # 2. 视频生成专用 Key
        video_api_key_input = gr.Textbox(
            label="🎬 Video API Key (Veo 渲染专用)", 
            value=DEFAULT_VIDEO_API_KEY, 
            type="password",
            placeholder="用于生成视频 (Veo)"
        )

    with gr.Row(variant="panel"):
        with gr.Column(scale=1):
            topic_input = gr.Textbox(label="1. 输入产品名称", placeholder="例如：Apple Juice, Ceramic Plate, Steel Gear")
            with gr.Accordion("🛠️ 角色1：首席工艺工程师 (全生命周期技术)", open=False):
                architect_prompt_input = gr.Textbox(label="Engineer System Prompt", value=DEFAULT_ARCHITECT_PROMPT, lines=8)
            plan_btn = gr.Button("🛠️ 第一步：生成工艺说明书 (LLM)", variant="secondary")
           
        with gr.Column(scale=2):
            architecture_output = gr.Textbox(
                label="2. 确认说明书 (检查：源头 -> 物理流程 -> 成品)", 
                lines=10, 
                placeholder="点击左侧按钮生成工艺...",
                interactive=True
            )

    with gr.Row():
        with gr.Column(scale=1):
            # [核心修改] UI 适配 200 个镜头
            count_slider = gr.Slider(minimum=1, maximum=300, value=200, step=1, label="3. 镜头数量 (建议 200+)")
            
            script_btn = gr.Button("📝 第二步：导演介入-解压沉浸分镜 (LLM)", variant="primary")
            video_btn = gr.Button("🎬 第三步：开始批量渲染视频 (Video API)", variant="stop")
           
        with gr.Column(scale=2):
            with gr.Accordion("🎭 角色2：IMAX 导演 (负责解压沉浸美学)", open=False):
                system_prompt_input = gr.Textbox(label="Director System Prompt", value=DEFAULT_DIRECTOR_PROMPT, lines=8)

    with gr.Row():
        log_out = gr.Textbox(label="运行日志 (实时反馈)", lines=12)
        script_out = gr.Textbox(label="最终脚本", lines=12, interactive=True)
        zip_out = gr.File(label="下载生成结果 (文件列表 & ZIP)")

    # 绑定事件
    plan_btn.click(
        generate_process_architecture,
        inputs=[topic_input, api_key_input, architect_prompt_input],
        outputs=[architecture_output]
    )
    
    script_btn.click(
        step2_generate_script,
        inputs=[topic_input, architecture_output, count_slider, system_prompt_input, api_key_input],
        outputs=[log_out, script_out]
    )
    
    video_btn.click(
        step3_generate_videos,
        # === 核心修改：传入 Video API Key ===
        inputs=[topic_input, script_out, video_api_key_input],
        outputs=[log_out, zip_out, zip_out]
    )

app.launch()