# -*- coding: utf-8 -*-
"""
智能体基类 - 所有阶段智能体的抽象接口
"""

import logging
from abc import ABC, abstractmethod
from typing import Any, Optional, Dict, Callable

logger = logging.getLogger(__name__)


class AgentInterface(ABC):
    """所有智能体必须实现的接口"""

    def __init__(self, name: str = ""):
        self.name = name
        self.cancellation_check: Optional[Callable] = None
        self.progress_callback: Optional[Callable] = None

    def set_cancellation_check(self, fn: Callable):
        self.cancellation_check = fn

    def set_progress_callback(self, fn: Callable):
        self.progress_callback = fn

    def _report_progress(self, phase: str, step_desc: str, percent: float, data: dict = None):
        if self.progress_callback:
            self.progress_callback(phase, step_desc, percent, data)

    def _check_cancel(self):
        if self.cancellation_check and self.cancellation_check():
            raise RuntimeError(f"Agent [{self.name}] cancelled by user")

    def _cancellable_query(self, llm, prompt: str, **kwargs):
        """在 LLM 调用前后检查取消状态"""
        self._check_cancel()
        result = llm.query(prompt, **kwargs)
        self._check_cancel()
        return result

    # -------- 抽象方法 --------

    @abstractmethod
    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        """
        核心处理逻辑

        Args:
            input_data: 来自上一阶段的输入数据
            intervention: 用户介入修改内容

        Returns:
            dict: { "payload": ..., "requires_intervention": bool }
        """
        pass

# -*- coding: utf-8 -*-
"""
阶段2: 角色/场景设计智能体
基于阶段1的剧本JSON生成角色4视图和场景全景图
支持单项重新生成、历史版本切换
图片以 character_id / setting_id 命名
"""

import os
import re
import json
import glob
import asyncio
import logging
from typing import Any, Optional, Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed

from .base_agent import AgentInterface
from prompts.loader import load_prompt, load_style_prompt

logger = logging.getLogger(__name__)


class CharacterDesignerAgent(AgentInterface):
    """角色/场景设计：从剧本JSON读取描述 → 生成角色4视图 + 场景全景图"""

    def __init__(self):
        super().__init__(name="CharacterDesigner")

    # ─── 提示词模板 ───

    @staticmethod
    def _char_prompt(name: str, desc: str, style: str, species: str = "") -> str:
        """角色4视图提示词 - 从风格提示词文件加载"""
        # 加载风格提示词模板
        template = load_style_prompt('character', style)
        # 替换角色信息
        return template.format(name=name, desc=desc)

    @staticmethod
    def _setting_prompt(name: str, desc: str, style: str) -> str:
        """场景全景图提示词 - 从风格提示词文件加载"""
        # 加载风格提示词模板
        template = load_style_prompt('setting', style)
        # 替换场景信息
        return template.format(name=name, desc=desc)

    # ─── 文件管理（基于唯一ID） ───

    @staticmethod
    def _asset_base(sid: str) -> str:
        return os.path.join('code/result/image', str(sid), 'Assets')

    def _list_versions(self, sid: str, asset_type: str, asset_id: str) -> List[str]:
        """列出某个素材的所有历史版本文件路径，按时间排序
        文件命名: {asset_id}.png, {asset_id}_v2.png, {asset_id}_v3.png, ...
        """
        adir = os.path.join(self._asset_base(sid), asset_type)
        pattern = os.path.join(adir, f"{asset_id}*.png")
        files = sorted(glob.glob(pattern), key=os.path.getmtime)
        return files

    def _next_version_path(self, sid: str, asset_type: str, asset_id: str) -> str:
        """获取下一个版本的文件路径"""
        adir = os.path.join(self._asset_base(sid), asset_type)
        os.makedirs(adir, exist_ok=True)

        existing = self._list_versions(sid, asset_type, asset_id)
        if not existing:
            return os.path.join(adir, f"{asset_id}.png")

        max_v = 1
        for fp in existing:
            bn = os.path.splitext(os.path.basename(fp))[0]
            m = re.search(r'_v(\d+)$', bn)
            if m:
                max_v = max(max_v, int(m.group(1)))

        return os.path.join(adir, f"{asset_id}_v{max_v + 1}.png")

    def _build_asset_info(self, sid: str, asset_type: str,
                          asset_id: str, name: str, desc: str,
                          selected_path: str = "") -> dict:
        """构建单个素材的信息（含所有历史版本）"""
        versions = self._list_versions(sid, asset_type, asset_id)
        if not selected_path and versions:
            selected_path = versions[-1]
        return {
            "id": asset_id,
            "name": name,
            "description": desc,
            "selected": selected_path,
            "versions": versions,
        }

    # ─── 图片生成 ───

    def _build_preview(self, sid: str, chars_desc: dict, sets_desc: dict) -> dict:
        """构建素材预览列表（含当前状态）用于前端实时显示"""
        preview = {"characters": [], "settings": []}
        for asset_id, info in chars_desc.items():
            existing = self._list_versions(sid, 'characters', asset_id)
            preview["characters"].append({
                "id": asset_id,
                "name": info.get("name", ""),
                "description": info.get("description", ""),
                "selected": existing[-1] if existing else "",
                "versions": existing,
                "status": "done" if existing else "pending",
            })
        for asset_id, info in sets_desc.items():
            existing = self._list_versions(sid, 'settings', asset_id)
            name = info.get("name", "") if isinstance(info, dict) else ""
            desc = info.get("description", "") if isinstance(info, dict) else str(info)
            preview["settings"].append({
                "id": asset_id,
                "name": name,
                "description": desc,
                "selected": existing[-1] if existing else "",
                "versions": existing,
                "status": "done" if existing else "pending",
            })
        return preview

    def _generate_one(self, img_client, asset_id: str, name: str, desc: str,
                      asset_type: str, style: str, species: str,
                      t2i_model: str, vlm_model: str, sid: str, max_iterations: int = 3) -> tuple:
        """生成单个素材图并返回 (asset_id, path_or_None, eval_result)

        评估-生成循环：如果 VLM 评估发现问题，最多重新生成 max_iterations 次
        """
        self._check_cancel()

        # 初始提示词
        if asset_type == 'characters':
            base_prompt = self._char_prompt(name, desc, style, species)
        else:
            base_prompt = self._setting_prompt(name, desc, style)

        size = "1920*1080"
        current_prompt = base_prompt

        for iteration in range(max_iterations):
            self._check_cancel()

            save_path = self._next_version_path(sid, asset_type, asset_id)
            save_dir = os.path.dirname(save_path)

            try:
                paths = img_client.generate_image(
                    prompt=current_prompt, model=t2i_model,
                    session_id=str(sid), save_dir=save_dir, size=size,
                )
                if not paths:
                    continue

                gen = paths[0]
                if gen != save_path:
                    if os.path.exists(save_path):
                        os.remove(save_path)
                    os.rename(gen, save_path)

                # VLM 评估
                eval_result = self._evaluate_with_vlm(save_path, desc, asset_type, vlm_model)

                # 使用固定阈值判断是否接受（8分及以上通过）
                score = eval_result.get('score', 0)
                issues = eval_result.get('issues', [])
                suggestion = eval_result.get('suggestion', '')
                is_acceptable = score >= 8

                if is_acceptable:
                    logger.info(f"[{asset_type}] {name} ✓ VLM评估通过 - 评分: {score}/10")
                else:
                    logger.warning(f"[{asset_type}] {name} ✗ VLM评估不通过 - 评分: {score}/10")
                    logger.warning(f"[{asset_type}] 问题: {issues}")
                    if suggestion:
                        logger.warning(f"[{asset_type}] 建议: {suggestion}")

                # 检查是否需要重新生成
                if is_acceptable:
                    # 评估通过，返回结果
                    return asset_id, save_path, eval_result
                else:
                    # 评估不通过，记录问题并继续循环
                    # 报告进度
                    self._report_progress("角色设计", f"重新生成中 ({iteration + 2}/{max_iterations}): {name}", 0)

            except Exception as e:
                logger.error(f"Asset gen failed for {asset_type} {name}({asset_id}): {e}")

        # 达到最大迭代次数，尝试使用 VLM 选择最佳图片
        logger.warning(f"[{asset_type}] {name} reached max iterations ({max_iterations}), trying VLM selection")

        # 收集所有生成过的版本
        all_versions = self._list_versions(sid, asset_type, asset_id)
        if len(all_versions) > 1:
            # 有多个版本，调用 VLM 选择最好的
            best_path, best_eval = self._select_best_with_vlm(
                all_versions, name, desc, asset_type, species, vlm_model
            )
            if best_path:
                logger.info(f"[{asset_type}] {name} VLM selected best version: {best_path}")
                return asset_id, best_path, best_eval

        # 没有多个版本或 VLM 选择失败，返回最后一次结果
        return asset_id, save_path if os.path.exists(save_path) else None, eval_result if 'eval_result' in locals() else None

    def _evaluate_with_vlm(self, image_path: str, description: str, asset_type: str, vlm_model: str = "qwen3.5-plus") -> dict:
        """使用 VLM 评估生成的图片"""
        try:
            from tool.vlm_client import VLM
            vlm = VLM()

            # 选择评估提示词
            if asset_type == 'characters':
                eval_prompt = load_prompt('character', 'eval_character', 'zh').format(
                    character_description=description
                )
            else:
                eval_prompt = load_prompt('setting', 'eval_setting', 'zh').format(
                    setting_description=description
                )

            result = vlm.query(
                prompt=eval_prompt,
                image_paths=[image_path],
                model=vlm_model
            )

            # 解析结果
            if result and isinstance(result, list):
                result_text = result[0] if result else ""
            elif isinstance(result, str):
                result_text = result
            else:
                result_text = str(result)

            # 尝试提取 JSON
            import json
            try:
                # 找到 JSON 部分
                import re
                json_match = re.search(r'\{[^{}]*\}', result_text, re.DOTALL)
                if json_match:
                    eval_result = json.loads(json_match.group())
                    return eval_result
            except:
                pass

            return {"score": 5, "issues": ["评估解析失败"], "is_acceptable": True}

        except Exception as e:
            logger.warning(f"VLM evaluation failed: {e}")
            return {"score": 5, "issues": [str(e)], "is_acceptable": True}

    def _select_best_with_vlm(self, image_paths: List[str], name: str, description: str,
                               asset_type: str, species: str = "", vlm_model: str = "qwen3.5-plus") -> tuple:
        """使用 VLM 从多个版本中选择最好的一张"""
        from tool.vlm_client import VLM
        import re

        if not image_paths:
            return None, None

        try:
            vlm = VLM()

            # 选择评估提示词
            if asset_type == 'characters':
                select_prompt = load_prompt('character', 'eval_select_best', 'zh').format(
                    num_images=len(image_paths),
                    num_images_minus_1=len(image_paths) - 1,
                    character_name=name,
                    character_description=description,
                    species=species,
                    images_list="\n".join([f"图片{i}: {p}" for i, p in enumerate(image_paths)])
                )
            else:
                select_prompt = load_prompt('setting', 'eval_select_best', 'zh').format(
                    num_images=len(image_paths),
                    num_images_minus_1=len(image_paths) - 1,
                    setting_name=name,
                    setting_description=description,
                    images_list="\n".join([f"图片{i}: {p}" for i, p in enumerate(image_paths)])
                )

            result = vlm.query(select_prompt, image_paths=image_paths, model=vlm_model)
            logger.info(f"[{asset_type}] {name} VLM selection result: {result}")

            # 解析 JSON 结果
            if result and isinstance(result, list):
                result_text = result[0] if result else ""
            elif isinstance(result, str):
                result_text = result
            else:
                result_text = str(result)

            logger.info(f"[{asset_type}] {name} VLM selection raw response: {result_text[:500]}")

            # 解析 JSON，提取 best_index
            best_index = 0
            try:
                # 找到 JSON 开始和结束
                json_start = result_text.find('{')
                json_end = result_text.rfind('}') + 1
                if json_start >= 0 and json_end > json_start:
                    json_str = result_text[json_start:json_end]
                    selection_result = json.loads(json_str)
                    best_index = selection_result.get('best_index', 0)
                    logger.info(f"[{asset_type}] {name} Parsed best_index: {best_index}")
            except Exception as e:
                logger.warning(f"[{asset_type}] {name} JSON parse failed: {e}, using last image")
                best_index = len(image_paths) - 1

            # 如果找到了 best_index，选择对应的图片
            if best_index is not None and 0 <= best_index < len(image_paths):
                best_path = image_paths[best_index]
                best_eval = {"score": 8, "issues": [], "is_acceptable": True, "reason": f"VLM selected image {best_index + 1} of {len(image_paths)}"}
                logger.info(f"[{asset_type}] {name} Selected image: {best_path}")
                return best_path, best_eval
            else:
                logger.warning(f"[{asset_type}] {name} Invalid best_index: {best_index}, available images: {len(image_paths)}")

        except Exception as e:
            logger.warning(f"VLM selection failed: {e}")

        return None, None

    # ─── 从剧本JSON读取角色/场景数据 ───

    @staticmethod
    def _read_script_data(sid: str) -> dict:
        """从结果文件的 script_json 字段读取角色和场景数据（含唯一ID）

        Returns:
            {
                "characters": { character_id: { "name", "description", "species" } },
                "settings":   { setting_id:   { "name", "description" } },
            }
        """
        from config import settings

        script_json_path = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')
        if not os.path.exists(script_json_path):
            return {"characters": {}, "settings": {}}

        with open(script_json_path, 'r', encoding='utf-8') as f:
            data = json.load(f)

        sid_data = data.get(str(sid), {})

        # 优先从 script_json 读取（包含完整ID信息）
        sj = sid_data.get('script_json')
        if sj:
            chars = {}
            for c in sj.get("characters", []):
                cid = c.get("character_id", "")
                if cid:
                    chars[cid] = {
                        "name": c.get("name", ""),
                        "description": c.get("description", ""),
                        "species": c.get("species", ""),
                    }
            sets = {}
            for s in sj.get("settings", []):
                sid_val = s.get("setting_id", "")
                if sid_val:
                    sets[sid_val] = {
                        "name": s.get("name", ""),
                        "description": s.get("description", ""),
                    }
            return {"characters": chars, "settings": sets}

        return {"characters": {}, "settings": {}}

    # ─── 核心流程 ───

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        from config import settings
        from tool.image_client import ImageClient

        sid = input_data["session_id"]
        style = input_data.get("style", "anime")
        t2i_model = input_data.get("image_t2i_model", "") or settings.IMAGE_T2I_MODEL
        vlm_model = input_data.get("vlm_model", "qwen3.5-plus")
        # 根据 enable_concurrency 决定并发数
        enable_concurrency = input_data.get("enable_concurrency", True)
        logger.info(f"[CharacterAgent] enable_concurrency={enable_concurrency}")
        from config_model import get_max_concurrency
        max_concurrency = get_max_concurrency(t2i_model, enable_concurrency)
        logger.info(f"[CharacterAgent] 使用并发数={max_concurrency}")
        concurrency = max_concurrency

        img_client = ImageClient(
            dashscope_api_key=settings.DASHSCOPE_API_KEY,
            dashscope_base_url=settings.DASHSCOPE_BASE_URL,
            gpt_api_key=os.getenv("OPENAI_API_KEY"),
            gpt_base_url=os.getenv("OPENAI_BASE_URL"),
            gpt_official_api_key=settings.OPENAI_OFFICIAL_API_KEY,
            local_proxy=settings.LOCAL_PROXY,
            ark_api_key=settings.ARK_API_KEY,
            ark_base_url=settings.ARK_BASE_URL,
        )

        # ═══════════ 介入: 重新生成指定素材 ═══════════
        if intervention:
            regen_chars = intervention.get("regenerate_characters", [])   # list of asset_id
            regen_sets = intervention.get("regenerate_settings", [])      # list of asset_id
            select_chars = intervention.get("select_characters", {})      # {asset_id: path}
            select_sets = intervention.get("select_settings", {})         # {asset_id: path}
            update_descriptions = intervention.get("update_descriptions", {})  # {characters: {}, settings: {}}

            script_data = self._read_script_data(sid)
            chars_desc = script_data["characters"]
            sets_desc = script_data["settings"]

            # 处理描述更新
            if update_descriptions:
                updated_chars = update_descriptions.get("characters", {})
                updated_sets = update_descriptions.get("settings", {})

                # 更新角色描述 (支持两种格式：字符串或字典)
                for asset_id, info in updated_chars.items():
                    if asset_id in chars_desc:
                        if isinstance(info, dict):
                            if "name" in info:
                                chars_desc[asset_id]["name"] = info["name"]
                            if "description" in info:
                                chars_desc[asset_id]["description"] = info["description"]
                            if "species" in info:
                                chars_desc[asset_id]["species"] = info["species"]
                        else:
                            # 简单字符串格式：直接更新 description
                            chars_desc[asset_id]["description"] = str(info)

                # 更新场景描述 (支持两种格式：字符串或字典)
                for asset_id, info in updated_sets.items():
                    if asset_id in sets_desc:
                        if isinstance(info, dict):
                            if "name" in info:
                                sets_desc[asset_id]["name"] = info["name"]
                            if "description" in info:
                                sets_desc[asset_id]["description"] = info["description"]
                        else:
                            # 简单字符串格式：直接更新 description
                            sets_desc[asset_id]["description"] = str(info)

                # 写回剧本数据文件
                script_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')
                with open(script_file, 'r', encoding='utf-8') as f:
                    full_data = json.load(f)

                if str(sid) in full_data:
                    full_data[str(sid)]["characters"] = chars_desc
                    full_data[str(sid)]["settings"] = sets_desc

                with open(script_file, 'w', encoding='utf-8') as f:
                    json.dump(full_data, f, ensure_ascii=False, indent=2)

                logger.info(f"[CharacterAgent] Updated descriptions for session {sid}")

            if regen_chars or regen_sets:
                self._report_progress("角色设计", "重新生成中...", 10)
                tasks = []
                for asset_id in regen_chars:
                    info = chars_desc.get(asset_id, {})
                    tasks.append(("characters", asset_id, info.get("name", ""), info.get("description", ""), info.get("species", "")))
                for asset_id in regen_sets:
                    info = sets_desc.get(asset_id, {})
                    tasks.append(("settings", asset_id, info.get("name", ""), info.get("description", ""), ""))

                def regen_run():
                    total = len(tasks)
                    done = 0
                    with ThreadPoolExecutor(max_workers=concurrency) as executor:
                        futs = {}
                        for atype, aid, name, desc, species in tasks:
                            fut = executor.submit(
                                self._generate_one, img_client,
                                aid, name, desc, atype, style, species, t2i_model, vlm_model, sid
                            )
                            futs[fut] = (atype, aid, name)
                        for fut in as_completed(futs):
                            atype, aid, fname = futs[fut]
                            _, result_path, eval_result = fut.result()
                            done += 1
                            pct = 10 + int(85 * done / max(total, 1))
                            if result_path:
                                versions = self._list_versions(sid, atype, aid)
                                self._report_progress("角色设计", f"完成: {fname}", pct, data={
                                    "asset_complete": {
                                        "type": atype, "id": aid, "status": "done",
                                        "selected": result_path, "versions": versions,
                                        "evaluation": eval_result,
                                    }
                                })
                            else:
                                self._report_progress("角色设计", f"失败: {fname}", pct, data={
                                    "asset_complete": {
                                        "type": atype, "id": aid, "status": "failed",
                                        "selected": "", "versions": [],
                                    }
                                })

                loop = asyncio.get_running_loop()
                await loop.run_in_executor(None, regen_run)

            self._report_progress("角色设计", "完成", 100)
            return self._build_payload(sid, chars_desc, sets_desc, select_chars, select_sets)

        # ═══════════ 正常流程: 全量首次生成 ═══════════
        self._report_progress("角色设计", "读取剧本数据...", 5)

        script_data = self._read_script_data(sid)
        chars_desc = script_data["characters"]
        sets_desc = script_data["settings"]

        if not chars_desc and not sets_desc:
            raise Exception("未能从剧本中读取到角色或场景描述数据")

        # 发送素材预览（含所有素材和当前状态）
        preview = self._build_preview(sid, chars_desc, sets_desc)
        self._report_progress("角色设计", "加载素材列表", 8, data={"assets_preview": preview})

        def run():
            all_tasks = []
            for asset_id, info in chars_desc.items():
                existing = self._list_versions(sid, 'characters', asset_id)
                if existing:
                    continue
                all_tasks.append(("characters", asset_id, info.get("name", ""), info.get("description", ""), info.get("species", "")))

            for asset_id, info in sets_desc.items():
                desc = info.get("description", "") if isinstance(info, dict) else info
                existing = self._list_versions(sid, 'settings', asset_id)
                if existing:
                    continue
                all_tasks.append(("settings", asset_id, info.get("name", "") if isinstance(info, dict) else "", desc, ""))

            if not all_tasks:
                self._report_progress("角色设计", "所有素材已存在", 95)
                return

            total = len(all_tasks)
            done = 0

            with ThreadPoolExecutor(max_workers=concurrency) as executor:
                futs = {}
                for atype, aid, name, desc, species in all_tasks:
                    fut = executor.submit(
                        self._generate_one, img_client,
                        aid, name, desc, atype, style, species, t2i_model, vlm_model, sid,
                    )
                    futs[fut] = (atype, aid, name)

                for fut in as_completed(futs):
                    atype, aid, fname = futs[fut]
                    _, result_path, _ = fut.result()
                    done += 1
                    pct = 10 + int(85 * done / max(total, 1))
                    if result_path:
                        versions = self._list_versions(sid, atype, aid)
                        self._report_progress("角色设计", f"完成: {fname}", pct, data={
                            "asset_complete": {
                                "type": atype, "id": aid, "status": "done",
                                "selected": result_path, "versions": versions,
                            }
                        })
                    else:
                        self._report_progress("角色设计", f"失败: {fname}", pct, data={
                            "asset_complete": {
                                "type": atype, "id": aid, "status": "failed",
                                "selected": "", "versions": self._list_versions(sid, atype, aid),
                            }
                        })

            self._report_progress("角色设计", "完成", 100)

        loop = asyncio.get_running_loop()
        await loop.run_in_executor(None, run)

        return self._build_payload(sid, chars_desc, sets_desc)

    def _build_payload(self, sid: str, chars_desc: dict, sets_desc: dict,
                       selected_chars: dict = None, selected_sets: dict = None) -> dict:
        """构建返回给前端的 payload"""
        selected_chars = selected_chars or {}
        selected_sets = selected_sets or {}

        characters = []
        for asset_id, info in chars_desc.items():
            desc = info.get("description", "") if isinstance(info, dict) else info
            name = info.get("name", "") if isinstance(info, dict) else ""
            sel = selected_chars.get(asset_id, "")
            characters.append(self._build_asset_info(sid, 'characters', asset_id, name, desc, sel))

        settings_list = []
        for asset_id, info in sets_desc.items():
            desc = info.get("description", "") if isinstance(info, dict) else info
            name = info.get("name", "") if isinstance(info, dict) else ""
            sel = selected_sets.get(asset_id, "")
            settings_list.append(self._build_asset_info(sid, 'settings', asset_id, name, desc, sel))

        # 图片生成完成即为阶段完成，用户选择图片只是更新数据
        return {
            "payload": {
                "session_id": sid,
                "characters": characters,
                "settings": settings_list,
            },
            "stage_completed": True,
        }

# -*- coding: utf-8 -*-
"""
阶段6: 后期制作智能体
拼接用户在阶段5选定的视频片段 → 最终成片
"""

import os
import re
import subprocess
import asyncio
import logging
from typing import Any, Optional, Dict

from .base_agent import AgentInterface

logger = logging.getLogger(__name__)


class VideoEditorAgent(AgentInterface):
    """后期制作：拼接用户选择的视频片段 → 最终成片"""

    def __init__(self):
        super().__init__(name="VideoEditor")

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        sid = input_data["session_id"]
        selected_clips: dict = input_data.get("selected_clips", {})

        if not selected_clips:
            raise Exception("未收到用户选择的视频片段(selected_clips)，请先完成阶段5")

        self._report_progress("后期制作", "准备视频片段...", 5)

        def run():
            video_dir = os.path.join('code/result/video', str(sid))

            # 按 shot_id 中的数字排序
            def sort_key(k: str) -> tuple:
                return tuple(int(n) for n in re.findall(r'\d+', k)) or (999,)

            clip_paths = []
            for shot_id in sorted(selected_clips.keys(), key=sort_key):
                path = selected_clips[shot_id]
                if os.path.exists(path):
                    clip_paths.append(path)
                else:
                    logger.warning(f"[{sid}] Clip missing: {shot_id} → {path}")

            if not clip_paths:
                raise Exception("所有选定的视频片段文件均不存在")

            logger.info(f"[{sid}] Concat {len(clip_paths)} clips")
            self._report_progress("后期制作", f"拼接 {len(clip_paths)} 个片段...", 15)

            list_path = os.path.join(video_dir, 'file_list.txt')
            with open(list_path, 'w', encoding='utf-8') as f:
                for p in clip_paths:
                    f.write(f"file '{os.path.abspath(p)}'\n")

            self._report_progress("后期制作", "ffmpeg 拼接中...", 30)

            output = os.path.join(video_dir, f'{sid}_final.mp4')
            cmd = ['ffmpeg', '-f', 'concat', '-safe', '0',
                   '-i', list_path, '-c', 'copy', '-y', output]
            subprocess.run(cmd, check=True, capture_output=True)
            logger.info(f"[{sid}] Concat success: {output}")
            return output

        loop = asyncio.get_running_loop()
        final_path = await loop.run_in_executor(None, run)

        self._report_progress("后期制作", "成片完成", 100)

        return {
            "payload": {"session_id": sid, "final_video": final_path},
            "stage_completed": True,
        }

# -*- coding: utf-8 -*-
"""
阶段4: 参考图生成智能体
- 基于阶段3分镜(shots)，为每个分镜生成「首帧图像提示词」，再据此生成参考图
- 首帧提示词由 LLM 根据 shot 的 plot、visual_prompt、duration 生成
- 阶段5生视频时使用阶段3的原始分镜描述，而非首帧提示词
- 支持逐项实时预览、重新生成、多版本管理
"""

import os
import re
import glob
import json
import asyncio
import logging
from typing import Any, Optional, Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed

from .base_agent import AgentInterface
from prompts.loader import load_prompt

logger = logging.getLogger(__name__)


def ratio_to_size(ratio: str) -> str:
    """将视频比例转换为图像尺寸"""
    size_map = {
        "16:9": "1920*1080",
        "9:16": "1080*1920",
        "1:1": "1024*1024",
        "4:3": "1024*768",
        "3:4": "768*1024",
        "21:9": "2560*1080",
    }
    return size_map.get(ratio, "1920*1080")


class ReferenceGeneratorAgent(AgentInterface):
    """参考图生成：分镜(阶段3) → 首帧提示词(LLM) → 参考图(图像模型)"""

    def __init__(self):
        super().__init__(name="ReferenceGenerator")

    # ─── 版本管理 ───

    @staticmethod
    def _scenes_base(sid: str) -> str:
        return os.path.join('code/result/image', str(sid), 'Scenes')

    def _list_versions(self, sid: str, shot_id: str) -> List[str]:
        """列出某个分镜的所有历史版本
        命名: shot_001_01.jpg, shot_001_01_v2.jpg, ...
        """
        return self._list_versions_static(sid, shot_id)

    @staticmethod
    def _list_versions_static(sid: str, shot_id: str) -> List[str]:
        """列出某个分镜的所有历史版本（静态方法，供外部调用）"""
        scenes_dir = os.path.join('code/result/image', str(sid), 'Scenes')
        pattern = os.path.join(scenes_dir, f"{shot_id}*.jpg")
        files = sorted(glob.glob(pattern), key=os.path.getmtime)
        return files

    def _next_version_path(self, sid: str, shot_id: str) -> str:
        """获取下一个版本路径"""
        scenes_dir = self._scenes_base(sid)
        os.makedirs(scenes_dir, exist_ok=True)

        existing = self._list_versions(sid, shot_id)
        if not existing:
            return os.path.join(scenes_dir, f"{shot_id}.jpg")

        max_v = 1
        for fp in existing:
            bn = os.path.splitext(os.path.basename(fp))[0]
            m = re.search(r'_v(\d+)$', bn)
            if m:
                max_v = max(max_v, int(m.group(1)))

        return os.path.join(scenes_dir, f"{shot_id}_v{max_v + 1}.jpg")

    # ─── 素材匹配 ───

    @staticmethod
    def _build_asset_map(sid: str) -> Dict[str, Dict[str, str]]:
        """扫描阶段2生成的素材文件"""
        base = os.path.join('code/result/image', str(sid), 'Assets')
        am: Dict[str, Dict[str, str]] = {'characters': {}, 'settings': {}}
        for sub, key in [('characters', 'characters'), ('settings', 'settings')]:
            d = os.path.join(base, sub)
            if os.path.isdir(d):
                files = sorted(
                    [f for f in os.listdir(d) if f.endswith('.png')],
                    key=lambda f: os.path.getmtime(os.path.join(d, f))
                )
                for fn in files:
                    name = os.path.splitext(fn)[0]
                    base_id = re.sub(r'_v\d+$', '', name)
                    am[key][base_id] = os.path.join(d, fn)
        return am

    def _collect_refs(self, shot: dict, asset_map: dict,
                      char_id_map: dict, setting_id_map: dict) -> List[str]:
        """为一个分镜收集参考原图路径（角色 + 场景素材）"""
        refs = []
        for cn in shot.get('characters', []):
            cid = char_id_map.get(cn)
            if cid and cid in asset_map['characters']:
                refs.append(os.path.abspath(asset_map['characters'][cid]))
                logger.info(f"[{shot.get('shot_id', '')}] 添加角色参考图: {cn} -> {cid}")
        loc = shot.get('location', '')
        set_id = setting_id_map.get(loc)
        if set_id and set_id in asset_map['settings']:
            refs.append(os.path.abspath(asset_map['settings'][set_id]))
            logger.info(f"[{shot.get('shot_id', '')}] 添加场景参考图: {loc} -> {set_id}")
        else:
            logger.warning(f"[{shot.get('shot_id', '')}] 未找到场景参考图: location={loc}, set_id={set_id}, available_settings={list(asset_map['settings'].keys())}")
        logger.info(f"[{shot.get('shot_id', '')}] 共收集 {len(refs)} 张参考图")
        return refs[:10]

    def _get_descriptions(self, shot: dict, char_id_map: dict, setting_id_map: dict,
                          script_json: dict) -> tuple:
        """获取分镜中涉及的角色和场景描述

        Returns:
            (character_description, setting_description)
        """
        # 角色描述
        char_descs = []
        for cn in shot.get('characters', []):
            cid = char_id_map.get(cn, '')
            if cid:
                for c in script_json.get('characters', []):
                    if c.get('character_id') == cid:
                        desc = c.get('description', '')
                        visual = c.get('visual_description', '')
                        if visual:
                            char_descs.append(f"{cn}: {visual}")
                        elif desc:
                            char_descs.append(f"{cn}: {desc}")
                        break

        # 场景描述
        loc = shot.get('location', '')
        set_id = setting_id_map.get(loc)
        setting_desc = ""
        if set_id:
            for s in script_json.get('settings', []):
                if s.get('setting_id') == set_id:
                    setting_desc = s.get('description', '') or s.get('visual_description', '')
                    break

        return "； ".join(char_descs), setting_desc

    # ─── 首帧提示词生成 ───

    # ─── 预览构建 ───

    def _build_preview(self, sid: str, shots: list) -> list:
        """构建分镜预览列表（含当前状态）"""
        preview = []
        for idx, shot in enumerate(shots, 1):
            shot_id = shot['shot_id']
            versions = self._list_versions(sid, shot_id)
            preview.append({
                "id": shot_id,
                "name": f"场景{shot['scene_number']}-镜头{shot['shot_number']}",
                "index": idx,
                "description": shot.get('visual_prompt', ''),
                "selected": versions[-1] if versions else "",
                "versions": versions,
                "status": "done" if versions else "pending",
            })
        return preview

    # ─── 单张生成 ───

    def _generate_one(self, img_client, sid: str, shot: dict,
                      first_frame_prompt: str, refs: List[str],
                      style: str, it2i_model: str, t2i_model: str,
                      ref_size: str = "1920*1080", vlm_model: str = "qwen3.5-plus",
                      character_description: str = "", setting_description: str = "",
                      max_versions: int = 3) -> tuple:
        """生成单个分镜参考图，返回 (shot_id, path_or_None, eval_result)

        最多生成 max_versions 个版本，如果所有版本都没有达到8分，
        使用 VLM 选择最好的一张作为最终参考图。
        """
        shot_id = shot.get('shot_id', '')
        plot = shot.get('plot', '')
        visual_prompt = shot.get('visual_prompt', '')

        # 取消时直接跳过，不抛异常，以保留已生成的部分结果
        if self.cancellation_check and self.cancellation_check():
            logger.info(f"ReferenceGeneratorAgent: {shot_id} 跳过（用户取消）")
            return shot_id, None, None

        model = it2i_model if refs else t2i_model
        logger.info(f"[{shot_id}] 使用模型: {model}, 参考图数量: {len(refs) if refs else 0}")
        if refs:
            for i, r in enumerate(refs):
                logger.info(f"[{shot_id}] 参考图[{i}]: {r}")

        # 收集所有生成的版本
        all_versions = []
        all_eval_results = []

        for version in range(max_versions):
            self._check_cancel()

            full_prompt = (
                f"{style} style, masterpiece, cinematic composition, "
                f"best quality, high resolution, "
                f"{first_frame_prompt}"
            )

            save_path = self._next_version_path(sid, shot_id)
            save_dir = os.path.dirname(save_path)

            try:
                paths = img_client.generate_image(
                    prompt=full_prompt,
                    image_paths=refs if refs else None,
                    model=model,
                    session_id=str(sid),
                    save_dir=save_dir,
                    size=ref_size,
                )
                if not paths:
                    continue

                gen = paths[0]
                if gen != save_path:
                    if os.path.exists(save_path):
                        os.remove(save_path)
                    os.rename(gen, save_path)

                # VLM 评估
                eval_result = self._evaluate_with_vlm(save_path, shot,
                                                      character_description=character_description,
                                                      setting_description=setting_description,
                                                      vlm_model=vlm_model)

                score = eval_result.get('score', 0)
                is_acceptable = score >= 8

                logger.info(f"[{shot_id}] 版本{version + 1}: 评分 {score}/10, {'✓通过' if is_acceptable else '✗不通过'}")

                # 记录版本信息
                all_versions.append(save_path)
                all_eval_results.append(eval_result)

                # 如果达到8分，立即返回
                if is_acceptable:
                    return shot_id, save_path, eval_result

                # 报告进度
                if version < max_versions - 1:
                    self._report_progress("参考图", f"重新生成中 ({version + 2}/{max_versions}): {shot_id}", 0)

            except Exception as e:
                logger.error(f"Shot {shot_id} image generation failed: {e}")

        # 所有版本都没有达到8分，使用 VLM 选择最好的
        if all_versions:
            logger.warning(f"[{shot_id}] 所有版本都未达到8分，使用VLM选择最佳...")
            best_path, best_eval = self._select_best_with_vlm(
                all_versions, shot,
                character_description=character_description,
                setting_description=setting_description,
                vlm_model=vlm_model
            )
            if best_path:
                return shot_id, best_path, best_eval

        # 如果没有任何生成成功
        logger.warning(f"[{shot_id}] 没有成功生成任何图片")
        return shot_id, None, None

    def _select_best_with_vlm(self, image_paths: List[str], shot: dict,
                              character_description: str = "", setting_description: str = "",
                              vlm_model: str = "qwen3.5-plus") -> tuple:
        """使用 VLM 从多个版本中选择最好的一张"""
        from tool.vlm_client import VLM

        if not image_paths:
            return None, None

        shot_id = shot.get('shot_id', '')
        plot = shot.get('plot', '')
        visual_prompt = shot.get('visual_prompt', '')

        # 加载评估提示词
        select_prompt = load_prompt('reference', 'eval_select_best', 'zh').format(
            num_images=len(image_paths),
            num_images_minus_1=len(image_paths) - 1,
            plot=plot,
            visual_prompt=visual_prompt,
            character_description=character_description,
            setting_description=setting_description,
            images_list="\n".join([f"图片{i}: {p}" for i, p in enumerate(image_paths)])
        )

        try:
            vlm = VLM()
            result = vlm.query(select_prompt, image_paths=image_paths, model=vlm_model)
            logger.info(f"[{shot_id}] VLM选择结果: {result}")

            # 解析 JSON 结果
            import re
            json_match = re.search(r'\{[^{}]*\}', result, re.DOTALL)
            if json_match:
                selected = json.loads(json_match.group())
                selected_idx = selected.get('selected_index', 0)
                if 0 <= selected_idx < len(image_paths):
                    best_path = image_paths[selected_idx]
                    logger.info(f"[{shot_id}] VLM选择第{selected_idx + 1}张作为最佳图片")
                    # 构建评估结果
                    best_eval = {
                        "score": selected.get('score', 5),
                        "issues": selected.get('issues', []),
                        "is_acceptable": True,
                        "selected_by_vlm": True,
                        "reason": selected.get('reason', '')
                    }
                    return best_path, best_eval

        except Exception as e:
            logger.error(f"[{shot_id}] VLM选择最佳图片失败: {e}")

        # 如果失败，返回第一个版本
        return image_paths[0], {"score": 5, "issues": [], "selected_by_vlm": False}

    def _evaluate_with_vlm(self, image_path: str, shot: dict,
                          character_description: str = "", setting_description: str = "",
                          vlm_model: str = "qwen3.5-plus") -> dict:
        """使用 VLM 评估首帧参考图"""
        try:
            from tool.vlm_client import VLM
            vlm = VLM()

            eval_prompt = load_prompt('reference', 'eval_first_frame', 'zh').format(
                plot=shot.get('plot', ''),
                visual_prompt=shot.get('visual_prompt', ''),
                character_description=character_description,
                setting_description=setting_description
            )

            result = vlm.query(
                prompt=eval_prompt,
                image_paths=[image_path],
                model=vlm_model
            )

            if result and isinstance(result, list):
                result_text = result[0] if result else ""
            elif isinstance(result, str):
                result_text = result
            else:
                result_text = str(result)

            import json
            try:
                import re
                json_match = re.search(r'\{[^{}]*\}', result_text, re.DOTALL)
                if json_match:
                    eval_result = json.loads(json_match.group())
                    return eval_result
            except:
                pass

            return {"score": 5, "issues": ["评估解析失败"], "is_acceptable": True}

        except Exception as e:
            logger.warning(f"VLM evaluation failed: {e}")
            return {"score": 5, "issues": [str(e)], "is_acceptable": True}

    # ─── 构建最终 payload ───

    def _build_payload(self, sid: str, shots: list) -> dict:
        """构建最终 payload"""
        scenes = []
        for idx, shot in enumerate(shots, 1):
            shot_id = shot['shot_id']
            versions = self._list_versions(sid, shot_id)
            # status: 有图片=done, 无图片=pending(待生成)
            status = "done" if versions else "pending"
            scenes.append({
                "id": shot_id,
                "name": f"场景{shot['scene_number']}-镜头{shot['shot_number']}",
                "index": idx,
                "description": shot.get('visual_prompt', ''),
                "selected": versions[-1] if versions else "",
                "versions": versions,
                "status": status,
            })
        return {
            "payload": {
                "session_id": sid,
                "scenes": scenes,
            },
            "stage_completed": True,
        }

    def _update_scene2image(self, sid: str, shots: list, result_file: str,
                            first_frame_prompts: dict) -> None:
        """写回 scene2image 到结果文件
        scene2image[shot_id] = {
            local_path: 当前最新版本图片路径,
            prompt: 首帧图像提示词(阶段4生成),
            plot: 原始分镜剧情描述(阶段3，供阶段5视频使用),
            video_prompt: 原始分镜视觉描述(阶段3),
            duration: 分镜时长,
        }
        """
        with open(result_file, 'r', encoding='utf-8') as f:
            res = json.load(f)
        scene_images = {}
        for shot in shots:
            shot_id = shot['shot_id']
            versions = self._list_versions(sid, shot_id)
            if versions:
                scene_images[shot_id] = {
                    "local_path": versions[-1],
                    "prompt": first_frame_prompts.get(shot_id, shot.get('visual_prompt', '')),
                    "plot": shot.get('plot', ''),
                    "video_prompt": shot.get('visual_prompt', ''),
                    "duration": shot.get('duration', 10),
                }
        res[str(sid)]['scene2image'] = scene_images
        with open(result_file, 'w', encoding='utf-8') as f:
            json.dump(res, f, indent=4, ensure_ascii=False)

    # ─── 核心流程 ───

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        from config import settings
        from tool.image_client import ImageClient
        from tool.llm_client import LLM

        sid = input_data["session_id"]
        style = input_data.get("style", "anime")
        video_ratio = input_data.get("video_ratio", "16:9")
        ref_size = ratio_to_size(video_ratio)
        llm_model = input_data.get("llm_model", "") or settings.LLM_MODEL
        t2i = input_data.get("image_t2i_model", "") or settings.IMAGE_T2I_MODEL
        it2i = input_data.get("image_it2i_model", "") or settings.IMAGE_IT2I_MODEL
        vlm_model = input_data.get("vlm_model", "") or settings.VLM_MODEL
        # 根据 enable_concurrency 决定并发数
        enable_concurrency = input_data.get("enable_concurrency", True)
        logger.info(f"[ReferenceAgent] enable_concurrency={enable_concurrency}")
        # 取 t2i 和 it2i 中的最大并发数
        from config_model import get_max_concurrency
        max_t2i = get_max_concurrency(t2i, enable_concurrency)
        max_it2i = get_max_concurrency(it2i, enable_concurrency)
        concurrency = max(max_t2i, max_it2i)
        logger.info(f"[ReferenceAgent] 使用并发数={concurrency}")

        result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')

        img_client = ImageClient(
            dashscope_api_key=settings.DASHSCOPE_API_KEY,
            dashscope_base_url=settings.DASHSCOPE_BASE_URL,
            gpt_api_key=os.getenv("OPENAI_API_KEY"),
            gpt_base_url=os.getenv("OPENAI_BASE_URL"),
            gpt_official_api_key=settings.OPENAI_OFFICIAL_API_KEY,
            local_proxy=settings.LOCAL_PROXY,
            ark_api_key=settings.ARK_API_KEY,
            ark_base_url=settings.ARK_BASE_URL,
        )

        # 读取数据
        with open(result_file, 'r', encoding='utf-8') as f:
            results = json.load(f)
        story_data = results[str(sid)]

        storyboard = story_data.get('storyboard', {})
        shots = storyboard.get('shots', [])
        if not shots:
            raise Exception("未找到分镜数据(storyboard.shots)，请先完成阶段3")

        script_json = story_data.get('script_json', {})

        # 判断中英文
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in script_json.get("title", ""))

        # 构建 name → id 映射（用于素材匹配）
        char_id_map = {}
        for c in script_json.get('characters', []):
            char_id_map[c['name']] = c.get('character_id', '')

        setting_id_map = {}
        for s in script_json.get('settings', []):
            setting_id_map[s['name']] = s.get('setting_id', '')

        asset_map = self._build_asset_map(sid)

        # ═══ 介入：重新生成指定分镜 ═══
        if intervention:
            regen_scenes = intervention.get("regenerate_scenes", [])

            if regen_scenes:
                self._report_progress("参考图", "重新生成中...", 2)

                # 重新从 session JSON 文件读取最新的 storyboard 数据
                with open(result_file, 'r', encoding='utf-8') as f:
                    fresh_data = json.load(f)
                fresh_storyboard = fresh_data.get(str(sid), {}).get('storyboard', {})
                fresh_shots = fresh_storyboard.get('shots', [])
                fresh_shot_map = {s['shot_id']: s for s in fresh_shots}

                llm = LLM()

                def regen_run():
                    total = len(regen_scenes)
                    done = 0
                    # 每分镜5个步骤：准备(1)、生成(3)、完成(1)
                    steps_per_shot = 5
                    total_steps = total * steps_per_shot

                    def calc_pct_regen(step: int) -> int:
                        return min(2 + int(98 * step / total_steps), 100)

                    # 从最新读取的 storyboard JSON 中获取 visual_prompt
                    prompt_map = {}  # shot_id → first_frame_prompt
                    for i, shot_id in enumerate(regen_scenes):
                        shot = fresh_shot_map.get(shot_id, {})
                        ff_prompt = shot.get('visual_prompt', '')
                        prompt_map[shot_id] = ff_prompt
                        logger.info(f"[{shot_id}] first-frame prompt (from JSON): {ff_prompt[:80]}...")
                        self._report_progress("参考图", f"准备提示词: {shot_id}", calc_pct_regen(i * steps_per_shot + 1))

                    # 并发生成图像
                    self._report_progress("参考图", "生成参考图...", calc_pct_regen(total * 2))
                    with ThreadPoolExecutor(max_workers=concurrency) as executor:
                        futs = {}
                        for shot_id in regen_scenes:
                            shot = fresh_shot_map.get(shot_id, {})
                            refs = self._collect_refs(shot, asset_map, char_id_map, setting_id_map)
                            char_desc, set_desc = self._get_descriptions(
                                shot, char_id_map, setting_id_map, script_json
                            )
                            fut = executor.submit(
                                self._generate_one, img_client, sid,
                                shot, prompt_map[shot_id], refs,
                                style, it2i, t2i, ref_size, vlm_model,
                                character_description=char_desc, setting_description=set_desc
                            )
                            futs[fut] = shot_id
                        for fut in as_completed(futs):
                            shot_id_done = futs[fut]
                            try:
                                _, result_path, eval_result = fut.result()
                            except Exception as e:
                                logger.error(f"Regen future error for {shot_id_done}: {e}")
                                result_path = None
                            done += 1
                            step = done * steps_per_shot
                            pct = calc_pct_regen(step)
                            if result_path:
                                versions = self._list_versions(sid, shot_id_done)
                                self._report_progress("参考图", f"完成: {shot_id_done}", pct, data={
                                    "asset_complete": {
                                        "type": "scenes", "id": shot_id_done,
                                        "status": "done",
                                        "selected": result_path,
                                        "versions": versions,
                                    }
                                })
                            else:
                                self._report_progress("参考图", f"失败: {shot_id_done}", pct, data={
                                    "asset_complete": {
                                        "type": "scenes", "id": shot_id_done,
                                        "status": "failed",
                                        "selected": "", "versions": [],
                                    }
                                })
                            # 检查取消
                            if self.cancellation_check and self.cancellation_check():
                                logger.info("ReferenceGeneratorAgent: 用户取消重新生成，停止等待剩余任务")
                                for f in futs:
                                    if not f.done():
                                        f.cancel()
                                break

                loop = asyncio.get_running_loop()
                await loop.run_in_executor(None, regen_run)

            # 重新生成后更新 scene2image（同步最新版本信息）
            self._update_scene2image(sid, shots, result_file, {})

            self._report_progress("参考图", "完成", 100)
            return self._build_payload(sid, shots)

        # ═══ 正常流程：全量生成 ═══
        self._report_progress("参考图", "加载分镜数据...", 5)

        # 发送预览列表
        preview = self._build_preview(sid, shots)
        self._report_progress("参考图", "加载分镜列表", 8, data={"assets_preview": {"scenes": preview}})

        llm = LLM()

        def run():
            # 筛选需要生成的（跳过已有图的）
            pending_shots = []
            for shot in shots:
                shot_id = shot['shot_id']
                existing = self._list_versions(sid, shot_id)
                if existing:
                    continue
                pending_shots.append(shot)

            if not pending_shots:
                self._report_progress("参考图", "所有分镜图已存在", 95)
                return

            total = len(pending_shots)
            # 每分镜5个步骤：准备(1)、生成(3)、完成(1)
            steps_per_shot = 5
            total_steps = total * steps_per_shot + 1  # +1 是加载数据步骤

            def calc_pct(step: int) -> int:
                """根据步骤计算进度百分比"""
                return min(2 + int(98 * step / total_steps), 100)

            done = 0

            # 步骤1：加载数据
            self._report_progress("参考图", "准备生成...", calc_pct(0))

            # 步骤2-6(每分镜)：准备提示词
            first_frame_prompts = {}  # shot_id → prompt
            for i, shot in enumerate(pending_shots):
                shot_id = shot['shot_id']
                ff_prompt = shot.get('visual_prompt', '')
                first_frame_prompts[shot_id] = ff_prompt
                logger.info(f"[{shot_id}] first-frame prompt: {ff_prompt[:80]}...")
                step = i * steps_per_shot + 1
                self._report_progress("参考图", f"准备提示词: {shot_id}", calc_pct(step))

            # 步骤7+(每分镜3步)：并发生成图像
            self._report_progress("参考图", "生成参考图...", calc_pct(total * 2))
            tasks = []
            for shot in pending_shots:
                shot_id = shot['shot_id']
                refs = self._collect_refs(shot, asset_map, char_id_map, setting_id_map)
                char_desc, set_desc = self._get_descriptions(
                    shot, char_id_map, setting_id_map, script_json
                )
                tasks.append((shot, first_frame_prompts[shot_id], refs, char_desc, set_desc))

            with ThreadPoolExecutor(max_workers=concurrency) as executor:
                futs = {}
                for shot, ff_prompt, refs, char_desc, set_desc in tasks:
                    shot_id = shot['shot_id']
                    fut = executor.submit(
                        self._generate_one, img_client, sid,
                        shot, ff_prompt, refs,
                        style, it2i, t2i, ref_size, vlm_model,
                        character_description=char_desc, setting_description=set_desc
                    )
                    futs[fut] = shot_id
                cancelled = False
                for fut in as_completed(futs):
                    shot_id_done = futs[fut]
                    try:
                        _, result_path, eval_result = fut.result()
                    except Exception as e:
                        logger.error(f"Image future error for {shot_id_done}: {e}")
                        result_path = None
                    done += 1
                    # 每个分镜完成时更新进度
                    step = done * steps_per_shot
                    pct = calc_pct(step)
                    if result_path:
                        versions = self._list_versions(sid, shot_id_done)
                        self._report_progress("参考图", f"完成: {shot_id_done}", pct, data={
                            "asset_complete": {
                                "type": "scenes", "id": shot_id_done,
                                "status": "done",
                                "selected": result_path,
                                "versions": versions,
                            }
                        })
                    else:
                        self._report_progress("参考图", f"失败: {shot_id_done}", pct, data={
                            "asset_complete": {
                                "type": "scenes", "id": shot_id_done,
                                "status": "failed",
                                "selected": "", "versions": [],
                            }
                        })
                    # 检查取消
                    if self.cancellation_check and self.cancellation_check():
                        logger.info("ReferenceGeneratorAgent: 用户取消，停止等待剩余任务")
                        for f in futs:
                            if not f.done():
                                f.cancel()
                        cancelled = True
                        break

            if cancelled:
                self._report_progress("参考图", "已取消（保留已完成图片）", 96)
            else:
                self._report_progress("参考图", "保存结果...", 96)

            # 写回结果文件
            self._update_scene2image(sid, shots, result_file, first_frame_prompts)

        loop = asyncio.get_running_loop()
        try:
            await loop.run_in_executor(None, run)
        except Exception as e:
            if "cancel" in str(e).lower():
                logger.info("ReferenceGeneratorAgent: 用户取消，返回已完成���部分结果")
                self._report_progress("参考图", "已取消（保留已完成图片）", 100)
                return self._build_payload(sid, shots)
            raise

        self._report_progress("参考图", "完成", 100)
        return self._build_payload(sid, shots)

# -*- coding: utf-8 -*-
"""
阶段1: 编剧智能体 - 多轮LLM交互生成结构化剧本JSON
流程: Logline → 节拍表(4幕) → 分场大纲(逐幕) → JSON结构化提取(带校验重试)
"""

import os
import re
import json
import asyncio
import logging
import string
import random
from datetime import datetime, timezone
from typing import Any, Optional, Dict

from .base_agent import AgentInterface

# 导入提示词加载器
from prompts.loader import load_prompt

logger = logging.getLogger(__name__)


# 懒加载提示词 - 优先从外部文件加载，失败则返回空
def _p(category: str, name: str, lang: str = 'zh') -> str:
    """Load prompt from external file, return empty string if not found"""
    try:
        return load_prompt(category, name, lang)
    except FileNotFoundError:
        return ""


# 从外部文件加载提示词的辅助函数
def _load_prompt(category: str, name: str, fallback: str) -> str:
    """Load prompt from external file, fallback to hardcoded string"""
    try:
        return load_prompt(category, name, 'zh')
    except FileNotFoundError:
        return fallback

# =============================================================
#  Phase 1A: Logline 生成（扩写创意 → 3 个 Logline 方案）
# =============================================================

LOGLINE_GENERATE_PROMPT_ZH = (
    "你是资深制片人。请将以下灵感扩展为 3 个不同的 Logline（故事大纲）。\n"
    "要求：\n"
    "- 明确主角（Who）、目标（Goal）、核心障碍（Conflict）和反转（Twist）\n"
    "- 确定故事的 Theme（潜在主题）\n"
    "- Logline 按照\"如果…会怎样\"的句式描述\n"
    "- 3 个 Logline 应风格各异、各有侧重\n\n"
    "输入内容：{idea}\n\n"
    "请严格按如下 JSON 数组格式输出（直接输出纯JSON，不要用```包裹，不要添加任何其他文字）：\n"
    '[{{"logline":"如果...会怎样","who":"主角描述","goal":"目标","conflict":"核心障碍","twist":"反转","theme":"潜在主题"}}]\n'
    "输出恰好 3 个元素的 JSON 数组。"
)

LOGLINE_GENERATE_PROMPT_EN = (
    "You are a senior producer. Expand the following idea into 3 different Loglines.\n"
    "Requirements:\n"
    "- Define the protagonist (Who), Goal, core Conflict, and Twist\n"
    "- Identify the story's Theme\n"
    "- Each Logline should use 'What if...' format\n"
    "- The 3 Loglines should be diverse in style and focus\n\n"
    "Input: {idea}\n\n"
    "Output ONLY a JSON array with exactly 3 elements (no code block markers, no other text):\n"
    '[{{"logline":"What if...","who":"protagonist","goal":"goal","conflict":"conflict","twist":"twist","theme":"theme"}}]'
)

# =============================================================
#  Phase 1B: Logline 检测 & 提取（未勾选扩写时）
# =============================================================

LOGLINE_CHECK_PROMPT_ZH = (
    "请判断以下文本是否包含足够的叙事要素，能够从中总结出一个完整故事的 Logline。\n"
    "（完整 Logline 需涵盖：主角、目标、核心障碍、反转和主题）\n\n"
    "文本：{idea}\n\n"
    "只回答 Yes 或 No，不要添加任何其他内容。"
)

LOGLINE_CHECK_PROMPT_EN = (
    "Determine if the following text contains enough narrative elements for a complete story Logline.\n"
    "(Needs: protagonist, goal, conflict, twist, and theme)\n\n"
    "Text: {idea}\n\n"
    "Answer only Yes or No."
)

LOGLINE_EXTRACT_PROMPT_ZH = (
    "你是资深制片人。请从以下文本中总结提取 Logline 及故事五要素。\n"
    "Logline 请使用\"如果…会怎样\"的句式。\n\n"
    "文本：{idea}\n\n"
    "请严格按如下 JSON 格式输出（直接输出纯JSON，不要用```包裹，不要添加任何其他文字）：\n"
    '{{"logline":"如果...会怎样","who":"主角描述","goal":"目标","conflict":"核心障碍","twist":"反转","theme":"潜在主题"}}'
)

LOGLINE_EXTRACT_PROMPT_EN = (
    "You are a senior producer. Extract the Logline and five story elements from the following text.\n"
    "The Logline should use 'What if...' format.\n\n"
    "Text: {idea}\n\n"
    "Output ONLY valid JSON (no code block markers, no other text):\n"
    '{{"logline":"What if...","who":"protagonist","goal":"goal","conflict":"conflict","twist":"twist","theme":"theme"}}'
)

# =============================================================
#  Phase 2A: 节拍表 (Save the Cat! Beat Sheet)
# =============================================================

BEAT_SHEET_PROMPT_ZH = (
    "你是好莱坞编剧导师。请根据以下故事线，使用 Save the Cat! 节拍表将故事拆解为四幕结构。\n\n"
    "必须包含以下四个关键节拍（起承转合）：\n"
    "第一幕 - 激励事件（Inciting Incident）：建立世界观和主角现状，发生打破平衡的事件\n"
    "第二幕 - 进入新世界（Break into Two）：主角踏上旅程，面对挑战和考验，副线展开\n"
    "第三幕 - 灵魂黑夜（Dark Night of the Soul）：主角遭受最大打击，陷入低谷\n"
    "第四幕 - 高潮决战（Finale）：主角获得顿悟，最终决战，故事收束\n\n"
    "请确保：逻辑严密、冲突逐步升级、每一幕有清晰的转折点。\n\n"
    "故事线：\n{draft}\n\n"
    "故事风格：{style}\n\n"
    "请直接输出四幕节拍表，每一幕用\"【第X幕 - 名称】\"标记开始，详细描述该幕的情节要点、角色发展和关键转折。"
)

BEAT_SHEET_PROMPT_EN = (
    "You are a Hollywood screenwriting mentor. Break down the following storyline into a 4-act structure "
    "using the Save the Cat! Beat Sheet.\n\n"
    "Must include these four key beats:\n"
    "Act 1 - Inciting Incident: Establish the world and protagonist's status quo, then a disruptive event\n"
    "Act 2 - Break into Two: Protagonist embarks on journey, faces challenges, B-story unfolds\n"
    "Act 3 - Dark Night of the Soul: Protagonist suffers the biggest blow, hits rock bottom\n"
    "Act 4 - Finale: Protagonist gains epiphany, final confrontation, story resolves\n\n"
    "Ensure: tight logic, escalating conflict, clear turning points in each act.\n\n"
    "Storyline:\n{draft}\n\n"
    "Story style: {style}\n\n"
    "Output the 4-act beat sheet directly. Start each act with '[Act X - Name]' heading. "
    "Detail the plot points, character development and key turning points for each act."
)

# =============================================================
#  Phase 2B: 分场大纲 (Step Outline, 逐幕生成)
# =============================================================

STEP_OUTLINE_PROMPT_ZH = (
    "你是分场导演。以下是完整的四幕节拍表：\n\n"
    "{beat_sheet}\n\n"
    "请将第{act_number}幕（{act_name}）转化为详细的分场大纲。\n\n"
    "格式要求（每场一段）：\n"
    "[场次编号]. [地点(室内/室外)] - [日/夜]\n"
    "[核心动作]：详细描述该场戏发生了什么，包含完整的对话、动作和表情描写。\n"
    "[情感转变]：描述主角在本场戏开始到结束的情绪变化（+/-）。\n"
    "[出场角色]：列出本场出现的所有角色。\n\n"
    "要求：\n"
    "- 每个角色都要有详细的外貌描写（发型、眼睛颜色、体型、服装颜色和款式等视觉特征）\n"
    "- **重要：外貌描写必须是静态的、贯穿全剧保持一致的特征，不要随剧情发展而变化**\n"
    "  - 例如：不要写\"他穿着破碎的衣服\"这种随情节变化的描写\n"
    "  - 应该写：\"他身穿蓝色衬衫，黑色长裤\"这种固定的服装描述\n"
    "- 每个场景都要有详细的环境、布局、色彩与氛围描写\n"
    "- 分场数量根据情节长度和节奏自行决定，确保叙事节奏合理\n"
    "- 对话用双引号标注，对话内容真实生动\n"
    "- 场次编号从 {scene_start} 开始递增\n"
    "- 故事风格：{style}\n\n"
    "请直接输出分场大纲，不要添加幕次标题或额外说明。"
)

STEP_OUTLINE_PROMPT_EN = (
    "You are a scene director. Here is the complete 4-act beat sheet:\n\n"
    "{beat_sheet}\n\n"
    "Convert Act {act_number} ({act_name}) into a detailed step outline.\n\n"
    "Format for each scene:\n"
    "[Scene number]. [Location (Indoor/Outdoor)] - [Day/Night]\n"
    "[Core Action]: Detailed description of what happens, including dialogue, actions and expressions.\n"
    "[Emotional Shift]: Describe the protagonist's emotional change from start to end (+/-).\n"
    "[Characters Present]: List all characters appearing in this scene.\n\n"
    "Requirements:\n"
    "- Each character needs detailed physical descriptions (hair, eyes, build, clothing details)\n"
    "- **IMPORTANT: Physical descriptions must be STATIC and consistent throughout the entire story - do NOT change with plot development**\n"
    "  - For example: do NOT write \"wearing torn clothes\" which changes with the plot\n"
    "  - Instead write: \"wearing a blue shirt and black pants\" which is a fixed clothing description\n"
    "- Each scene needs detailed environment, layout, color and atmosphere descriptions\n"
    "- Number of scenes based on plot length and pacing\n"
    "- Dialogue marked with double quotes, natural and vivid\n"
    "- Scene numbers start from {scene_start} and increment\n"
    "- Story style: {style}\n\n"
    "Output the step outline directly, without act headings or extra notes."
)

ACT_NAMES_ZH = {1: "激励事件", 2: "进入新世界", 3: "灵魂黑夜", 4: "高潮决战"}
ACT_NAMES_EN = {1: "Inciting Incident", 2: "Break into Two", 3: "Dark Night of the Soul", 4: "Finale"}

# =============================================================
#  Micro-film 微电影模式专用提示词
# =============================================================

MICRO_BEAT_SHEET_PROMPT_ZH = (
    "你是微电影编剧专家。请根据以下故事线，将故事压缩为一个紧凑的单幕剧情概要。\n\n"
    "要求：\n"
    "- 叙事节奏快，情节紧凑精炼，没有拖沓的铺垫\n"
    "- 全部内容在一幕内完成，不分幕\n"
    "- 保留核心冲突和情感转折，去掉多余叙事\n"
    "- 场景数量控制在 3-6 场\n"
    "- 适合 1-3 分钟的微电影\n\n"
    "故事线：\n{draft}\n\n"
    "故事风格：{style}\n\n"
    "请直接输出紧凑的剧情概要，描述场景发展、核心动作和情感转折。"
)

MICRO_BEAT_SHEET_PROMPT_EN = (
    "You are a micro-film screenwriting expert. Compress the following storyline "
    "into a compact single-act plot summary.\n\n"
    "Requirements:\n"
    "- Fast narrative pacing, concise and tight plot\n"
    "- All content in a single act, no act divisions\n"
    "- Keep core conflict and emotional turns, remove unnecessary setup\n"
    "- 3-6 scenes total\n"
    "- Suitable for a 1-3 minute short film\n\n"
    "Storyline:\n{draft}\n\n"
    "Story style: {style}\n\n"
    "Output a compact plot summary directly, describing scene progression, "
    "core actions and emotional shifts."
)

MICRO_STEP_OUTLINE_PROMPT_ZH = (
    "你是分场导演。以下是微电影剧情概要：\n\n"
    "{beat_sheet}\n\n"
    "请将其转化为详细的分场大纲。\n\n"
    "格式要求（每场一段）：\n"
    "[场次编号]. [地点(室内/室外)] - [日/夜]\n"
    "[核心动作]：详细描述该场戏发生了什么，包含完整的对话、动作和表情描写。\n"
    "[情感转变]：描述主角在本场戏开始到结束的情绪变化（+/-）。\n"
    "[出场角色]：列出本场出现的所有角色。\n\n"
    "要求：\n"
    "- 每个角色都要有详细的外貌描写（发型、眼睛颜色、体型、服装颜色和款式等视觉特征）\n"
    "- **重要：外貌描写必须是静态的、贯穿全剧保持一致的特征，不要随剧情发展而变化**\n"
    "  - 例如：不要写\"他穿着破碎的衣服\"这种随情节变化的描写\n"
    "  - 应该写：\"他身穿蓝色衬衫，黑色长裤\"这种固定的服装描述\n"
    "- 每个场景都要有详细的环境、布局、色彩与氛围描写\n"
    "- 分场数量 3-6 场，叙事紧凑快节奏\n"
    "- 对话用双引号标注，对话内容真实生动\n"
    "- 场次编号从 1 开始递增\n"
    "- 故事风格：{style}\n\n"
    "请直接输出分场大纲，不要添加额外说明。"
)

MICRO_STEP_OUTLINE_PROMPT_EN = (
    "You are a scene director. Here is the micro-film plot summary:\n\n"
    "{beat_sheet}\n\n"
    "Convert it into a detailed step outline.\n\n"
    "Format for each scene:\n"
    "[Scene number]. [Location (Indoor/Outdoor)] - [Day/Night]\n"
    "[Core Action]: Detailed description including dialogue, actions and expressions.\n"
    "[Emotional Shift]: Protagonist's emotional change from start to end (+/-).\n"
    "[Characters Present]: All characters appearing in this scene.\n\n"
    "Requirements:\n"
    "- Each character needs detailed physical descriptions (hair, eyes, build, clothing)\n"
    "- **IMPORTANT: Physical descriptions must be STATIC and consistent throughout the entire story - do NOT change with plot development**\n"
    "  - For example: do NOT write \"wearing torn clothes\" which changes with the plot\n"
    "  - Instead write: \"wearing a blue shirt and black pants\" which is a fixed clothing description\n"
    "- Each scene needs detailed environment, layout, color and atmosphere descriptions\n"
    "- 3-6 scenes total, compact and fast-paced\n"
    "- Dialogue marked with double quotes, natural and vivid\n"
    "- Scene numbers start from 1 and increment\n"
    "- Story style: {style}\n\n"
    "Output the step outline directly, without extra notes."
)

MICRO_META_EXTRACT_PROMPT_ZH = (
    "你是专业的剧本分析师。以下是微电影剧情概要：\n\n"
    "{beat_sheet}\n\n"
    "请从中提取以下信息，以纯JSON格式输出（不要用```包裹）：\n"
    '{{"title":"故事标题(2-8字)","logline":"一句话概括故事(30字以内)",'
    '"genre":["类型1","类型2"],"synopsis":"完整故事梗概(50-100字)",'
    '"mood":"影片情绪基调"}}'
)

MICRO_META_EXTRACT_PROMPT_EN = (
    "You are a professional script analyst. Here is the micro-film plot summary:\n\n"
    "{beat_sheet}\n\n"
    "Extract the following information as pure JSON (no code blocks):\n"
    '{{"title":"Story title (short)","logline":"One sentence summary",'
    '"genre":["genre1","genre2"],"synopsis":"Complete synopsis (50-100 words)",'
    '"mood":"Overall mood"}}'
)

# =============================================================
#  Phase 3A: 单幕结构化 JSON 提取
# =============================================================

ACT_EXTRACT_INTRO_ZH = (
    "你是一个专业的剧本分析师。请仔细阅读以下第{act_number}幕的分场大纲，从中提取并整理为标准JSON格式。\n\n"
    "分场大纲：\n{outline}\n\n"
    "请严格按照以下JSON结构输出（直接输出纯JSON，不要用```包裹，不要添加注释或任何其他文字）：\n\n"
)

ACT_EXTRACT_INTRO_EN = (
    "You are a professional script analyst. Read the following Act {act_number} step outline carefully "
    "and extract it into a structured JSON format.\n\n"
    "Step outline:\n{outline}\n\n"
    "Output ONLY valid JSON in the following structure (no code block markers, no comments, no other text):\n\n"
)

ACT_EXTRACT_SCHEMA_ZH = """{{
  "characters": [
    {{
      "name": "角色全名",
      "character_id": "char_加8位随机字母数字",
      "description": "外貌描写: 含发型、体型、服装颜色和款式等视觉特征, 不要描述眼睛颜色, 面部不要有文字等特殊符号, 形象要正常(可以前卫时髦但不能恐怖灵异), 50-80字, 不要用比喻",
      "personality": ["性格特征1", "性格特征2", "性格特征3"],
      "motivation": "角色核心动机",
      "arc_description": "角色成长弧线",
      "role": "主角 或 配角 或 背景",
      "age": "年龄",
      "species": "人类 或 具体动物种类"
    }}
  ],
  "settings": [
    {{
      "name": "场景名称(室内) 或 场景名称(室外)",
      "setting_id": "set_加8位随机字母数字",
      "description": "环境布局、色彩、光线、氛围等视觉细节, 80-120字, 不要包含人物或动物"
    }}
  ],
  "scenes": [
    {{
      "scene_number": {scene_start},
      "act": {act_number},
      "location": "必须是settings中已定义的场景名称",
      "characters": ["出场角色名(必须与characters中的name一致)"],
      "plot": "该场景完整详细的剧情, 含对话、动作和表情描写, 必须完整表达分场内容, 无字数限制"
    }}
  ]
}}"""

ACT_EXTRACT_SCHEMA_EN = """{{
  "characters": [
    {{
      "name": "Full name",
      "character_id": "char_ plus 8 random alphanumeric",
      "description": "Visual description: hair, eyes, build, clothing details, 50-80 words",
      "personality": ["trait1", "trait2", "trait3"],
      "motivation": "Core motivation",
      "arc_description": "Character growth arc",
      "role": "protagonist or supporting or background",
      "age": "age",
      "species": "human or specific animal"
    }}
  ],
  "settings": [
    {{
      "name": "Location name (Indoor) or Location name (Outdoor)",
      "setting_id": "set_ plus 8 random alphanumeric",
      "description": "Layout, colors, lighting, atmosphere details, 80-120 words, no people or animals"
    }}
  ],
  "scenes": [
    {{
      "scene_number": {scene_start},
      "act": {act_number},
      "location": "Must be a name defined in settings",
      "characters": ["character names matching characters array"],
      "plot": "Complete detailed scene plot with dialogue, actions and expressions, no word limit"
    }}
  ]
}}"""

ACT_EXTRACT_RULES_ZH = (
    "\n\n重要规则：\n"
    "1. characters中的name必须与scenes中的角色名完全一致\n"
    "2. scenes中的location必须是settings中已定义的场景名称之一\n"
    "3. settings的name需标注(室内)或(室外)\n"
    "4. 所有scene的act字段必须为{act_number}\n"
    "5. scene_number从{scene_start}开始递增\n"
    "6. 角色的description要有足够视觉细节用于AI图像生成\n"
    "7. setting的description要有足够视觉细节用于AI背景图生成\n"
    "8. 不要生成群体角色(如\"邻居们\")，每个角色都是独立个体\n"
    "9. scene的plot字段必须完整表达该分场的全部内容\n"
    "10. 只输出纯JSON\n"
)

ACT_EXTRACT_RULES_EN = (
    "\n\nImportant rules:\n"
    "1. Character names in scenes must exactly match names in characters array\n"
    "2. Scene locations must be names defined in settings array\n"
    "3. Setting names must include (Indoor) or (Outdoor)\n"
    "4. All scenes' act field must be {act_number}\n"
    "5. scene_number starts from {scene_start} and increments\n"
    "6. Character descriptions need enough visual detail for AI image generation\n"
    "7. Setting descriptions need enough visual detail for AI background generation\n"
    "8. No group characters, every character is an individual\n"
    "9. Scene 'plot' field must fully express all content, do not truncate\n"
    "10. Output ONLY the JSON\n"
)

# =============================================================
#  Phase 3B: 最终合并补充提示词（生成 title / logline / synopsis 等顶层字段）
# =============================================================

META_EXTRACT_PROMPT_ZH = (
    "你是专业的剧本分析师。以下是完整的四幕节拍表：\n\n"
    "{beat_sheet}\n\n"
    "请从中提取以下信息，以纯JSON格式输出（不要用```包裹）：\n"
    '{{"title":"故事标题(2-8字)","logline":"一句话概括故事(30字以内)",'
    '"genre":["类型1","类型2"],"synopsis":"完整故事梗概(100-200字)",'
    '"mood":"影片情绪基调"}}'
)

META_EXTRACT_PROMPT_EN = (
    "You are a professional script analyst. Here is the complete 4-act beat sheet:\n\n"
    "{beat_sheet}\n\n"
    "Extract the following information as pure JSON (no code blocks):\n"
    '{{"title":"Story title (short)","logline":"One sentence summary",'
    '"genre":["genre1","genre2"],"synopsis":"Complete synopsis (100-200 words)",'
    '"mood":"Overall mood"}}'
)

# =============================================================
#  Phase 4: 场景 & 角色合并（去重相似条目）
# =============================================================

CONSOLIDATE_PROMPT_ZH = (
    "你是剧本审校专家。请审查以下剧本中的场景列表和角色列表，找出可以合并的条目。\n\n"
    "合并规则：\n"
    "- 场景合并：如果两个场景在物理空间上是同一个地点（只是拍摄角度、景别不同），应合并为一个\n"
    "  例如：「车厢内」「车厢过道」「车厢全景」都是同一节车厢 → 合并为「车厢内」\n"
    "  例如：「咖啡馆吧台」「咖啡馆角落」→ 合并为「咖啡馆」\n"
    "  注意：不同物理空间不能合并（如「车厢内」和「车厢连接处」是不同空间）\n"
    "- 角色合并：如果同名角色出现多次（可能描述略有不同），合并为一个\n"
    "- 合并后保留最详细的描述\n\n"
    "当前场景列表：\n{settings_json}\n\n"
    "当前角色列表：\n{characters_json}\n\n"
    "请输出纯JSON（不要用```包裹），格式如下：\n"
    '{{\n'
    '  "setting_merges": {{"被合并的场景名": "合并到的目标场景名", ...}},\n'
    '  "character_merges": {{"被合并的角色名": "合并到的目标角色名", ...}}\n'
    '}}\n\n'
    "如果没有需要合并的条目，对应字段返回空对象 {{}}。\n"
    "只输出纯JSON，不要添加任何其他文字。"
)

CONSOLIDATE_PROMPT_EN = (
    "You are a script review expert. Review the following settings and characters lists "
    "and identify entries that should be merged.\n\n"
    "Merge rules:\n"
    "- Settings merge: If two settings are the same physical location (just different camera angles), "
    "merge them into one. E.g., 'Train interior', 'Train aisle', 'Train panorama' are all the same car.\n"
    "  Different physical spaces should NOT be merged.\n"
    "- Character merge: If the same character appears with slightly different descriptions, merge them.\n"
    "- Keep the most detailed description after merging.\n\n"
    "Current settings:\n{settings_json}\n\n"
    "Current characters:\n{characters_json}\n\n"
    "Output ONLY valid JSON (no code blocks):\n"
    '{{\n'
    '  "setting_merges": {{"merged_setting_name": "target_setting_name", ...}},\n'
    '  "character_merges": {{"merged_char_name": "target_char_name", ...}}\n'
    '}}\n\n'
    "If nothing to merge, return empty objects {{}}. Output ONLY the JSON."
)

class ScriptWriterAgent(AgentInterface):
    """编剧智能体：多轮LLM交互 → 结构化剧本JSON"""

    def __init__(self):
        super().__init__(name="ScriptWriter")

    # ─── JSON 提取 ───

    @staticmethod
    def _extract_json_from_text(text: str) -> Optional[dict]:
        """从LLM输出中提取JSON对象"""
        text = text.strip()
        text = re.sub(r'^```(?:json)?\s*', '', text)
        text = re.sub(r'\s*```$', '', text)
        text = text.strip()

        try:
            return json.loads(text)
        except json.JSONDecodeError:
            pass

        start = text.find('{')
        end = text.rfind('}')
        if start != -1 and end != -1 and end > start:
            try:
                return json.loads(text[start:end + 1])
            except json.JSONDecodeError:
                pass
        return None

    @staticmethod
    def _extract_json_array_from_text(text: str) -> Optional[list]:
        """从LLM输出中提取JSON数组"""
        text = text.strip()
        # 去除 markdown 代码块标记（支持多行）
        text = re.sub(r'```(?:json)?\s*\n?', '', text)
        text = text.strip()

        try:
            result = json.loads(text)
            if isinstance(result, list):
                return result
            # LLM 有时返回对象而非数组，尝试包装
            if isinstance(result, dict):
                return [result]
        except json.JSONDecodeError:
            pass

        start = text.find('[')
        end = text.rfind(']')
        if start != -1 and end != -1 and end > start:
            try:
                result = json.loads(text[start:end + 1])
                if isinstance(result, list):
                    return result
            except json.JSONDecodeError:
                pass

        # 尝试匹配多个独立 JSON 对象
        objects = []
        for m in re.finditer(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', text):
            try:
                obj = json.loads(m.group())
                if isinstance(obj, dict) and 'logline' in obj:
                    objects.append(obj)
            except json.JSONDecodeError:
                continue
        if objects:
            return objects

        return None

    @staticmethod
    def _gen_id(prefix: str = "char") -> str:
        return f"{prefix}_{''.join(random.choices(string.ascii_lowercase + string.digits, k=8))}"

    # ─── 保存结果 ───

    def _save_result(self, json_data: dict, sid: str, is_zh: bool):
        """保存结构化剧本JSON到结果文件"""
        from config import settings
        script_dir = os.path.join(settings.RESULT_DIR, 'script')
        os.makedirs(script_dir, exist_ok=True)

        result_file = os.path.join(script_dir, f'script_{sid}.json')
        results = {}
        if os.path.exists(result_file) and os.path.getsize(result_file) > 0:
            with open(result_file, 'r', encoding='utf-8') as f:
                results = json.load(f)

        results.setdefault(str(sid), {})['script_json'] = json_data
        with open(result_file, 'w', encoding='utf-8') as f:
            json.dump(results, f, indent=4, ensure_ascii=False)

    def _save_progress(self, sid: str, phase: str, data: dict):
        """保存剧本生成的中间进度状态到结果文件"""
        from config import settings
        script_dir = os.path.join(settings.RESULT_DIR, 'script')
        os.makedirs(script_dir, exist_ok=True)

        result_file = os.path.join(script_dir, f'script_{sid}.json')
        results = {}
        if os.path.exists(result_file) and os.path.getsize(result_file) > 0:
            with open(result_file, 'r', encoding='utf-8') as f:
                results = json.load(f)

        # 初始化 progress 字段
        results.setdefault(str(sid), {}).setdefault('progress', {})

        # 保存当前阶段信息
        results[str(sid)]['progress']['current_phase'] = phase
        results[str(sid)]['progress']['updated_at'] = datetime.now(timezone.utc).isoformat()

        # 根据阶段保存对应的数据
        if phase == 'logline_check':
            # 创意检查结果
            results[str(sid)]['progress']['idea_analyzed'] = data.get('idea_analyzed', False)
            results[str(sid)]['progress']['logline_extracted'] = data.get('logline_summary')
        elif phase == 'logline_generation':
            # 生成的候选 logline
            results[str(sid)]['progress']['logline_options'] = data.get('logline_options', [])
        elif phase == 'logline_confirmed':
            # 用户选择的 logline
            results[str(sid)]['progress']['selected_logline'] = data.get('selected_logline')
        elif phase == 'mode_selection':
            # 用户选择的模式
            results[str(sid)]['progress']['selected_mode'] = data.get('selected_mode')
        elif phase == 'script_generation':
            # 完整剧本已生成
            results[str(sid)]['progress']['script_generated'] = True
            results[str(sid)]['progress']['title'] = data.get('title')

        with open(result_file, 'w', encoding='utf-8') as f:
            json.dump(results, f, indent=4, ensure_ascii=False)

    # ─── 核心流程 ───

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:

        # 检查当前阶段，避免重复生成 logline
        current_phase = input_data.get("phase", "")
        selected_logline = input_data.get("selected_logline")
        selected_mode = input_data.get("selected_mode")

        # 如果已选择模式，直接生成剧本
        if selected_mode:
            # 如果 selected_logline 是索引（数字），需要转换为 logline 对象
            if isinstance(selected_logline, int):
                logline_options = input_data.get("logline_options", [])
                if 0 <= selected_logline < len(logline_options):
                    logline_data = logline_options[selected_logline]
                else:
                    logline_data = {}
            else:
                logline_data = selected_logline if isinstance(selected_logline, dict) else {}

            if selected_mode == "micro":
                return await self._phase_micro_script_gen(input_data, logline_data)
            else:
                return await self._phase_script_gen(input_data, logline_data)

        # 如果已选择 logline 但未选择模式，返回模式选择
        if selected_logline and current_phase == "mode_selection":
            return {
                "payload": {
                    "phase": "mode_selection",
                    "selected_logline": selected_logline,
                    "session_id": input_data.get("session_id", ""),
                },
                "requires_intervention": True,
                "openclaw_hint": "用户已选择情节，需要选择拍摄模式(电影模式4幕/微电影模式1幕)。请展示给用户并等待用户选择。",
            }

        # (A) 用户介入修改最终剧本
        if intervention and "modified_script" in intervention:
            modified = intervention["modified_script"]
            sid = input_data.get("session_id", "")
            if isinstance(modified, str):
                modified = self._extract_json_from_text(modified) or {}
            is_zh = any('\u4e00' <= c <= '\u9fff' for c in modified.get("title", ""))
            modified["session_id"] = sid
            self._save_result(modified, sid, is_zh)
            return {"payload": modified, "requires_intervention": False, "stage_completed": True}

        # (B1) 用户选择了创作模式 → 根据模式生成剧本
        if intervention and "selected_mode" in intervention:
            selected = input_data.get("selected_logline", {})
            mode = intervention["selected_mode"]
            sid = input_data.get("session_id", "")

            # 如果 selected_logline 是索引（数字），转换为对应的 logline 对象
            if isinstance(selected, int):
                logline_options = input_data.get("logline_options", [])
                if 0 <= selected < len(logline_options):
                    logline_data = logline_options[selected]
                else:
                    logline_data = {}
            else:
                logline_data = selected if isinstance(selected, dict) else {}

            # 保存进度状态
            self._save_progress(sid, "mode_selection", {
                "selected_mode": mode
            })

            if mode == "micro":
                return await self._phase_micro_script_gen(input_data, logline_data)
            else:
                return await self._phase_script_gen(input_data, logline_data)

        # (B2) 用户选择了一个 Logline → 显示模式选择
        if intervention and "selected_logline" in intervention:
            selected = intervention["selected_logline"]
            sid = input_data.get("session_id", "")

            # 如果 selected_logline 是索引（数字），转换为对应的 logline 对象
            if isinstance(selected, int):
                logline_options = input_data.get("logline_options", [])
                if 0 <= selected < len(logline_options):
                    logline_data = logline_options[selected]
                else:
                    logline_data = {}
            else:
                logline_data = selected if isinstance(selected, dict) else {}

            # 保存进度状态
            self._save_progress(sid, "logline_confirmed", {
                "selected_logline": logline_data
            })

            return {
                "payload": {
                    "phase": "mode_selection",
                    "selected_logline": logline_data,
                    "session_id": sid,
                },
                "requires_intervention": True,
                "openclaw_hint": "用户已选择情节，需要选择拍摄模式(电影模式4幕/微电影模式1幕)。请展示给用户并等待用户选择。",
            }

        # 首次运行：自动判断是直接提取 logline 还是进入扩写
        auto_mode = input_data.get("auto_mode", False)

        # 代理（自动）模式：跳过 Logline 选择，直接生成剧本
        if auto_mode:
            return await self._phase_direct(input_data)

        # 自动判断：创意足够则提取 logline，否则自动扩写生成 3 个选项
        return await self._phase_logline_check(input_data)

    # ─── Phase 1A: 生成 3 个 Logline 方案 ───

    async def _phase_logline_gen(self, input_data: Dict) -> Dict:
        idea = input_data.get("idea", "")
        sid = input_data.get("session_id", "")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")
        web_search = input_data.get("web_search", False)
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in idea)

        def run():
            from tool.llm_client import LLM
            llm = LLM()
            self._report_progress("剧本生成", "正在生成 Logline 方案...", 5)
            prompt = (LOGLINE_GENERATE_PROMPT_ZH if is_zh else LOGLINE_GENERATE_PROMPT_EN).format(idea=idea)

            for attempt in range(3):
                self._check_cancel()
                raw = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid, web_search=web_search)
                logger.info(f"[ScriptWriter] Logline gen attempt {attempt + 1}, raw output ({len(raw)} chars): {raw[:500]}")
                options = self._extract_json_array_from_text(raw)
                if options and len(options) > 0:
                    # 确保每个选项包含必要字段
                    required = {"logline", "who", "goal", "conflict", "twist", "theme"}
                    valid = [o for o in options if isinstance(o, dict) and required.issubset(o.keys())]
                    if valid:
                        self._report_progress("剧本生成", "Logline 方案已生成", 20)
                        return valid[:3]

                logger.warning(f"[ScriptWriter] Logline gen attempt {attempt + 1}: parse failed")
                if is_zh:
                    prompt = (
                        "上次输出格式不正确，请严格按要求重新输出。"
                        "必须输出纯JSON数组，不要用```包裹，不要有任何多余文字。\n\n"
                        + (LOGLINE_GENERATE_PROMPT_ZH).format(idea=idea)
                    )
                else:
                    prompt = (
                        "Previous output format was incorrect. Please try again. "
                        "Output ONLY a raw JSON array, no code blocks, no extra text.\n\n"
                        + (LOGLINE_GENERATE_PROMPT_EN).format(idea=idea)
                    )

            raise Exception("Logline 生成失败：多次尝试均无法解析输出")

        loop = asyncio.get_running_loop()
        options = await loop.run_in_executor(None, run)

        # 保存进度状态
        self._save_progress(sid, "logline_generation", {
            "logline_options": options
        })

        return {
            "payload": {
                "phase": "logline_selection",
                "logline_options": options,
                "session_id": sid,
            },
            "requires_intervention": True,
            "openclaw_hint": "生成了多个情节候选(logline)，需要用户选择。请展示给用户并等待用户选择。",
        }

    # ─── Phase 1B: 检测输入是否可提取 Logline ───

    async def _phase_logline_check(self, input_data: Dict) -> Dict:
        idea = input_data.get("idea", "")
        sid = input_data.get("session_id", "")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")
        web_search = input_data.get("web_search", False)
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in idea)

        def run():
            from tool.llm_client import LLM
            llm = LLM()
            self._report_progress("剧本生成", "分析创意文本...", 5)
            check_prompt = (LOGLINE_CHECK_PROMPT_ZH if is_zh else LOGLINE_CHECK_PROMPT_EN).format(idea=idea)
            answer = self._cancellable_query(llm, check_prompt, model=llm_model, task_id=sid, web_search=web_search).strip()

            if answer.lower().startswith("yes"):
                self._report_progress("剧本生成", "提取 Logline...", 10)
                extract_prompt = (LOGLINE_EXTRACT_PROMPT_ZH if is_zh else LOGLINE_EXTRACT_PROMPT_EN).format(idea=idea)
                raw = self._cancellable_query(llm, extract_prompt, model=llm_model, task_id=sid, web_search=web_search)
                logger.info(f"[ScriptWriter] Logline extract raw ({len(raw)} chars): {raw[:500]}")
                logline_data = self._extract_json_from_text(raw)
                if logline_data and isinstance(logline_data, dict) and 'logline' in logline_data:
                    self._report_progress("剧本生成", "Logline 提取完成", 20)
                    return {"phase": "logline_confirm", "logline_summary": logline_data}

            return {"phase": "suggest_expand"}

        loop = asyncio.get_running_loop()
        result = await loop.run_in_executor(None, run)
        result["session_id"] = sid

        # 如果创意不够，自动进入扩写阶段，生成 3 个 logline 供选择
        if result.get("phase") == "suggest_expand":
            return await self._phase_logline_gen(input_data)

        # 保存进度状态
        phase = result.get("phase", "logline_check")
        self._save_progress(sid, "logline_check", {
            "idea_analyzed": phase == "logline_confirm",
            "logline_summary": result.get("logline_summary")
        })

        return {
            "payload": result,
            "requires_intervention": True,
            "openclaw_hint": "已提取情节概要，需要用户确认。请展示给用户并等待用户确认。",
        }

    # ─── Phase 2: 根据选定 Logline 生成完整剧本 ───

    async def _phase_script_gen(self, input_data: Dict, logline_data: Dict) -> Dict:
        idea = input_data.get("idea", "")
        sid = input_data.get("session_id", "")
        style = input_data.get("style", "anime")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")
        web_search = input_data.get("web_search", False)
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in idea)

        # 用 Logline 六要素构建丰富的故事概要
        if is_zh:
            draft = (
                f"故事核心 Logline：{logline_data.get('logline', '')}\n"
                f"主角：{logline_data.get('who', '')}\n"
                f"目标：{logline_data.get('goal', '')}\n"
                f"核心障碍：{logline_data.get('conflict', '')}\n"
                f"反转：{logline_data.get('twist', '')}\n"
                f"主题：{logline_data.get('theme', '')}\n\n"
                f"原始灵感：{idea}"
            )
        else:
            draft = (
                f"Story Logline: {logline_data.get('logline', '')}\n"
                f"Protagonist: {logline_data.get('who', '')}\n"
                f"Goal: {logline_data.get('goal', '')}\n"
                f"Core Conflict: {logline_data.get('conflict', '')}\n"
                f"Twist: {logline_data.get('twist', '')}\n"
                f"Theme: {logline_data.get('theme', '')}\n\n"
                f"Original idea: {idea}"
            )

        def run():
            from config import settings as app_settings
            from tool.llm_client import LLM

            os.makedirs(app_settings.TEMP_DIR, exist_ok=True)
            os.makedirs(os.path.join(app_settings.RESULT_DIR, 'script'), exist_ok=True)

            llm = LLM()

            # 逐幕生成节拍表 + 分场大纲 + 结构化提取
            json_data = self._generate_script_incremental(
                llm, draft, style, llm_model, sid, is_zh, web_search=web_search, pct_start=20
            )

            # 补充元数据
            json_data.setdefault("project_id", f"proj_{sid}")
            json_data.setdefault("version", 1)
            json_data["created_at"] = datetime.now(timezone.utc).isoformat()
            json_data["metadata"] = {
                "generation_model": llm_model,
                "generation_prompt": idea,
            }
            json_data["session_id"] = sid
            json_data["logline_data"] = logline_data

            self._save_result(json_data, sid, is_zh)
            # 保存进度状态
            self._save_progress(sid, "script_generation", {
                "title": json_data.get("title")
            })
            self._report_progress("剧本生成", "完成", 100)
            return json_data

        loop = asyncio.get_running_loop()
        script_json = await loop.run_in_executor(None, run)

        # 保存进度状态
        self._save_progress(sid, "script_generation", {
            "title": script_json.get("title")
        })

        return {
            "payload": script_json,
            "requires_intervention": False,
            "stage_completed": True,  # 明确标记阶段完成
            "openclaw_hint": "剧本生成完成。",
        }

    # ─── Phase 2-Micro: 微电影模式 - 根据选定 Logline 生成紧凑单幕剧本 ───

    async def _phase_micro_script_gen(self, input_data: Dict, logline_data: Dict) -> Dict:
        idea = input_data.get("idea", "")
        sid = input_data.get("session_id", "")
        style = input_data.get("style", "anime")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")
        web_search = input_data.get("web_search", False)
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in idea)

        # 用 Logline 六要素构建故事概要
        if is_zh:
            draft = (
                f"故事核心 Logline：{logline_data.get('logline', '')}\n"
                f"主角：{logline_data.get('who', '')}\n"
                f"目标：{logline_data.get('goal', '')}\n"
                f"核心障碍：{logline_data.get('conflict', '')}\n"
                f"反转：{logline_data.get('twist', '')}\n"
                f"主题：{logline_data.get('theme', '')}\n\n"
                f"原始灵感：{idea}"
            )
        else:
            draft = (
                f"Story Logline: {logline_data.get('logline', '')}\n"
                f"Protagonist: {logline_data.get('who', '')}\n"
                f"Goal: {logline_data.get('goal', '')}\n"
                f"Core Conflict: {logline_data.get('conflict', '')}\n"
                f"Twist: {logline_data.get('twist', '')}\n"
                f"Theme: {logline_data.get('theme', '')}\n\n"
                f"Original idea: {idea}"
            )

        def run():
            from config import settings as app_settings
            from tool.llm_client import LLM

            os.makedirs(app_settings.TEMP_DIR, exist_ok=True)
            os.makedirs(os.path.join(app_settings.RESULT_DIR, 'script'), exist_ok=True)

            llm = LLM()

            # 微电影模式: 单幕生成
            json_data = self._generate_micro_script_incremental(
                llm, draft, style, llm_model, sid, is_zh, web_search=web_search, pct_start=20
            )

            # 补充元数据
            json_data.setdefault("project_id", f"proj_{sid}")
            json_data.setdefault("version", 1)
            json_data["created_at"] = datetime.now(timezone.utc).isoformat()
            json_data["metadata"] = {
                "generation_model": llm_model,
                "generation_prompt": idea,
                "mode": "micro",
            }
            json_data["session_id"] = sid
            json_data["logline_data"] = logline_data

            self._save_result(json_data, sid, is_zh)
            # 保存进度状态
            self._save_progress(sid, "script_generation", {
                "title": json_data.get("title")
            })
            self._report_progress("剧本生成", "完成", 100)
            return json_data

        loop = asyncio.get_running_loop()
        script_json = await loop.run_in_executor(None, run)

        # 保存进度状态
        self._save_progress(sid, "script_generation", {
            "title": script_json.get("title")
        })

        return {
            "payload": script_json,
            "requires_intervention": False,
            "stage_completed": True,  # 明确标记阶段完成
            "openclaw_hint": "剧本生成完成。",
        }

    # ─── 代理模式（自动生成 Logline 并选择第一个） ───

    async def _phase_direct(self, input_data: Dict) -> Dict:
        """代理模式：生成 3 个 Logline → 自动选择第一个 → 生成完整剧本"""
        idea = input_data.get("idea", "")
        sid = input_data.get("session_id", "")
        style = input_data.get("style", "anime")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")
        web_search = input_data.get("web_search", False)
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in idea)

        def run():
            from config import settings as app_settings
            from tool.llm_client import LLM

            os.makedirs(app_settings.TEMP_DIR, exist_ok=True)
            os.makedirs(os.path.join(app_settings.RESULT_DIR, 'script'), exist_ok=True)

            llm = LLM()

            # Step 1: 生成 Logline 方案
            self._report_progress("剧本生成", "正在生成 Logline 方案...", 5)
            prompt = (LOGLINE_GENERATE_PROMPT_ZH if is_zh else LOGLINE_GENERATE_PROMPT_EN).format(idea=idea)

            logline_data = None
            for attempt in range(3):
                self._check_cancel()
                raw = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid, web_search=web_search)
                logger.info(f"[ScriptWriter][auto] Logline gen attempt {attempt + 1}, raw ({len(raw)} chars): {raw[:500]}")
                options = self._extract_json_array_from_text(raw)
                if options and len(options) > 0:
                    required = {"logline", "who", "goal", "conflict", "twist", "theme"}
                    valid = [o for o in options if isinstance(o, dict) and required.issubset(o.keys())]
                    if valid:
                        logline_data = valid[0]  # 自动选择第一个
                        logger.info(f"[ScriptWriter][auto] Auto-selected logline: {logline_data.get('logline', '')[:80]}")
                        break

                logger.warning(f"[ScriptWriter][auto] Logline gen attempt {attempt + 1}: parse failed")
                if is_zh:
                    prompt = (
                        "上次输出格式不正确，请严格按要求重新输出。"
                        "必须输出纯JSON数组，不要用```包裹，不要有任何多余文字。\n\n"
                        + LOGLINE_GENERATE_PROMPT_ZH.format(idea=idea)
                    )
                else:
                    prompt = (
                        "Previous output format was incorrect. Please try again. "
                        "Output ONLY a raw JSON array, no code blocks, no extra text.\n\n"
                        + LOGLINE_GENERATE_PROMPT_EN.format(idea=idea)
                    )

            if logline_data is None:
                raise Exception("Logline 生成失败：多次尝试均无法解析输出")

            self._report_progress("剧本生成", "已自动选择 Logline，开始创作情节...", 15)

            # Step 2: 用 Logline 六要素构建故事概要
            if is_zh:
                draft = (
                    f"故事核心 Logline：{logline_data.get('logline', '')}\n"
                    f"主角：{logline_data.get('who', '')}\n"
                    f"目标：{logline_data.get('goal', '')}\n"
                    f"核心障碍：{logline_data.get('conflict', '')}\n"
                    f"反转：{logline_data.get('twist', '')}\n"
                    f"主题：{logline_data.get('theme', '')}\n\n"
                    f"原始灵感：{idea}"
                )
            else:
                draft = (
                    f"Story Logline: {logline_data.get('logline', '')}\n"
                    f"Protagonist: {logline_data.get('who', '')}\n"
                    f"Goal: {logline_data.get('goal', '')}\n"
                    f"Core Conflict: {logline_data.get('conflict', '')}\n"
                    f"Twist: {logline_data.get('twist', '')}\n"
                    f"Theme: {logline_data.get('theme', '')}\n\n"
                    f"Original idea: {idea}"
                )

            # Step 3: 逐幕生成节拍表 + 分场大纲 + 结构化提取
            json_data = self._generate_script_incremental(
                llm, draft, style, llm_model, sid, is_zh, web_search=web_search, pct_start=20
            )

            # 补充元数据
            json_data.setdefault("project_id", f"proj_{sid}")
            json_data.setdefault("version", 1)
            json_data["created_at"] = datetime.now(timezone.utc).isoformat()
            json_data["metadata"] = {
                "generation_model": llm_model,
                "generation_prompt": idea,
            }
            json_data["session_id"] = sid
            json_data["logline_data"] = logline_data

            self._save_result(json_data, sid, is_zh)
            # 保存进度状态
            self._save_progress(sid, "script_generation", {
                "title": json_data.get("title")
            })
            self._report_progress("剧本生成", "完成", 100)
            return json_data

        loop = asyncio.get_running_loop()
        script_json = await loop.run_in_executor(None, run)

        # 保存进度状态
        self._save_progress(sid, "script_generation", {
            "title": script_json.get("title")
        })

        return {
            "payload": script_json,
            "requires_intervention": False,
            "stage_completed": True,  # 明确标记阶段完成
            "openclaw_hint": "剧本生成完成。",
        }

    # ─── 公共: 逐幕生成节拍表 + 分场大纲 + 结构化提取 ───

    def _generate_script_incremental(self, llm, draft: str, style: str,
                                      llm_model: str, sid: str, is_zh: bool,
                                      web_search: bool = False,
                                      pct_start: int = 20) -> dict:
        """生成 Save the Cat! 节拍表 → 逐幕生成分场大纲 + 结构化提取，返回合并的 JSON"""

        # Step 1: 生成四幕节拍表
        self._report_progress("剧本生成", "生成节拍表...", pct_start)
        prompt = (BEAT_SHEET_PROMPT_ZH if is_zh else BEAT_SHEET_PROMPT_EN).format(draft=draft, style=style)
        beat_sheet = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid, web_search=web_search)
        logger.info(f"[ScriptWriter] Beat sheet generated ({len(beat_sheet)} chars)")

        # 发送节拍表到前端
        self._report_progress("剧本生成", "节拍表生成完成", pct_start + 5,
                              data={"beat_sheet": beat_sheet})

        # Step 2: 提取顶层元数据 (title, logline, genre, synopsis, mood)
        self._report_progress("剧本生成", "提取故事元信息...", pct_start + 7)
        meta_prompt = (META_EXTRACT_PROMPT_ZH if is_zh else META_EXTRACT_PROMPT_EN).format(beat_sheet=beat_sheet)
        meta_raw = self._cancellable_query(llm, meta_prompt, model=llm_model, task_id=sid, web_search=web_search)
        meta_data = self._extract_json_from_text(meta_raw) or {}
        logger.info(f"[ScriptWriter] Meta extracted: {list(meta_data.keys())}")

        # Step 3: 逐幕生成分场大纲 + 结构化提取
        act_names = ACT_NAMES_ZH if is_zh else ACT_NAMES_EN
        all_characters = []  # 累积角色
        all_settings = []    # 累积场景
        all_scenes = []      # 累积分场
        seen_char_names = set()
        seen_setting_names = set()
        scene_start = 1

        for act_num in range(1, 5):
            self._check_cancel()
            act_name = act_names[act_num]

            # --- 生成分场大纲 ---
            pct_outline = pct_start + 8 + (act_num - 1) * 15  # 28, 43, 58, 73
            progress_msg = (f"生成第{act_num}幕分场大纲（{act_name}）..."
                            if is_zh else f"Generating Act {act_num} outline ({act_name})...")
            self._report_progress("剧本生成", progress_msg, pct_outline)

            outline_prompt = (STEP_OUTLINE_PROMPT_ZH if is_zh else STEP_OUTLINE_PROMPT_EN).format(
                beat_sheet=beat_sheet,
                act_number=act_num,
                act_name=act_name,
                scene_start=scene_start,
                style=style,
            )
            outline = self._cancellable_query(llm, outline_prompt, model=llm_model, task_id=sid, web_search=web_search)
            logger.info(f"[ScriptWriter] Act {act_num} outline generated ({len(outline)} chars)")

            # --- 结构化提取本幕 JSON ---
            pct_extract = pct_outline + 8
            progress_msg = (f"提取第{act_num}幕结构化数据..."
                            if is_zh else f"Extracting Act {act_num} structured data...")
            self._report_progress("剧本生成", progress_msg, pct_extract)

            act_json = self._extract_act_json(
                llm, outline, act_num, scene_start, style, llm_model, sid, is_zh, web_search
            )

            # 累积角色（去重）
            for c in act_json.get("characters", []):
                if c.get("name") and c["name"] not in seen_char_names:
                    if not c.get("character_id"):
                        c["character_id"] = self._gen_id("char")
                    all_characters.append(c)
                    seen_char_names.add(c["name"])

            # 累积场景（去重）
            for s in act_json.get("settings", []):
                if s.get("name") and s["name"] not in seen_setting_names:
                    if not s.get("setting_id"):
                        s["setting_id"] = self._gen_id("set")
                    all_settings.append(s)
                    seen_setting_names.add(s["name"])

            # 累积分场
            act_scenes = act_json.get("scenes", [])
            all_scenes.extend(act_scenes)

            # 计算下一幕场次起始
            if act_scenes:
                scene_start = max(s.get("scene_number", scene_start) for s in act_scenes) + 1

            # 发送本幕结果到前端
            act_label = f"第{act_num}幕 - {act_name}" if is_zh else f"Act {act_num} - {act_name}"
            self._report_progress("剧本生成",
                                  f"{act_label} 完成" if is_zh else f"{act_label} done",
                                  pct_extract + 2,
                                  data={"act_complete": {
                                      "act": act_num,
                                      "act_name": act_name,
                                      "characters": act_json.get("characters", []),
                                      "settings": act_json.get("settings", []),
                                      "scenes": act_scenes,
                                  }})

        # Step 4: 合并最终 JSON
        # 重新编号 scene_number
        for i, sc in enumerate(all_scenes):
            sc["scene_number"] = i + 1

        json_data = {
            "title": meta_data.get("title", ""),
            "logline": meta_data.get("logline", ""),
            "genre": meta_data.get("genre", []),
            "target_duration": 1800,
            "synopsis": meta_data.get("synopsis", ""),
            "characters": all_characters,
            "settings": all_settings,
            "scenes": all_scenes,
            "overall_style": style,
            "mood": meta_data.get("mood", ""),
        }

        # Step 5: 合并相似场景和角色
        self._report_progress("剧本生成",
                              "审查并合并相似场景..." if is_zh else "Consolidating similar settings...",
                              96)
        json_data = self._consolidate_script(llm, json_data, llm_model, sid, is_zh, web_search=web_search)

        return json_data

    # ─── 微电影模式: 单幕紧凑生成 ───

    def _generate_micro_script_incremental(self, llm, draft: str, style: str,
                                            llm_model: str, sid: str, is_zh: bool,
                                            web_search: bool = False,
                                            pct_start: int = 20) -> dict:
        """微电影模式：生成紧凑单幕剧情概要 → 分场大纲 → 结构化提取，返回合并的 JSON"""

        # Step 1: 生成单幕剧情概要
        self._report_progress("剧本生成", "生成微电影剧情概要...", pct_start)
        prompt = (MICRO_BEAT_SHEET_PROMPT_ZH if is_zh else MICRO_BEAT_SHEET_PROMPT_EN).format(
            draft=draft, style=style
        )
        beat_sheet = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid, web_search=web_search)
        logger.info(f"[ScriptWriter][micro] Beat sheet generated ({len(beat_sheet)} chars)")

        # 发送概要到前端
        self._report_progress("剧本生成", "剧情概要生成完成", pct_start + 10,
                              data={"beat_sheet": beat_sheet})

        # Step 2: 提取顶层元数据
        self._report_progress("剧本生成", "提取故事元信息...", pct_start + 15)
        meta_prompt = (MICRO_META_EXTRACT_PROMPT_ZH if is_zh else MICRO_META_EXTRACT_PROMPT_EN).format(
            beat_sheet=beat_sheet
        )
        meta_raw = self._cancellable_query(llm, meta_prompt, model=llm_model, task_id=sid, web_search=web_search)
        meta_data = self._extract_json_from_text(meta_raw) or {}
        logger.info(f"[ScriptWriter][micro] Meta extracted: {list(meta_data.keys())}")

        # Step 3: 生成分场大纲
        self._check_cancel()
        self._report_progress("剧本生成",
                              "生成微电影分场大纲..." if is_zh else "Generating micro-film step outline...",
                              pct_start + 25)

        outline_prompt = (MICRO_STEP_OUTLINE_PROMPT_ZH if is_zh else MICRO_STEP_OUTLINE_PROMPT_EN).format(
            beat_sheet=beat_sheet, style=style
        )
        outline = self._cancellable_query(llm, outline_prompt, model=llm_model, task_id=sid, web_search=web_search)
        logger.info(f"[ScriptWriter][micro] Outline generated ({len(outline)} chars)")

        # Step 4: 结构化 JSON 提取
        self._report_progress("剧本生成",
                              "提取结构化数据..." if is_zh else "Extracting structured data...",
                              p

# -*- coding: utf-8 -*-
"""
阶段3: 分镜智能体
基于剧本JSON，逐场景拆分为带时长标签的分镜（shots），按幕分组输出。
"""

import os
import re
import json
import asyncio
import logging
from typing import Any, Optional, Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed

from .base_agent import AgentInterface
from prompts.loader import load_prompt

logger = logging.getLogger(__name__)

# ─── 幕名 ───
ACT_NAMES = {1: "激励事件", 2: "进入新世界", 3: "灵魂黑夜", 4: "高潮决战"}


def _get_shot_prompt(lang: str = 'zh') -> str:
    """获取分镜提示词"""
    return load_prompt('storyboard', 'shot', lang)


def _get_continue_prompt(lang: str = 'zh') -> str:
    """获取续写分镜提示词"""
    from prompts.loader import load_prompt_with_fallback
    return load_prompt_with_fallback('storyboard', 'continue', lang, 'zh')


def _get_prompt(name: str) -> str:
    """Helper to get prompts"""
    if name == 'SHOT_PROMPT_ZH':
        return load_prompt('storyboard', 'shot', 'zh')
    elif name == 'SHOT_PROMPT_EN':
        return load_prompt('storyboard', 'shot', 'en')
    raise AttributeError(f"module has no attribute {name!r}")


class StoryboardAgent(AgentInterface):
    """分镜智能体：逐场景拆分为带时长标签的分镜"""

    def __init__(self):
        super().__init__(name="Storyboard")

    # ─── 辅助方法 ───

    @staticmethod
    def _read_script_json(sid: str) -> dict:
        """从结果文件读取 script_json"""
        from config import settings
        result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')
        if not os.path.exists(result_file):
            return {}
        with open(result_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
        return data.get(str(sid), {}).get('script_json', {})

    @staticmethod
    def _extract_json_array(text: str) -> Optional[List[dict]]:
        """从LLM输出中提取JSON数组"""
        text = text.strip()
        text = re.sub(r'^```(?:json)?\s*', '', text)
        text = re.sub(r'\s*```$', '', text)
        text = text.strip()
        try:
            result = json.loads(text)
            if isinstance(result, list):
                return result
        except json.JSONDecodeError:
            pass
        # 尝试找到 [ ... ] 部分
        m = re.search(r'\[.*\]', text, re.DOTALL)
        if m:
            try:
                result = json.loads(m.group())
                if isinstance(result, list):
                    return result
            except json.JSONDecodeError:
                pass
        return None

    @staticmethod
    def _validate_shots(shots: List[dict]) -> List[dict]:
        """校验并清洗分镜数据"""
        valid = []
        for s in shots:
            if not isinstance(s, dict):
                continue
            dur = s.get("duration", 10)
            if dur not in (5, 10, 15):
                dur = 10  # 默认10秒
            valid.append({
                "shot_number": s.get("shot_number", len(valid) + 1),
                "duration": dur,
                "characters": s.get("characters", []),
                "location": s.get("location", ""),
                "plot": s.get("plot", ""),
                "visual_prompt": s.get("visual_prompt", ""),
            })
        return valid

    async def _continue_story(self, input_data: Dict, continue_info: Dict) -> Dict:
        """智能续写：根据已有剧情续写新场景"""
        from config import settings
        from tool.llm_client import LLM

        sid = input_data["session_id"]
        style = input_data.get("style", "anime")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")

        result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')

        # 读取已有分镜
        with open(result_file, 'r', encoding='utf-8') as f:
            results = json.load(f)
        existing_shots = results.get(str(sid), {}).get('storyboard', {}).get('shots', [])
        if not existing_shots:
            raise Exception("没有已有分镜，无法续写")

        # 读取剧本信息
        script_json = self._read_script_json(sid)
        if not script_json:
            raise Exception("未找到剧本数据")

        title = script_json.get("title", "")
        characters = script_json.get("characters", [])
        settings_list = script_json.get("settings", [])

        # 取所有分镜作为上下文
        last_shots = existing_shots

        # 构建上下文描述
        char_names = [c.get("name", "") for c in characters]
        # 只使用现有分镜中实际使用的场景位置
        used_locations = set(s.get("location", "") for s in existing_shots if s.get("location"))
        setting_names = [s.get("name", "") for s in settings_list if s.get("name", "") in used_locations]

        # 获取续写提示词
        is_zh = any('\u4e00' <= c <= '\u9fff' for c in title)
        prompt_template = _get_continue_prompt('zh' if is_zh else 'en')

        # 格式化已有分镜信息
        shots_context = ""
        for shot in last_shots:
            shots_context += f"- 场景{shot.get('scene_number')} 分镜{shot.get('shot_number')}: {shot.get('plot', '')}\n"

        prompt = prompt_template.format(
            title=title,
            style=style,
            characters=", ".join(char_names),
            settings=", ".join(setting_names),
            existing_shots=shots_context,
        )

        self._report_progress("分镜", "智能续写中...", 10)

        def run():
            llm = LLM()
            raw = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid)
            new_shots = self._extract_json_array(raw)
            if not new_shots:
                raise Exception("续写失败，无法解析LLM输出")
            new_shots = self._validate_shots(new_shots)
            return new_shots

        loop = asyncio.get_running_loop()
        new_shots = await loop.run_in_executor(None, run)

        # 为新分镜添加全局标识
        last_scene = last_shots[-1] if last_shots else None
        next_scene_num = (last_scene.get("scene_number", 0) + 1) if last_scene else 1
        next_act = last_scene.get("act", 1) if last_scene else 1

        for i, shot in enumerate(new_shots):
            shot["shot_id"] = f"shot_{next_scene_num:03d}_{i + 1:02d}"
            shot["scene_number"] = next_scene_num
            shot["act"] = next_act
            shot["is_new"] = True  # 标记为新添加的分镜

        # 追加到已有分镜
        all_shots = existing_shots + new_shots

        # 保存（带有 is_new 标记，供前端识别）
        results.setdefault(str(sid), {})['storyboard'] = {
            'shots': all_shots,
            'user_modified': True,
            'new_shot_ids': [s["shot_id"] for s in new_shots],  # 记录新分镜ID
        }
        with open(result_file, 'w', encoding='utf-8') as f:
            json.dump(results, f, indent=4, ensure_ascii=False)

        self._report_progress("分镜", "续写完成", 100)

        return {
            "payload": {
                "session_id": sid,
                "shots": all_shots,
                "new_shots": new_shots,
                "new_shot_ids": [s["shot_id"] for s in new_shots],
                "continued": True,
            },
            "requires_intervention": True,
        }

    # ─── 核心流程 ───

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        from config import settings
        from tool.llm_client import LLM

        sid = input_data["session_id"]
        style = input_data.get("style", "anime")
        llm_model = input_data.get("llm_model", "qwen3.5-plus")

        result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')

        # ── 用户修改了分镜 ──
        if intervention and "modified_storyboard" in intervention:
            modified_shots = intervention["modified_storyboard"]
            if isinstance(modified_shots, str):
                modified_shots = json.loads(modified_shots)

            with open(result_file, 'r', encoding='utf-8') as f:
                results = json.load(f)

            # 同步更新 script_json 中的 scenes
            # 获取修改后的 shots 中包含的场景编号
            new_scene_numbers = set(s.get("scene_number") for s in modified_shots if s.get("scene_number"))

            # 更新 script_json.scenes
            script_json = results.get(str(sid), {}).get('script_json', {})
            if script_json and 'scenes' in script_json:
                original_scenes = script_json.get('scenes', [])
                # 保留新分镜中包含的场景，按原始顺序
                filtered_scenes = [s for s in original_scenes if s.get('scene_number') in new_scene_numbers]
                # 重新编号（确保 scene_number 连续）
                for i, scene in enumerate(filtered_scenes, 1):
                    scene['scene_number'] = i
                script_json['scenes'] = filtered_scenes

            # 清除 new_shot_ids 标记，同时清除 is_new 标志
            for shot in modified_shots:
                if 'is_new' in shot:
                    shot['is_new'] = False
            storyboard_data = {
                'shots': modified_shots,
                'user_modified': True,
                'new_shot_ids': [],  # 清除新分镜标记
            }

            results.setdefault(str(sid), {})['storyboard'] = storyboard_data
            if script_json:
                results.setdefault(str(sid), {})['script_json'] = script_json
            with open(result_file, 'w', encoding='utf-8') as f:
                json.dump(results, f, indent=4, ensure_ascii=False)

            # 返回完整的 payload 包含 user_modified 和 new_shot_ids
            return {
                "payload": {
                    "session_id": sid,
                    "shots": modified_shots,
                    "user_modified": True,
                    "new_shot_ids": [],
                },
                "stage_completed": True,
            }

        # ── 用户点击"智能续写" ──
        if intervention and "continue_story" in intervention:
            return await self._continue_story(input_data, intervention["continue_story"])

        # ── 正常流程 ──
        script_json = self._read_script_json(sid)
        if not script_json:
            raise Exception("未找到剧本数据(script_json)，请先完成阶段1")

        scenes = script_json.get("scenes", [])
        characters = {c["name"]: c for c in script_json.get("characters", [])}
        settings_map = {s["name"]: s for s in script_json.get("settings", [])}

        is_zh = any('\u4e00' <= c <= '\u9fff' for c in script_json.get("title", ""))
        prompt_template = _get_prompt('SHOT_PROMPT_ZH') if is_zh else _get_prompt('SHOT_PROMPT_EN')

        self._report_progress("分镜", "读取剧本数据...", 5)

        # 获取并发数
        enable_concurrency = input_data.get("enable_concurrency", True)
        from config_model import get_max_concurrency
        # LLM 调用的并发数
        concurrency = get_max_concurrency("llm", enable_concurrency)
        logger.info(f"[StoryboardAgent] enable_concurrency={enable_concurrency}, concurrency={concurrency}")

        # 用于按场景顺序存储结果的字典
        shots_results: Dict[int, List[dict]] = {}
        done_count = 0
        total = len(scenes)

        def generate_one_scene(scene_index: int, scene: dict) -> tuple:
            """生成单个场景的分镜"""
            llm = LLM()
            sn = scene.get("scene_number", scene_index + 1)
            act = scene.get("act", 1)

            location = scene.get("location", "")
            scene_chars = scene.get("characters", [])
            plot = scene.get("plot", "")

            # 角色外貌描述
            char_descs = []
            for cn in scene_chars:
                c = characters.get(cn)
                if c:
                    char_descs.append(f"{cn}: {c.get('description', '')}")
            char_desc_text = "\n".join(char_descs) if char_descs else "无"

            # 场景环境描述
            setting_info = settings_map.get(location, {})
            setting_desc = setting_info.get("description", location)

            prompt = prompt_template.format(
                style=style,
                scene_number=sn,
                location=location,
                characters=", ".join(scene_chars),
                plot=plot,
                char_descriptions=char_desc_text,
                setting_description=setting_desc,
            )

            # 最多重试3次
            scene_shots = None
            for attempt in range(3):
                if hasattr(self, 'cancellation_check') and self.cancellation_check:
                    if self.cancellation_check():
                        break
                raw = self._cancellable_query(llm, prompt, model=llm_model, task_id=sid)
                parsed = self._extract_json_array(raw)
                if parsed:
                    scene_shots = self._validate_shots(parsed)
                    if scene_shots:
                        break
                logger.warning(f"Scene {sn} shot parse attempt {attempt+1} failed")

            if not scene_shots:
                # 降级: 整个场景作为一个分镜
                scene_shots = [{
                    "shot_number": 1,
                    "duration": 15,
                    "characters": scene_chars,
                    "location": location,
                    "plot": plot,
                    "visual_prompt": plot,
                }]

            # 为每个分镜添加全局标识
            for shot in scene_shots:
                shot["shot_id"] = f"shot_{sn:03d}_{shot['shot_number']:02d}"
                shot["scene_number"] = sn
                shot["act"] = act

            return scene_index, scene_shots, sn, act

        def run():
            nonlocal done_count
            # 检测是否有多幕结构（微电影模式只有一幕或无 act 字段）
            act_values = {s.get("act") for s in scenes}
            multi_act = len(act_values - {None}) > 1

            with ThreadPoolExecutor(max_workers=concurrency) as executor:
                futs = {}
                for i, scene in enumerate(scenes):
                    fut = executor.submit(generate_one_scene, i, scene)
                    futs[fut] = i

                # 按提交顺序收集结果（不是按完成顺序）
                for scene_index in range(len(scenes)):
                    # 找到对应的 future
                    found_future = None
                    for fut in futs:
                        if futs[fut] == scene_index:
                            found_future = fut
                            break

                    if found_future:
                        try:
                            idx, scene_shots, sn, act = found_future.result()
                            shots_results[idx] = scene_shots

                            # 报告进度
                            done_count += 1
                            pct = 5 + int(90 * done_count / max(total, 1))
                            if multi_act:
                                act_label = ACT_NAMES.get(act, f"第{act}幕")
                                self._report_progress("分镜", f"第{act}幕「{act_label}」 场景{sn}/{total}完成", pct)
                            else:
                                self._report_progress("分镜", f"场景{sn}完成 ({len(scene_shots)}个分镜)", pct)

                            # 发送逐场完成事件
                            self._report_progress(
                                "分镜",
                                f"场景{sn}完成 ({len(scene_shots)}个分镜)",
                                pct,
                                data={"scene_shots_complete": {
                                    "scene_number": sn,
                                    "act": act,
                                    "shots": scene_shots,
                                }},
                            )
                        except Exception as e:
                            logger.error(f"Scene {scene_index} generation error: {e}")
                            shots_results[scene_index] = []

            # 按场景顺序拼接所有分镜
            all_shots = []
            for i in range(len(scenes)):
                if i in shots_results:
                    all_shots.extend(shots_results[i])

            self._report_progress("分镜", "保存结果...", 96)

            # 写入结果文件
            with open(result_file, 'r', encoding='utf-8') as f:
                results = json.load(f)
            results.setdefault(str(sid), {})['storyboard'] = {
                'shots': all_shots,
            }
            with open(result_file, 'w', encoding='utf-8') as f:
                json.dump(results, f, indent=4, ensure_ascii=False)

            self._report_progress("分镜", "完成", 100)
            return {
                "payload": {
                    "session_id": sid,
                    "shots": all_shots,
                },
                "stage_completed": True,
            }

        loop = asyncio.get_running_loop()
        all_shots = await loop.run_in_executor(None, run)

        return {
            "payload": {
                "session_id": sid,
                "shots": all_shots,
            },
            "stage_completed": True,
        }

# -*- coding: utf-8 -*-
"""
阶段5: 视频生成智能体
分镜参考图 → 各分镜视频片段
- 视频提示词使用阶段3的原始分镜剧情描述(plot)，而非视觉描述或首帧图像提示词
- 参考图使用用户在阶段4选择的版本，而非第一版
- 支持逐项实时预览、重新生成、多版本管理
"""

import os
import re
import glob
import json
import asyncio
import logging
from typing import Any, Optional, Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed

from .base_agent import AgentInterface

logger = logging.getLogger(__name__)


class VideoDirectorAgent(AgentInterface):
    """视频生成：分镜参考图(阶段4用户选择) + 分镜剧情描述(阶段3 plot) → 视频片段"""

    def __init__(self):
        super().__init__(name="VideoDirector")

    # ─── 版本管理 ───

    @staticmethod
    def _video_base(sid: str) -> str:
        return os.path.join('code/result/video', str(sid))

    def _list_versions(self, sid: str, shot_id: str) -> List[str]:
        """列出某个分镜视频的所有历史版本"""
        video_dir = self._video_base(sid)
        pattern = os.path.join(video_dir, f"{shot_id}*.mp4")
        files = [f for f in sorted(glob.glob(pattern), key=os.path.getmtime)
                 if not f.endswith('_final.mp4')]
        return files

    def _next_version_path(self, sid: str, shot_id: str) -> str:
        """获取下一个版本路径"""
        video_dir = self._video_base(sid)
        os.makedirs(video_dir, exist_ok=True)

        existing = self._list_versions(sid, shot_id)
        if not existing:
            return os.path.join(video_dir, f"{shot_id}.mp4")

        max_v = 1
        for fp in existing:
            bn = os.path.splitext(os.path.basename(fp))[0]
            m = re.search(r'_v(\d+)$', bn)
            if m:
                max_v = max(max_v, int(m.group(1)))

        return os.path.join(video_dir, f"{shot_id}_v{max_v + 1}.mp4")

    # ─── 视频生成 ───

    def _generate_one(self, sid: str, shot_id: str, prompt: str,
                      img_path: str, video_model: str,
                      duration: int = 5, sound: str = "",
                      shot_type: str = "multi") -> tuple:
        """生成单个分镜视频，返回 (shot_id, path_or_None)"""
        # 取消时直接跳过，不抛异常，以保留已生成的部分结果
        if self.cancellation_check and self.cancellation_check():
            logger.info(f"VideoDirectorAgent: {shot_id} 跳过（用户取消）")
            return shot_id, None

        if not os.path.exists(img_path):
            logger.warning(f"Image missing for {shot_id}: {img_path}")
            return shot_id, None

        save_path = self._next_version_path(sid, shot_id)
        try:
            from tool.video_client import VideoClient
            client = VideoClient()
            client.generate_video(
                prompt=prompt,
                image_path=img_path,
                save_path=save_path,
                model=video_model,
                duration=duration,
                sound=sound,
                shot_type=shot_type,
            )
            return shot_id, save_path
        except Exception as e:
            logger.error(f"Video gen failed for {shot_id}: {e}")
            if os.path.exists(save_path):
                try:
                    os.remove(save_path)
                except Exception:
                    pass
        return shot_id, None

    # ─── 排序 ───

    @staticmethod
    def _sort_shot_keys(keys: list) -> list:
        """对 shot_id 排序: shot_001_01, shot_001_02, shot_002_01, ..."""
        def sort_key(k):
            nums = re.findall(r'(\d+)', k)
            return tuple(int(n) for n in nums) if nums else (0,)
        return sorted(keys, key=sort_key)

    # ─── 预览 / Payload 构建 ───

    @staticmethod
    def _shot_display_name(shot_id: str) -> str:
        """shot_001_02 → 场景1-镜头2"""
        nums = re.findall(r'(\d+)', shot_id)
        if len(nums) >= 2:
            return f"场景{int(nums[0])}-镜头{int(nums[1])}"
        elif len(nums) == 1:
            return f"场景{int(nums[0])}"
        return shot_id

    def _build_preview(self, sid: str, shot_keys: list, s2i: dict) -> list:
        """构建视频片段预览列表"""
        preview = []
        for idx, shot_id in enumerate(shot_keys, 1):
            versions = self._list_versions(sid, shot_id)
            entry = s2i.get(shot_id, {})
            desc = entry.get('plot', '') or entry.get('video_prompt', '') or entry.get('prompt', '')
            preview.append({
                "id": shot_id,
                "name": self._shot_display_name(shot_id),
                "index": idx,
                "description": desc,
                "duration": entry.get('duration', 5),
                "selected": versions[-1] if versions else "",
                "versions": versions,
                "status": "done" if versions else "pending",
            })
        return preview

    def _build_payload(self, sid: str, shot_keys: list, s2i: dict, clip_descriptions: dict = None) -> dict:
        """构建最终 payload

        Args:
            clip_descriptions: 用户修改的提示词，优先使用
        """
        clips = []
        for idx, shot_id in enumerate(shot_keys, 1):
            versions = self._list_versions(sid, shot_id)
            entry = s2i.get(shot_id, {})
            # 优先使用用户修改的描述，否则用 scene2image 中的原始描述
            if clip_descriptions and shot_id in clip_descriptions:
                desc = clip_descriptions[shot_id]
            else:
                desc = entry.get('plot', '') or entry.get('video_prompt', '') or entry.get('prompt', '')
            clips.append({
                "id": shot_id,
                "name": self._shot_display_name(shot_id),
                "index": idx,
                "description": desc,
                "duration": entry.get('duration', 5),
                "selected": versions[-1] if versions else "",
                "versions": versions,
                "status": "done" if versions else "failed",
            })
        return {
            "payload": {
                "session_id": sid,
                "clips": clips,
            },
            "stage_completed": True,
        }

    # ─── 视频提示词前缀/后缀配置 ───

    # 尝试从模板文件加载前缀/后缀，失败则使用默认值
    _VIDEO_PROMPT_PREFIX = None
    _VIDEO_PROMPT_SUFFIX = None

    @classmethod
    def _load_video_enhance_prompt(cls) -> tuple:
        """加载视频提示词优化模板"""
        if cls._VIDEO_PROMPT_PREFIX is not None:
            return cls._VIDEO_PROMPT_PREFIX, cls._VIDEO_PROMPT_SUFFIX

        try:
            from prompts.loader import PROMPTS_DIR
            import os
            enhance_file = os.path.join(PROMPTS_DIR, 'video', 'enhance.txt')
            if os.path.exists(enhance_file):
                with open(enhance_file, 'r', encoding='utf-8') as f:
                    content = f.read()

                prefix = ""
                suffix = ""
                current_section = None

                for line in content.split('\n'):
                    line = line.strip()
                    if not line or line.startswith('#'):
                        continue
                    if line == '[prefix]':
                        current_section = 'prefix'
                    elif line == '[suffix]':
                        current_section = 'suffix'
                    elif line.startswith('[') and line.endswith(']'):
                        # 遇到新的 section（如 [style_keywords]），停止解析
                        current_section = None
                    elif current_section == 'prefix':
                        prefix += line + " "
                    elif current_section == 'suffix':
                        suffix += " " + line

                cls._VIDEO_PROMPT_PREFIX = prefix.strip()
                cls._VIDEO_PROMPT_SUFFIX = suffix.strip()
                logger.info(f"Loaded video enhance prompt from file: prefix={len(cls._VIDEO_PROMPT_PREFIX)} chars, suffix={len(cls._VIDEO_PROMPT_SUFFIX)} chars")
                return cls._VIDEO_PROMPT_PREFIX, cls._VIDEO_PROMPT_SUFFIX
        except Exception as e:
            logger.warning(f"Failed to load video enhance prompt: {e}")

        # 默认值
        cls._VIDEO_PROMPT_PREFIX = (
            "high quality, detailed, cinematic footage, smooth motion, natural movement, "
        )
        cls._VIDEO_PROMPT_SUFFIX = (
            ", realistic, no blur, no distortion, professional lighting, film grain"
        )
        return cls._VIDEO_PROMPT_PREFIX, cls._VIDEO_PROMPT_SUFFIX

    # 视频API字符限制（可灵2500，万象也类似）
    MAX_PROMPT_LENGTH = 2500

    # ─── 风格关键词映射 ───
    # 根据项目风格添加对应的视觉描述词

    STYLE_VIDEO_KEYWORDS = {
        # 动漫/动画风格
        "anime": "anime style, animated, cel-shaded, vibrant colors, manga aesthetic, ",
        "cartoon": "cartoon style, animated, colorful, fun, children's book illustration, ",
        # 写实风格
        "realistic": "photorealistic, realistic, natural lighting, detailed textures, cinema photography, ",
        "photorealistic": "photorealistic, realistic, natural lighting, detailed textures, cinema photography, ",
        # 3D 迪士尼风格
        "3d-disney": "3D animation, Disney style, pixar, CGI, smooth textures, computer generated, ",
        "3d": "3D animation, CGI, computer generated, smooth textures, digital cinema, ",
        # 油画风格
        "oil-painting": "oil painting style, impasto, classical art, painterly, rich brushstrokes, ",
        "watercolor": "watercolor style, delicate, soft colors, artistic, flowing, ",
        # 漫画风格
        "comic-book": "comic book style, vibrant, bold outlines, pop art, graphic novel, ",
        # 赛博朋克
        "cyberpunk": "cyberpunk, neon lights, futuristic, dark atmosphere, sci-fi, ",
        # 中国风
        "chinese-ink": "Chinese ink painting style, traditional, minimalist, brush strokes, oriental art, ",
        "ink": "Chinese ink painting style, traditional, minimalist, brush strokes, oriental art, ",
    }

    def _get_style_keywords(self, sid: str) -> str:
        """获取项目风格对应的视频关键词"""
        try:
            from config import settings
            result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')
            if os.path.exists(result_file):
                with open(result_file, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                session_data = data.get(str(sid), {})
                style = session_data.get('overall_style', '').lower().strip()
                if style and style in self.STYLE_VIDEO_KEYWORDS:
                    logger.info(f"Using style keywords for video: {style}")
                    return self.STYLE_VIDEO_KEYWORDS[style]
        except Exception as e:
            logger.debug(f"Could not get style for video prompt: {e}")
        return ""

    # ─── 辅助：获取分镜的视频提示词和参考图路径 ───

    def _enhance_video_prompt(self, base_prompt: str, sid: str = None) -> str:
        """
        增强视频提示词：添加前缀后缀优化生成效果
        不截断，发送完整提示词给API
        """
        if not base_prompt:
            return base_prompt

        prefix, suffix = self._load_video_enhance_prompt()
        base_lower = base_prompt.lower().strip()

        # 获取风格关键词
        style_keywords = ""
        if sid:
            style_keywords = self._get_style_keywords(sid)

        # 获取对话语言要求
        dialog_language = ""
        if sid:
            from config import settings
            import os
            script_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')
            if os.path.exists(script_file):
                import json
                with open(script_file, 'r', encoding='utf-8') as f:
                    data = json.load(f)
                    script_data = data.get(str(sid), {})
                    # title 可能在 script_json 子对象中
                    title = script_data.get('title') or script_data.get('script_json', {}).get('title', '')
                    # 判断语言：检查标题是否包含中文字符
                    is_zh = any('\u4e00' <= c <= '\u9fff' for c in title)
                    if is_zh:
                        dialog_language = "注意：人物对话必须使用中文，不要使用英文。"
                    else:
                        dialog_language = "Note: Character dialogues must be in English."

        # 构建增强后的提示词
        # 检查是否已包含前缀关键词
        has_prefix = any(kw in base_lower for kw in ["high quality", "cinematic", "smooth motion", "anime", "photorealistic"])
        # 检查是否已包含后缀关键词
        has_suffix = any(kw in base_lower for kw in ["film grain", "realistic", "professional lighting", "masterpiece"])

        enhanced = base_prompt.strip()

        # 添加对话语言要求
        if dialog_language:
            enhanced = enhanced + " " + dialog_language

        # 添加风格关键词（前缀之前）
        if style_keywords:
            enhanced = style_keywords + enhanced

        if prefix and not has_prefix:
            enhanced = prefix + enhanced

        if suffix and not has_suffix:
            enhanced = enhanced + suffix

        logger.info(f"Video prompt enhanced: {len(base_prompt)} -> {len(enhanced)} chars")
        # 不截断，发送完整提示词
        return enhanced

    def _get_shot_prompt(self, entry: dict, enhance: bool = True, sid: str = None, shot_id: str = None, clip_descriptions: dict = None) -> str:
        """获取视频提示词：优先用用户修改的提示词，其次用 plot（剧情描述），兼容旧数据回退到 video_prompt"""
        # 优先使用用户修改的提示词
        if not shot_id:
            shot_id = entry.get('shot_id') or entry.get('id', '')
        if clip_descriptions and shot_id and clip_descriptions.get(shot_id):
            base_prompt = clip_descriptions[shot_id]
        else:
            base_prompt = entry.get('plot', '') or entry.get('video_prompt', '') or entry.get('prompt', '')
        if enhance:
            return self._enhance_video_prompt(base_prompt, sid)
        return base_prompt

    def _get_shot_image(self, sid: str, shot_id: str, entry: dict,
                        selected_images: dict) -> str:
        """获取参考图路径：优先用前端传入的用户选择，再用 scene2image 的 local_path，
        最后回退到扫描磁盘最新版本"""
        # 1. 前端传入的用户选择（stage 4 确认时携带）
        if selected_images.get(shot_id):
            path = selected_images[shot_id]
            if os.path.exists(path):
                return path
            logger.warning(f"selected_images path missing for {shot_id}: {path}")

        # 2. scene2image 中的 local_path
        local_path = entry.get('local_path', '')
        if local_path and os.path.exists(local_path):
            return local_path

        # 3. 回退：扫描磁盘，使用最新版本
        from core.agents.reference_agent import ReferenceGeneratorAgent
        versions = ReferenceGeneratorAgent._list_versions_static(sid, shot_id)
        if versions:
            logger.info(f"Fallback to latest version for {shot_id}: {versions[-1]}")
            return versions[-1]

        # 4. 最终回退：默认路径
        return os.path.join('code/result/image', str(sid), 'Scenes', f"{shot_id}.jpg")

    # ─── 核心流程 ───

    async def process(self, input_data: Any, intervention: Optional[Dict] = None) -> Dict:
        from config import settings

        sid = input_data["session_id"]
        video_model = input_data.get("video_model", "") or settings.VIDEO_MODEL
        # 根据 enable_concurrency 决定并发数
        enable_concurrency = input_data.get("enable_concurrency", True)
        from config_model import get_max_concurrency
        concurrency = get_max_concurrency(video_model, enable_concurrency)
        selected_images = input_data.get("selected_images", {})
        # 优先使用 input_data 中已有的 clips（包含用户修改的 description）
        existing_clips = input_data.get("clips", [])
        clip_descriptions = {c['id']: c['description'] for c in existing_clips if c.get('id') and c.get('description')}
        video_sound = input_data.get("video_sound", "on")
        video_shot_type = input_data.get("video_shot_type", "multi")
        sound_param = "" if video_sound == "off" else video_sound

        logger.info(f"VideoDirectorAgent: sid={sid}, video_model={video_model}, sound={video_sound}, shot_type={video_shot_type}")

        result_file = os.path.join(settings.RESULT_DIR, 'script', f'script_{sid}.json')

        # 读取数据
        with open(result_file, 'r', encoding='utf-8') as f:
            results = json.load(f)
        story_data = results[str(sid)]

        s2i = story_data.get('scene2image', {})

        # 从 storyboard 获取时长数据（用户修改已同步到 clips 中）
        storyboard = story_data.get('storyboard', {})
        storyboard_shots_list = storyboard.get('shots', [])
        shot_duration_map = {s.get('shot_id'): s.get('duration', 10) for s in storyboard_shots_list if s.get('shot_id')}

        # 同步 scene2image 中的时长
        for shot_id in s2i:
            if shot_id in shot_duration_map:
                s2i[shot_id]['duration'] = shot_duration_map[shot_id]

        logger.info(f"VideoDirectorAgent: duration sync from storyboard: {list(shot_duration_map.keys())}")

        # 兼容 shot_xxx_xx 和旧 Scene_x 格式
        shot_keys = self._sort_shot_keys(list(s2i.keys()))
        total = len(shot_keys)

        logger.info(f"VideoDirectorAgent: total shots in scene2image = {total}, shot_keys = {shot_keys}")

        if not shot_keys:
            raise Exception("未找到场景图数据(scene2image)，请先完成阶段4")

        # ═══ 介入：重新生成指定片段 ═══
        if intervention:
            regen_clips = intervention.get("regenerate_clips", [])

            if regen_clips:
                self._report_progress("视频生成", "重新生成中...", 10)

                def regen_run():
                    regen_total = len(regen_clips)
                    done = 0
                    with ThreadPoolExecutor(max_workers=concurrency) as executor:
                        futs = {}
                        for shot_id in regen_clips:
                            entry = s2i.get(shot_id, {})
                            prompt = self._get_shot_prompt(entry, sid=sid, shot_id=shot_id, clip_descriptions=clip_descriptions)
                            img_path = self._get_shot_image(sid, shot_id, entry, selected_images)
                            shot_duration = entry.get('duration', 5)
                            fut = executor.submit(
                                self._generate_one, sid, shot_id, prompt,
                                img_path, video_model, shot_duration,
                                sound_param, video_shot_type
                            )
                            futs[fut] = shot_id
                        for fut in as_completed(futs):
                            shot_id_done = futs[fut]
                            try:
                                _, result_path = fut.result()
                            except Exception as e:
                                logger.error(f"Regen future error for {shot_id_done}: {e}")
                                result_path = None
                            done += 1
                            pct = 10 + int(85 * done / max(regen_total, 1))
                            if result_path:
                                versions = self._list_versions(sid, shot_id_done)
                                self._report_progress("视频生成", f"完成: {shot_id_done}", pct, data={
                                    "asset_complete": {
                                        "type": "clips", "id": shot_id_done,
                                        "status": "done",
                                        "selected": result_path,
                                        "versions": versions,
                                    }
                                })
                            else:
                                self._report_progress("视频生成", f"失败: {shot_id_done}", pct, data={
                                    "asset_complete": {
                                        "type": "clips", "id": shot_id_done,
                                        "status": "failed",
                                        "selected": "", "versions": [],
                                    }
                                })
                            # 检查取消：停止等待剩余任务
                            if self.cancellation_check and self.cancellation_check():
                                logger.info("VideoDirectorAgent: 用户取消重新生成，停止等待剩余任务")
                                for f in futs:
                                    if not f.done():
                                        f.cancel()
                                break

                loop = asyncio.get_running_loop()
                await loop.run_in_executor(None, regen_run)

            self._report_progress("视频生成", "完成", 100)
            return self._build_payload(sid, shot_keys, s2i, clip_descriptions)

        # ═══ 正常流程：全量生成 ═══
        self._report_progress("视频生成", "加载场景数据...", 5)

        # 发送预览列表
        preview = self._build_preview(sid, shot_keys, s2i)
        self._report_progress("视频生成", "加载视频列表", 8, data={"assets_preview": {"clips": preview}})

        def run():
            # 筛选需要生成的（跳过已有的）
            tasks = []
            for shot_id in shot_keys:
                existing = self._list_versions(sid, shot_id)
                if existing:
                    continue
                entry = s2i.get(shot_id, {})
                prompt = self._get_shot_prompt(entry, sid=sid, shot_id=shot_id, clip_descriptions=clip_descriptions)
                img_path = self._get_shot_image(sid, shot_id, entry, selected_images)
                shot_duration = entry.get('duration', 5)
                tasks.append((shot_id, prompt, img_path, shot_duration))

            if not tasks:
                self._report_progress("视频生成", "所有视频已存在", 95)
                return

            gen_total = len(tasks)
            done = 0

            cancelled = False
            with ThreadPoolExecutor(max_workers=concurrency) as executor:
                futs = {}
                for shot_id, prompt, img_path, shot_duration in tasks:
                    fut = executor.submit(
                        self._generate_one, sid, shot_id, prompt,
                        img_path, video_model, shot_duration,
                        sound_param, video_shot_type,
                    )
                    futs[fut] = shot_id
                for fut in as_completed(futs):
                    shot_id_done = futs[fut]
                    try:
                        _, result_path = fut.result()
                    except Exception as e:
                        logger.error(f"Video future error for {shot_id_done}: {e}")
                        result_path = None
                    done += 1
                    pct = 10 + int(85 * done / max(gen_total, 1))
                    if result_path:
                        versions = self._list_versions(sid, shot_id_done)
                        self._report_progress("视频生成", f"完成: {shot_id_done}", pct, data={
                            "asset_complete": {
                                "type": "clips", "id": shot_id_done,
                                "status": "done",
                                "selected": result_path,
                                "versions": versions,
                            }
                        })
                    else:
                        self._report_progress("视频生成", f"失败: {shot_id_done}", pct, data={
                            "asset_complete": {
                                "type": "clips", "id": shot_id_done,
                                "status": "failed",
                                "selected": "", "versions": [],
                            }
                        })
                    # 检查取消：停止等待剩余任务
                    if self.cancellation_check and self.cancellation_check():
                        logger.info("VideoDirectorAgent: 用户取消，停止等待剩余任务")
                        for f in futs:
                            if not f.done():
                                f.cancel()
                        cancelled = True
                        break

            if cancelled:
                self._report_progress("视频生成", "已取消（保留已完成片段）", 96)
            else:
                self._report_progress("视频生成", "保存结果...", 96)

            # 写回结果文件
            with open(result_file, 'r', encoding='utf-8') as f:
                res = json.load(f)
            i2v_data = {}
            for shot_id in shot_keys:
                versions = self._list_versions(sid, shot_id)
                entry = s2i.get(shot_id, {})
                if versions:
                    i2v_data[shot_id] = {
                        "video_prompt": self._get_shot_prompt(entry, sid=sid, shot_id=shot_id, clip_descriptions=clip_descriptions),
                        "input_path": self._get_shot_image(sid, shot_id, entry, selected_images),
                        "output_path": versions[-1],
                        "duration": entry.get('duration', 10),
                        "status": "done",
                    }
            res[str(sid)]['image2video'] = i2v_data
            with open(result_file, 'w', encoding='utf-8') as f:
                json.dump(res, f, indent=4, ensure_ascii=False)

        loop = asyncio.get_running_loop()
        try:
            await loop.run_in_executor(None, run)
        except Exception as e:
            # 即使异常也保留已完成的部分结果
            if "cancel" in str(e).lower():
                logger.info("VideoDirectorAgent: 用户取消，返回已完成的部分结果")
                self._report_progress("视频生成", "已取消（保留已完成片段）", 100)
                return self._build_payload(sid, shot_keys, s2i, clip_descriptions)
            raise

        self._report_progress("视频生成", "完成", 100)
        return self._build_payload(sid, shot_keys, s2i, clip_descriptions)

# -*- coding: utf-8 -*-
from .base_agent import AgentInterface
from .script_agent import ScriptWriterAgent
from .character_agent import CharacterDesignerAgent
from .storyboard_agent import StoryboardAgent
from .reference_agent import ReferenceGeneratorAgent
from .video_agent import VideoDirectorAgent
from .editor_agent import VideoEditorAgent

__all__ = [
    "AgentInterface",
    "ScriptWriterAgent",
    "CharacterDesignerAgent",
    "StoryboardAgent",
    "ReferenceGeneratorAgent",
    "VideoDirectorAgent",
    "VideoEditorAgent",
]

# Character Reference Sheet Prompt Templates
# 角色参考图提示词模板（按风格分类）
# 共用 4 视图结构，风格特定视觉描述
# 使用方式：根据 {style} 变量选择对应的模板

# ============================================================
# 共用 4 视图结构定义 (所有风格通用)
# ============================================================
# Four-view structure template (shared across all styles):
# 1) front-facing portrait (head and shoulders)
# 2) front-facing full body (standing in natural pose)
# 3) side-view full body (standing in natural pose)
# 4) back-view full body (standing in natural pose)
# ALL views show identical character with perfectly consistent appearance, outfit, and lighting

# ============================================================
# 共用面部要求 (所有风格通用)
# ============================================================
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin texture.

# ============================================================
# realistic - 写实摄影风格
# ============================================================
[realistic]
Photorealistic character reference sheet, actual photograph style, pure white background.
Four views of the same real person arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (standing in natural resting pose),
3) side-view full body (natural resting pose),
4) back-view full body (natural resting pose).
ALL views show identical character with perfectly consistent appearance, outfit, and lighting.
Portrait shows head to waist; others show complete body head to feet.
Ultra high quality photography, 8k resolution, sharp focus, 85mm lens, f/2.8, soft studio lighting, even illumination.
Realistic skin texture with subtle imperfections, fabric has natural folds and highlights.
NO text, NO labels, NO annotations, NO captions, NO watermarks on image.
NOT an illustration, NOT a drawing, NOT anime style.
Character: {name} — {desc}

# ============================================================
# anime - 动漫风格
# ============================================================
[anime]
Anime character reference sheet, clean vector art style, white background.
Four views of the same anime character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (standing in natural pose),
3) side-view full body (natural pose),
4) back-view full body (natural pose).
ALL views show IDENTICAL character with perfectly consistent appearance, outfit, hair, and facial features.
Portrait shows head to waist; others show complete body head to feet.
Clean anime linework, vibrant colors, cel-shaded rendering style.
High quality anime illustration, masterpiece, crisp details.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO watermarks on image.
Character: {name} — {desc}

# ============================================================
# comic-book - 漫画风格
# ============================================================
[comic-book]
Comic book character reference sheet, comic panel art style, white background.
Four views of the same comic character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (heroic pose),
3) side-view full body (action pose),
4) back-view full body (standing pose).
ALL views show IDENTICAL character with perfectly consistent appearance, costume, and signature features.
Portrait shows head to waist; others show complete body head to feet.
Bold ink lines, comic shading (hatching/cross-hatching), dynamic comic book art style.
High quality comic illustration, vibrant ink colors, dramatic lighting.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO speech bubbles on image.
Character: {name} — {desc}

# ============================================================
# 3d-disney - 迪士尼3D风格
# ============================================================
[3d-disney]
3D Disney-style character reference sheet, CGI animated movie style, pure white background.
Four views of the same 3D animated character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (friendly pose),
3) side-view full body (character profile),
4) back-view full body (standing pose).
ALL views show IDENTICAL character with perfectly consistent appearance, costume, and features.
Portrait shows head to waist; others show complete body head to feet.
Disney Pixar CGI quality, toon shader rendering, smooth 3D geometry, clean textures.
High quality 3D render, soft shadows, cinematic lighting, feature film quality.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO watermarks on image.
Character: {name} — {desc}

# ============================================================
# watercolor - 水彩风格
# ============================================================
[watercolor]
Watercolor character reference sheet, painterly art style, white background.
Four views of the same character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (elegant pose),
3) side-view full body (graceful pose),
4) back-view full body (standing pose).
ALL views show IDENTICAL character with perfectly consistent appearance, outfit, and features.
Portrait shows head to waist; others show complete body head to feet.
Soft watercolor painting texture, flowing color washes, delicate brush strokes, translucent layers.
High quality watercolor illustration, artistic masterpiece, organic color blending.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO watermarks on image.
Character: {name} — {desc}

# ============================================================
# oil-painting - 油画风格
# ============================================================
[oil-painting]
Oil painting character reference sheet, classical fine art style, white background.
Four views of the same character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (noble pose),
3) side-view full body (aristocratic pose),
4) back-view full body (standing pose).
ALL views show IDENTICAL character with perfectly consistent appearance, attire, and features.
Portrait shows head to waist; others show complete body head to feet.
Rich oil paint texture, impasto brushwork, classical portraiture technique, deep colors.
High quality oil painting, museum-quality masterpiece, dramatic chiaroscuro lighting.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO watermarks on image.
Character: {name} — {desc}

# ============================================================
# cyberpunk - 赛博朋克风格
# ============================================================
[cyberpunk]
Cyberpunk character reference sheet, futuristic sci-fi style, white background.
Four views of the same cybernetic character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders, showing cybernetics),
2) front-facing full body (tech-enhanced pose),
3) side-view full body (cyberpunk stance),
4) back-view full body (with tech gear visible).
ALL views show IDENTICAL character with perfectly consistent appearance, cybernetic augmentations, and outfit.
Portrait shows head to waist; others show complete body head to feet.
Neon lighting, chrome/metallic surfaces, holographic elements, RGB accents.
High quality cyberpunk illustration, sci-fi concept art, futuristic tech aesthetic.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO HUD elements on image.
Character: {name} — {desc}

# ============================================================
# chinese-ink - 中国水墨风格
# ============================================================
[chinese-ink]
Chinese ink painting (水墨画) character reference sheet, traditional East Asian art style, white background.
Four views of the same character arranged in a single row from left to right:
1) front-facing portrait (head and shoulders),
2) front-facing full body (classical pose),
3) side-view full body (traditional stance),
4) back-view full body (standing pose).
ALL views show IDENTICAL character with perfectly consistent appearance, clothing, and features.
Portrait shows head to waist; others show complete body head to feet.
Ink wash (墨色) rendering, Gongbi/Boneless brush technique, subtle ink gradients, rice paper texture.
High quality Chinese ink painting, traditional scroll art aesthetics, elegant brushwork.
DO NOT describe or specify eye color. Leave eye color unspecified.
Smooth, clear face, no blemishes, no spots, perfect skin.
NO text, NO labels, NO annotations, NO captions, NO seals/stamps on image.
Character: {name} — {desc}

Character reference sheet, {style} style, white background,
4 views of the same character arranged in a single row from left to right:
1) front-facing close-up portrait (head and upper body),
2) front-facing full body ({pose_note}),
3) side-view full body ({pose_note}),
4) back-view full body ({pose_note}).
All views show the SAME character with consistent appearance and outfit.
The close-up shows head-to-waist; the other three show complete body from head to feet.
Pure image only, absolutely NO text, NO labels, NO annotations, NO captions, NO watermarks on the image.
High quality, masterpiece, clean line art.
Character: {name} — {desc}

你是一个专业的AI图像质量评估师。请根据以下信息评估生成的4视图角色参考图。

角色描述：
{character_description}

注意：这是一张4视图角色参考图，包含：
1. 正面特写（头部及上半身）
2. 正面全身照
3. 侧面全身照
4. 背面全身照

请严格按照以下标准评估并给出1-10分：

【评分标准】
满分10分，每个检查项符合得1分，不符合扣1分，最高10分：

1. 四视图一致性（+1/-1）：四个视图是否为同一角色（面貌、服装、体型是否一致）
2. 面貌还原（+1/-1）：面孔是否与描述一致
3. 发型还原（+1/-1）：发型是否与描述一致
4. 服装还原（+1/-1）：服装颜色、款式是否与描述一致
5. 体型还原（+1/-1）：体型是否与描述一致
6. 完整性（+1/-1）：四个视图是否都存在且完整
7. 光线质量（+1/-1）：光线是否自然、合理
8. 构图质量（+1/-1）：构图是否合理、均衡
9. 图片质量（+1/-1）：清晰度良好，无模糊、无畸变
10. 无无关元素（+1/-1）：无文字、标签、注释、水印等

【扣分项】（发现以下问题必须扣分并在issues中列出）：
- 四个视图角色面貌不一致：-1分
- 服装颜色与描述不符：-1分
- 发型与描述不符：-1分
- 面孔与描述不符：-1分
- 缺少某个视图：-1分
- 出现文字/水印：-1分

【最终评分规则】
- 8分及以上：可接受（is_acceptable: true）
- 7分及以下：需要重新生成（is_acceptable: false）

请输出纯JSON格式（不要用```包裹）：
{{
  "score": 1-10,
  "issues": ["问题1", "问题2", ...],
  "is_acceptable": true/false,
  "suggestion": "修改建议（如果有问题）"
}}

如果图片可接受，issues 返回空数组 []。

你是一个专业的AI图像质量评估师。请从以下{num_images}张角色设计图中选择最好的一张。

角色名称：{character_name}
角色描述：{character_description}
角色物种：{species}

图片列表：
{images_list}

请严格按照以下标准评估并选择最好的一张：

【评分标准】
满分10分，每个检查项符合得1分，不符合扣1分，最高10分：

1. 外观一致性（+1/-1）：角色外观是否与描述一致（发型、服装、配饰）
2. 面部特征（+1/-1）：面部特征是否清晰、符合描述
3. 身体比例（+1/-1）：身体比例是否正常、协调
4. 风格一致性（+1/-1）：整体风格是否符合设定风格
5. 细节完整（+1/-1）：细节是否丰富，无明显缺失
6. 色彩还原（+1/-1）：色彩是否与描述一致
7. 画面质量（+1/-1）：清晰度良好，无模糊、无畸变
8. 构图质量（+1/-1）：构图是否均衡、美观
9. 视角一致性（+1/-1）：四个视角是否一致
10. 无无关元素（+1/-1）：无文字、水印、标签等无关内容

【最终选择规则】
- 选择分数最高的一张作为最终选择
- 如果最高分有多张相同，选择第一张

请输出纯JSON格式（不要用```包裹）：
{{
  "scores": [
    {{"image_index": 0, "score": 8, "reasons": ["原因1", "原因2"]}},
    {{"image_index": 1, "score": 6, "reasons": ["原因1"]}},
    ...
  ],
  "best_index": 0,
  "best_reason": "选择这张的原因"
}}

Determine if the following text contains enough narrative elements for a complete story Logline.
(Needs: protagonist, goal, conflict, twist, and theme)

Text: {idea}

Answer only Yes or No.

请判断以下文本是否包含足够的叙事要素，能够从中总结出一个完整故事的 Logline。
（完整 Logline 需涵盖：主角、目标、核心障碍、反转和主题）

文本：{idea}

只回答 Yes 或 No，不要添加任何其他内容。

你是资深制片人。请从以下文本中总结提取 Logline 及故事五要素。
Logline 请使用"如果…会怎样"的句式。

文本：{idea}

请严格按如下 JSON 格式输出（直接输出纯JSON，不要用```包裹，不要添加任何其他文字）：
{{"logline":"如果...会怎样","who":"主角描述","goal":"目标","conflict":"核心障碍","twist":"反转","theme":"潜在主题"}}

You are a senior producer. Expand the following idea into 3 different Loglines.
Requirements:
- Define the protagonist (Who), Goal, core Conflict, and Twist
- Identify the story's Theme
- Each Logline should use 'What if...' format
- The 3 Loglines should be diverse in style and focus

Input: {idea}

Output ONLY a JSON array with exactly 3 elements (no code block markers, no other text):
[{{"logline":"What if...","who":"protagonist","goal":"goal","conflict":"conflict","twist":"twist","theme":"theme"}}]

你是资深制片人。请将以下灵感扩展为 3 个不同的 Logline（故事大纲）。
要求：
- 明确主角（Who）、目标（Goal）、核心障碍（Conflict）和反转（Twist）
- 确定故事的 Theme（潜在主题）
- Logline 按照"如果…会怎样"的句式描述
- 3 个 Logline 应风格各异、各有侧重

输入内容：{idea}

请严格按如下 JSON 数组格式输出（直接输出纯JSON，不要用```包裹，不要添加任何其他文字）：
[{{"logline":"如果...会怎样","who":"主角描述","goal":"目标","conflict":"核心障碍","twist":"反转","theme":"潜在主题"}}]
输出恰好 3 个元素的 JSON 数组。

你是一个专业的AI图像质量评估师。请根据以下信息评估生成的视频首帧参考图。

分镜剧情：
{plot}

分镜视觉描述：
{visual_prompt}

角色描述：
{character_description}

场景描述：
{setting_description}

请严格按照以下标准评估并给出1-10分：

【评分标准】
满分10分，每个检查项符合得1分，不符合扣1分，最高10分：

1. 角色外观一致性（+1/-1）：角色发型、服装、面孔是否与角色描述一致
2. 场景一致性（+1/-1）：场景地点、布局是否与场景描述一致
3. 剧情相关性（+1/-1）：图片是否体现分镜剧情的核心内容和情感
4. 姿态合理性（+1/-1）：角色姿态是否体现动作的起始瞬间
5. 光线质量（+1/-1）：光线是否自然、合理、有层次
6. 色调氛围（+1/-1）：色调是否符合分镜设定的氛围（日/夜、暖/冷等）
7. 构图美感（+1/-1）：构图是否平衡、美观、符合影视镜头语言
8. 图片质量（+1/-1）：无模糊、无畸变、无明显瑕疵
9. 细节完整（+1/-1）：画面细节丰富，无缺失或残缺
10. 无无关元素（+1/-1）：无文字、水印、标签等无关内容

【扣分项】（发现以下问题必须扣分并在issues中列出）：
- 角色服装颜色与描述不符：-1分
- 角色发型/面孔与描述不符：-1分
- 场景环境与描述不符：-1分
- 角色数量错误（多或少）：-1分
- 光线过暗或过亮：-1分
- 构图严重偏斜：-1分
- 出现文字/水印：-1分

【最终评分规则】
- 8分及以上：可接受（is_acceptable: true）
- 7分及以下：需要重新生成（is_acceptable: false）

重要：如果发现问题需要重新生成，请同时提供一个优化后的提示词，用于改善图片质量。优化提示词时：
- **不要改变角色的外貌描述**（如发型、服装、面孔等）
- 可以让光线、构图、氛围、姿态等描述更清晰具体
- 保持与角色外观相关的描述不变

请输出纯JSON格式（不要用```包裹）：
{{
  "score": 1-10,
  "issues": ["问题1", "问题2", ...],
  "is_acceptable": true/false,
  "suggestion": "修改建议（如果有问题）",
  "suggested_prompt": "优化后的提示词（如果需要重新生成），如果不需重新生成则为空字符串"
}}

如果图片可接受，issues 返回空数组 []，suggested_prompt 为空字符串。

你是一个专业的AI图像质量评估师。请从以下{num_images}张图片中选择最好的一张作为视频参考图。

分镜剧情：
{plot}

分镜视觉描述：
{visual_prompt}

角色描述：
{character_description}

场景描述：
{setting_description}

{images_list}

【选择标准】
请严格按照以下标准选择最佳图片：

1. 角色外观一致性：角色发型、服装、面孔是否与角色描述一致
2. 场景一致性：场景地点、布局是否与场景描述一致
3. 剧情相关性：图片是否体现分镜剧情的核心内容和情感
4. 姿态合理性：角色姿态是否体现动作的起始瞬间
5. 光线质量：光线是否自然、合理、有层次
6. 色调氛围：色调是否符合分镜设定的氛围（日/夜、暖/冷等）
7. 构图美感：构图是否平衡、美观、符合影视镜头语言
8. 图片质量：无模糊、无畸变、无明显瑕疵
9. 细节完整：画面细节丰富，无缺失或残缺
10. 无无关元素：无文字、水印、标签等无关内容

【排除原则】
以下情况必须排除：
- 角色服装颜色与描述严重不符
- 角色发型/面孔与描述严重不符
- 场景环境与描述严重不符
- 角色数量错误（多或少）
- 光线过暗或过亮导致无法看清内容
- 构图严重偏斜导致主体不清晰
- 出现文字/水印/标签等无关元素

请输出纯JSON格式（不要用```包裹）：
{{
  "selected_index": 0到{num_images_minus_1}之间的整数,
  "reason": "选择该图片的主要原因",
  "score": 1-10,
  "issues": ["该图片存在的问题列表，如果完美则为空数组"]
}}

selected_index 必须是从 0 到 {num_images_minus_1} 的整数，表示你选择的图片编号。

You are a professional AI image prompt engineer.
I need to generate a **first-frame reference image** for a {duration}-second video clip.

Shot plot description:
{plot}

Shot visual description:
{visual_prompt}

Requirements:
1. Output a pure English image generation prompt for an AI image model
2. Describe the **first frame** (static image) of the video, capturing the starting moment
3. Must include: character appearance/pose/expression, environment, lighting/color tone, composition/shot type
4. For {duration}s video: {duration_hint}
5. 80-150 English words
6. Output ONLY the prompt text, no explanations or markers

你是一位专业的AI绘画提示词工程师。
我需要为一段{duration}秒的视频生成**首帧参考图**。

分镜剧情描述：
{plot}

分镜视觉描述：
{visual_prompt}

要求：
1. 输出一段纯英文的图像生成提示词(image prompt)，用于AI绘图模型
2. 描述的是视频**第一帧**的静态画面，要体现动作的起始瞬间
3. 必须包含：角色外貌/姿态/表情、场景环境、光线/色调、构图/景别
4. {duration}秒视频：{duration_hint}
5. 字数控制在80-150个英文单词
6. 只输出提示词文本，不要任何解释或标记

You are a Hollywood screenwriting mentor. Break down the following storyline into a 4-act structure using the Save the Cat! Beat Sheet.

Must include these four key beats:
Act 1 - Inciting Incident: Establish the world and protagonist's status quo, then a disruptive event
Act 2 - Break into Two: Protagonist embarks on journey, faces challenges, B-story unfolds
Act 3 - Dark Night of the Soul: Protagonist suffers the biggest blow, hits rock bottom
Act 4 - Finale: Protagonist gains epiphany, final confrontation, story resolves

Ensure: tight logic, escalating conflict, clear turning points in each act.

Storyline:
{draft}

Story style: {style}

Output the 4-act beat sheet directly. Start each act with '[Act X - Name]' heading. Detail the plot points, character development and key turning points for each act.

你是好莱坞编剧导师。请根据以下故事线，使用 Save the Cat! 节拍表将故事拆解为四幕结构。

必须包含以下四个关键节拍（起承转合）：
第一幕 - 激励事件（Inciting Incident）：建立世界观和主角现状，发生打破平衡的事件
第二幕 - 进入新世界（Break into Two）：主角踏上旅程，面对挑战和考验，副线展开
第三幕 - 灵魂黑夜（Dark Night of the Soul）：主角遭受最大打击，陷入低谷
第四幕 - 高潮决战（Finale）：主角获得顿悟，最终决战，故事收束

请确保：逻辑严密、冲突逐步升级、每一幕有清晰的转折点。

故事线：
{draft}

故事风格：{style}

请直接输出四幕节拍表，每一幕用"【第X幕 - 名称】"标记开始，详细描述该幕的情节要点、角色发展和关键转折。

You are a micro-film screenwriting expert. Compress the following storyline into a compact single-act plot summary.

Requirements:
- Fast narrative pacing, concise and tight plot
- All content in a single act, no act divisions
- Keep core conflict and emotional turns, remove unnecessary setup
- 3-6 scenes total
- Suitable for a 1-3 minute short film

Storyline:
{draft}

Story style: {style}

Output a compact plot summary directly, describing scene progression, core actions and emotional shifts.

你是微电影编剧专家。请根据以下故事线，将故事压缩为一个紧凑的单幕剧情概要。

要求：
- 叙事节奏快，情节紧凑精炼，没有拖沓的铺垫
- 全部内容在一幕内完成，不分幕
- 保留核心冲突和情感转折，去掉多余叙事
- 场景数量控制在 3-6 场
- 适合 1-3 分钟的微电影

故事线：
{draft}

故事风格：{style}

请直接输出紧凑的剧情概要，描述场景发展、核心动作和情感转折。

你是微电影编剧专家。请根据以下故事线，将故事压缩为一个紧凑的单幕剧情概要。

{draft}

故事风格：{style}

请将其转化为详细的分场大纲。

格式要求（每场一段）：
[场次编号]. [地点(室内/室外)] - [日/夜]
[核心动作]：详细描述该场戏发生了什么，包含完整的对话、动作和表情描写。
[情感转变]：描述主角在本场戏开始到结束的情绪变化（+/-）。
[出场角色]：列出本场出现的所有角色。

要求：
- 每个角色都要有详细的外貌描写（发型、眼睛颜色、体型、服装颜色和款式等视觉特征）
- **重要：外貌描写必须是静态的、贯穿全剧保持一致的特征，不要随剧情发展而变化**
  - 例如：不要写"他穿着破碎的衣服"这种随情节变化的描写
  - 应该写："他身穿蓝色衬衫，黑色长裤"这种固定的服装描述
- 每个场景都要有详细的环境、布局、色彩与氛围描写
- 分场数量根据情节长度和节奏自行决定，确保叙事节奏合理
- 对话用双引号标注，对话内容真实生动
- 场次编号从 1 开始递增

请直接输出分场大纲。

You are a scene director. Here is the complete 4-act beat sheet:

{beat_sheet}

Convert Act {act_number} ({act_name}) into a detailed step outline.

Format for each scene:
[Scene number]. [Location (Indoor/Outdoor)] - [Day/Night]
[Core Action]: Detailed description of what happens, including dialogue, actions and expressions.
[Emotional Shift]: Describe the protagonist's emotional change from start to end (+/-).
[Characters Present]: List all characters appearing in this scene.

Requirements:
- Each character needs detailed physical descriptions (hair, eyes, build, clothing details)
- **IMPORTANT: Physical descriptions must be STATIC and consistent throughout the entire story - do NOT change with plot development**
  - For example: do NOT write "wearing torn clothes" which changes with the plot
  - Instead write: "wearing a blue shirt and black pants" which is a fixed clothing description
- Each scene needs detailed environment, layout, color and atmosphere descriptions
- Number of scenes based on plot length and pacing
- Dialogue marked with double quotes, natural and vivid
- Scene numbers start from {scene_start} and increment
- Story style: {style}

Output the step outline directly, without act headings or extra notes.

你是分场导演。以下是完整的四幕节拍表：

{beat_sheet}

请将第{act_number}幕（{act_name}）转化为详细的分场大纲。

格式要求（每场一段）：
[场次编号]. [地点(室内/室外)] - [日/夜]
[核心动作]：详细描述该场戏发生了什么，包含完整的对话、动作和表情描写。
[情感转变]：描述主角在本场戏开始到结束的情绪变化（+/-）。
[出场角色]：列出本场出现的所有角色。

要求：
- 每个角色都要有详细的外貌描写（发型、眼睛颜色、体型、服装颜色和款式等视觉特征）
- **重要：外貌描写必须是静态的、贯穿全剧保持一致的特征，不要随剧情发展而变化**
  - 例如：不要写"他穿着破碎的衣服"这种随情节变化的描写
  - 应该写："他身穿蓝色衬衫，黑色长裤"这种固定的服装描述
- 每个场景都要有详细的环境、布局、色彩与氛围描写
- 分场数量根据情节长度和节奏自行决定，确保叙事节奏合理
- 对话用双引号标注，对话内容真实生动
- 场次编号从 {scene_start} 开始递增
- 故事风格：{style}

请直接输出分场大纲，不要添加幕次标题或额外说明。

你是专业的剧本分析师和AI绘画提示词工程师。请审查以下角色列表，识别需要修改或删除的角色。

角色列表：
{characters_json}

审查标准：
1. 群体角色（如"邻居们"、"群众"、"乘客们"、"学生们"）应该删除，改为在场景描述中用一句话表示（如"车厢里坐满了乘客"）
2. 角色描述必须包含足够的视觉细节用于AI图像生成：
   - 外貌：发型、眼睛颜色、面部特征、体型
   - 服装：颜色、款式、材质配饰：帽子
   - 、眼镜、珠宝等
3. 避免抽象比喻（如"看起来很凶"），要具体描述

请输出纯JSON（不要用```包裹），格式如下：
{{
  "characters_to_remove": ["需要删除的角色名1", "角色名2", ...],
  "characters_to_fix": [
    {{
      "name": "角色名",
      "issue": "问题描述",
      "fix_suggestion": "修改建议"
    }}
  ]
}}

如果没有需要删除的角色，characters_to_remove 返回空数组 []。
如果没有需要修改的角色，characters_to_fix 返回空数组 []。
只输出纯JSON，不要添加任何其他文字。

你是专业的剧本分析师和AI绘画提示词工程师。请审查以下场景列表，识别需要修改的场景。

场景列表：
{settings_json}

审查标准：
1. 场景描述必须包含足够的视觉细节用于AI图像生成：
   - 空间布局：室内/室外、主要物体位置
   - 光线：自然光/人工光、光源方向、亮度
   - 色彩：主色调、氛围
   - 构图：景别、视角
2. 场景应该是具体的、可视觉化的地点
3. 避免过于笼统的描述（如"某个地方"）

请输出纯JSON（不要用```包裹），格式如下：
{{
  "settings_to_fix": [
    {{
      "name": "场景名",
      "issue": "问题描述",
      "fix_suggestion": "修改建议"
    }}
  ]
}}

如果没有需要修改的场景，settings_to_fix 返回空数组 []。
只输出纯JSON，不要添加任何其他文字。

你是一个专业的AI图像质量评估师。请从以下{num_images}张场景设计图中选择最好的一张。

场景名称：{setting_name}
场景描述：{setting_description}

图片列表：
{images_list}

请严格按照以下标准评估并选择最好的一张：

【评分标准】
满分10分，每个检查项符合得1分，不符合扣1分，最高10分：

1. 地点一致性（+1/-1）：场景地点是否与描述一致
2. 布局还原（+1/-1）：场景布局、物品摆放是否与描述一致
3. 光线氛围（+1/-1）：光线是否与描述一致（日/夜、暖/冷）
4. 色彩还原（+1/-1）：场景色彩是否与描述一致
5. 风格一致性（+1/-1）：整体风格是否符合设定（室内/室外、年代感等）
6. 细节完整（+1/-1）：细节是否丰富，无明显缺失
7. 空间感（+1/-1）：空间透视是否合理
8. 构图质量（+1/-1）：构图是否均衡、美观
9. 图片质量（+1/-1）：清晰度良好，无模糊、无畸变
10. 无无关元素（+1/-1）：无文字、水印、标签等无关内容

【最终选择规则】
- 选择分数最高的一张作为最终选择
- 如果最高分有多张相同，选择第一张

请输出纯JSON格式（不要用```包裹）：
{{
  "scores": [
    {{"image_index": 0, "score": 8, "reasons": ["原因1", "原因2"]}},
    {{"image_index": 1, "score": 6, "reasons": ["原因1"]}},
    ...
  ],
  "best_index": 0,
  "best_reason": "选择这张的原因"
}}

你是一个专业的AI图像质量评估师。请根据以下信息评估生成的场景参考图。

场景描述：
{setting_description}

请严格按照以下标准评估并给出1-10分：

【评分标准】
满分10分，每个检查项符合得1分，不符合扣1分，最高10分：

1. 地点一致性（+1/-1）：场景地点是否与描述一致
2. 布局还原（+1/-1）：场景布局、物品摆放是否与描述一致
3. 光线氛围（+1/-1）：光线是否与描述一致（日/夜、暖/冷）
4. 色彩还原（+1/-1）：场景色彩是否与描述一致
5. 风格一致性（+1/-1）：整体风格是否符合设定（室内/室外、年代感等）
6. 细节完整（+1/-1）：细节是否丰富，无明显缺失
7. 空间感（+1/-1）：空间透视是否合理
8. 构图质量（+1/-1）：构图是否均衡、美观
9. 图片质量（+1/-1）：清晰度良好，无模糊、无畸变
10. 无无关元素（+1/-1）：无文字、水印、标签等无关内容

【扣分项】（发现以下问题必须扣分并在issues中列出）：
- 场景地点与描述不符：-1分
- 光线氛围与描述不符：-1分
- 出现不需要的元素：-1分
- 构图严重偏斜：-1分
- 出现文字/水印：-1分

【最终评分规则】
- 8分及以上：可接受（is_acceptable: true）
- 7分及以下：需要重新生成（is_acceptable: false）

请输出纯JSON格式（不要用```包裹）：
{{
  "score": 1-10,
  "issues": ["问题1", "问题2", ...],
  "is_acceptable": true/false,
  "suggestion": "修改建议（如果有问题）"
}}

如果图片可接受，issues 返回空数组 []。

# Setting Scene Prompt Templates
# 场景背景图提示词模板（按风格分类）
# 使用方式：根据 {style} 变量选择对应的模板

# ============================================================
# realistic - 写实摄影风格
# ============================================================
[realistic]
Photorealistic landscape photography, actual photograph style.
Wide establishing shot, eye-level view, panoramic perspective.
Natural lighting, golden hour or blue hour atmosphere, realistic textures.
No characters, no people, no animals in frame.
Cinematic composition, movie scene quality, 8K resolution.
High quality photography, sharp focus, wide angle lens, f/8, professional camera.
True-to-life environment, detailed textures, atmospheric depth.
NO text, NO labels, NO watermarks on image.
NOT an illustration, NOT a drawing, NOT anime style.
Scene: {name} — {desc}

# ============================================================
# anime - 动漫风格
# ============================================================
[anime]
Anime style landscape illustration, clean vector art aesthetic.
Wide establishing shot, eye-level view, panoramic perspective.
Vibrant colors, cel-shaded rendering, anime background art style.
No characters, no people, no animals in frame.
Cinematic composition, high quality anime illustration, masterpiece.
Crisp details, atmospheric background, anime movie quality.
NO text, NO labels, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# comic-book - 漫画风格
# ============================================================
[comic-book]
Comic book style landscape, comic panel art aesthetic.
Wide establishing shot, eye-level view, dynamic perspective.
Bold ink lines, comic shading (hatching/cross-hatching), vibrant colors.
No characters, no people, no animals in frame.
Comic book art style, dramatic lighting, comic panel composition.
High quality comic illustration, vibrant ink colors, graphic novel aesthetic.
NO text, NO speech bubbles, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# 3d-disney - 迪士尼3D风格
# ============================================================
[3d-disney]
3D CGI animated movie style landscape, Disney Pixar aesthetic.
Wide establishing shot, eye-level view, smooth 3D geometry.
Toon shader rendering, soft shadows, cinematic lighting, feature film quality.
No characters, no people, no animals in frame.
Disney Pixar CGI quality, clean 3D environment, volumetric lighting.
High quality 3D render, animated movie background, toon shading.
NO text, NO labels, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# watercolor - 水彩风格
# ============================================================
[watercolor]
Watercolor painting style landscape, painterly art aesthetic.
Wide establishing shot, eye-level view, soft perspective.
Flowing color washes, delicate brush strokes, translucent layers.
No characters, no people, no animals in frame.
Watercolor art style, organic color blending, artistic masterpiece.
Soft texture, artistic render, traditional painting aesthetic.
NO text, NO labels, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# oil-painting - 油画风格
# ============================================================
[oil-painting]
Oil painting style landscape, classical fine art aesthetic.
Wide establishing shot, eye-level view, classical composition.
Rich oil paint texture, impasto brushwork, classical portraiture technique.
No characters, no people, no animals in frame.
Oil painting art style, dramatic chiaroscuro lighting, museum-quality masterpiece.
Deep colors, detailed brushwork, traditional canvas texture.
NO text, NO labels, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# cyberpunk - 赛博朋克风格
# ============================================================
[cyberpunk]
Cyberpunk style landscape, futuristic sci-fi aesthetic.
Wide establishing shot, eye-level view, dystopian perspective.
Neon lighting, chrome/metallic surfaces, holographic elements, RGB accents.
No characters, no people, no animals in frame.
Cyberpunk cityscape, high-tech environment, volumetric fog.
High quality cyberpunk illustration, sci-fi concept art, futuristic aesthetic.
NO text, NO HUD elements, NO watermarks on image.
Scene: {name} — {desc}

# ============================================================
# chinese-ink - 中国水墨风格
# ============================================================
[chinese-ink]
Chinese ink painting (水墨画) style landscape, traditional East Asian art aesthetic.
Wide establishing shot, eye-level view, traditional Chinese composition.
Ink wash (墨色) rendering, Gongbi/Boneless brush technique, subtle ink gradients.
No characters, no people, no animals in frame.
Chinese landscape painting style, rice paper texture, traditional scroll art.
High quality ink painting, elegant brushwork, classical Chinese aesthetics.
NO text, NO seals/stamps, NO watermarks on image.
Scene: {name} — {desc}

Panoramic landscape, eye-level wide shot, {style} style,
no characters, no people, no animals,
cinematic composition, establishing shot,
high quality, masterpiece, Movie picture quality.
Scene: {name} — {desc}

你是一位专业的影视编剧。根据已有的剧情内容，续写接下来的故事情节。

已有剧情信息：
- 标题：{title}
- 风格：{style}
- 角色：{characters}
- 场景位置：{settings}

当前分镜列表：
{existing_shots}

请根据以上信息，续写1个新场景（包含多个分镜，总时长40-60秒）。

要求：
1. 新场景要承接上文剧情自然发展
2. 分镜时长为 5、10 或 15 秒
3. 包含4-8个分镜，总时长控制在40-60秒
4. 每个分镜描述一个独立的画面段落
5. plot 字段必须按时间顺序描述：角色动作、表情、对话(用引号标注)、背景音效
6. visual_prompt 字段是适合AI图像生成的视觉描述，包含角色站位、姿态、表情、环境光线，色调、构图
7. 保持{style}风格
8. 用角色全名，不要用代词
9. location 字段必须从上面给出的"场景位置"中选择一个，名称必须完全一致，不能有任何修改或添加

请直接输出JSON数组（不要用```包裹），每个元素格式如下：
[{{"shot_number":1,"duration":5,"characters":["角色名"],"location":"场景位置","plot":"按时间顺序描述: 角色动作、表情、对话、背景音效，50-100字","visual_prompt":"AI图像生成用的视觉描述，含站位、姿态、表情，光线、构图，80-120字"}}]

注意：
- duration只能是5、10、15三个值之一
- 新场景的 scene_number 应该延续上一个场景的编号
- 新场景应该延续当前幕(act)的内容，或者开启新一幕(如果故事需要)
- 新场景中出现的人物、场景位置必须与上面给出的完全一致，禁止添加额外的人物或场景位置

你是一位专业的影视分镜师。根据以下场景信息，将该场景拆分为若干分镜（shot）。

要求：
1. 每个分镜时长为 5、10 或 15 秒（根据内容复杂度选择）
2. 每个分镜描述一个独立的画面段落（一个动作/一句对话/一个反应）
3. plot 字段必须按时间顺序描述：角色动作、表情、对话(用引号标注)、背景音效
4. visual_prompt 字段是适合AI图像生成的视觉描述，包含角色站位、姿态、表情、环境光线、色调、构图
5. 保持{style}风格
6. 用角色全名，不要用代词

场景编号：{scene_number}
场景位置：{location}
出场角色：{characters}
场景剧情：{plot}

角色外貌参考：
{char_descriptions}

场景环境参考：
{setting_description}

请直接输出JSON数组（不要用```包裹），每个元素格式如下：
[{{"shot_number":1,"duration":5,"characters":["角色名"],"location":"场景位置","plot":"按时间顺序描述: 角色动作、表情、对话、背景音效，50-100字","visual_prompt":"AI图像生成用的视觉描述，含站位、姿态、表情、光线、构图，80-120字"}}]

注意：duration只能是5、10、15三个值之一。

# 视频生成提示词优化模板
# 在基础提示词前后添加这些内容来提升生成质量
# 使用方法：从 prompts/loader import load_prompt('video', 'enhance', 'zh')

[prefix]
high quality, 4K, detailed, cinematic footage, film style, smooth motion, natural movement, professional camera work,

[suffix]
, realistic, high definition, no blur, no distortion, no artifacts, perfect composition, professional lighting, film grain, masterpiece

# 风格关键词（会自动从会话中读取项目风格并添加对应关键词）
[style_keywords]
anime: anime style, animated, cel-shaded, vibrant colors, manga aesthetic,
cartoon: cartoon style, animated, colorful, fun, children's book illustration,
realistic: photorealistic, realistic, natural lighting, detailed textures, cinema photography,
photorealistic: photorealistic, realistic, natural lighting, detailed textures, cinema photography,
3d-disney: 3D animation, Disney style, pixar, CGI, smooth textures, computer generated,
3d: 3D animation, CGI, computer generated, smooth textures, digital cinema,
oil-painting: oil painting style, impasto, classical art, painterly, rich brushstrokes,
watercolor: watercolor style, delicate, soft colors, artistic, flowing,
comic-book: comic book style, vibrant, bold outlines, pop art, graphic novel,
cyberpunk: cyberpunk, neon lights, futuristic, dark atmosphere, sci-fi,
chinese-ink: Chinese ink painting style, traditional, minimalist, brush strokes, oriental art,
ink: Chinese ink painting style, traditional, minimalist, brush strokes, oriental art,

export { default as ScriptStage } from './ScriptStage';
export { default as CharacterStage } from './CharacterStage';
export { default as StoryboardStage } from './StoryboardStage';
export { default as ReferenceStage } from './ReferenceStage';
export { default as VideoStage } from './VideoStage';
export { default as PostProductionStage } from './PostProductionStage';
export type { StageState, StageStatus, StageViewProps } from './types';

export type StageStatus = 'pending' | 'running' | 'waiting' | 'completed' | 'error';

export interface StageState {
  status: StageStatus;
  progress: number;
  progressMessage: string;
  artifact: any;
  error: string | null;
}

export interface StageViewProps {
  state: StageState;
  sessionId: string;
  onConfirm: () => void;
  onIntervene: (modifications: Record<string, any>) => void;
  onRegenerate: () => void;
  onUpdateArtifact?: (patch: Record<string, any>) => void;
  onSaveSelections?: (selections: Record<string, any>) => Promise<void>;
  /** 是否显示"确认并继续"按钮（后续阶段已执行过时为 false） */
  showConfirm?: boolean;
  isRunning: boolean;
  /** 是否有待生成的项（阶段2、4、5使用） */
  hasPendingItems?: boolean;
  /** 后续阶段是否已开始（阶段1、3使用） */
  hasNextStageStarted?: boolean;
  /** 视频生成参数（仅 VideoStage 使用） */
  videoSound?: string;
  videoShotType?: string;
  onVideoParamsChange?: (params: { videoSound?: string; videoShotType?: string }) => void;
  /** 参考图阶段的 artifact（仅 VideoStage 使用，用于检查依赖） */
  referenceArtifact?: any;
}

/**
 * 阶段数据工具函数
 * - 路径转 URL
 * - 剧本/分镜结构化文本解析与重建
 */

/** 将后端本地文件路径转换为浏览器可访问的 URL */
export function assetUrl(path: string): string {
  if (!path) return '';
  if (path.startsWith('http') || path.startsWith('/') || path.startsWith('blob:') || path.startsWith('data:')) return path;
  return '/' + path;
}

/* ─── 剧本 / 分镜 结构化文本解析 ─── */

export interface ParsedCharacter {
  name: string;
  description: string;
}

export interface ParsedSetting {
  name: string;
  description: string;
}

export interface ParsedScene {
  id: string;
  characters: string[];
  settings: string[];
  description: string;
  raw: string;
}

export interface ParsedScript {
  characters: ParsedCharacter[];
  settings: ParsedSetting[];
  scenes: ParsedScene[];
  isZh: boolean;
}

/** 解析结构化剧本/分镜文本 → 角色 + 场景 + 故事线 */
export function parseScriptText(text: string): ParsedScript {
  if (!text) return { characters: [], settings: [], scenes: [], isZh: false };

  const normalized = text.replace(/\\n/g, '\n');
  const isZh = /角色[:：]|场景设置[:：]|视频片段/.test(normalized);

  const charHeader = isZh ? /角色[:：]/ : /Characters[:：]/;
  const settingHeader = isZh ? /场景设置[:：]/ : /Settings[:：]/;
  const sceneHeader = isZh ? /视频片段[:：]/ : /Scenes[:：]/;

  function findMatch(src: string, pat: RegExp) {
    const m = src.match(pat);
    return m ? { index: src.indexOf(m[0]), length: m[0].length } : null;
  }

  function extractBlock(src: string, startPat: RegExp, endPat: RegExp | null): string {
    const sm = findMatch(src, startPat);
    if (!sm) return '';
    const sp = sm.index + sm.length;
    if (endPat) {
      const em = findMatch(src.slice(sp), endPat);
      return em ? src.slice(sp, sp + em.index) : src.slice(sp);
    }
    return src.slice(sp);
  }

  const charBlock = extractBlock(normalized, charHeader, settingHeader).trim();
  const settingBlock = extractBlock(normalized, settingHeader, sceneHeader).trim();
  const sceneBlock = extractBlock(normalized, sceneHeader, null).trim();

  const characters: ParsedCharacter[] = [];
  for (const line of charBlock.split('\n')) {
    const t = line.trim();
    if (!t) continue;
    const ci = t.search(/[:：]/);
    if (ci > 0) {
      characters.push({
        name: t.slice(0, ci).trim(),
        description: t.slice(ci + 1).trim().replace(/\.\s*$/, ''),
      });
    }
  }

  const settings: ParsedSetting[] = [];
  for (const line of settingBlock.split('\n')) {
    const t = line.trim();
    if (!t) continue;
    const ci = t.search(/[:：]/);
    if (ci > 0) {
      settings.push({
        name: t.slice(0, ci).trim(),
        description: t.slice(ci + 1).trim().replace(/\.\s*$/, ''),
      });
    }
  }

  const scenes: ParsedScene[] = [];
  const scenePat = isZh
    ? /^视频片段\s*(\d+)\s*[:：]\s*(.*)/
    : /^Scene\s+(\d+)\s*[:：]\s*(.*)/i;

  for (const line of sceneBlock.split('\n')) {
    const m = line.trim().match(scenePat);
    if (m) {
      const raw = m[2];
      const cm = raw.match(/\[(?:Characters|角色)\s*[:：]\s*([^\]]+)\]/i);
      const sm2 = raw.match(/\[(?:Settings|场景(?:设置)?)\s*[:：]\s*([^\]]+)\]/i);
      const chars = cm ? cm[1].split(/[,，]/).map(s => s.trim()).filter(Boolean) : [];
      const sets = sm2 ? sm2[1].split(/[,，]/).map(s => s.trim()).filter(Boolean) : [];
      const desc = raw.replace(/\[.*?\]/g, '').trim();
      scenes.push({ id: m[1], characters: chars, settings: sets, description: desc, raw });
    }
  }

  return { characters, settings, scenes, isZh };
}

/** 将解析后的结构重建为标准文本格式 */
export function reconstructScriptText(parsed: ParsedScript): string {
  const { isZh, characters, settings, scenes } = parsed;
  const charH = isZh ? '角色:' : 'Characters:';
  const settH = isZh ? '场景设置:' : 'Settings:';
  const sceneH = isZh ? '视频片段:' : 'Scenes:';
  const scenePrefix = isZh ? '视频片段' : 'Scene';
  const charLabel = isZh ? '角色' : 'Characters';
  const settLabel = isZh ? '场景' : 'Settings';

  const lines: string[] = [];
  lines.push(charH);
  for (const c of characters) {
    lines.push(`${c.name}: ${c.description}`);
  }
  lines.push(settH);
  for (const s of settings) {
    lines.push(`${s.name}: ${s.description}`);
  }
  lines.push(sceneH);
  for (const sc of scenes) {
    const cp = sc.characters.length ? `[${charLabel}: ${sc.characters.join(', ')}]` : '';
    const sp = sc.settings.length ? `[${settLabel}: ${sc.settings.join(', ')}]` : '';
    const parts = [`${scenePrefix} ${sc.id}:`, cp, sp, sc.description].filter(Boolean);
    lines.push(parts.join(' '));
  }
  return lines.join('\n');
}