mp_audio_manage/app/Http/Controllers/Anime/AnimeController.php

<?php

namespace App\Http\Controllers\Anime;

use App\Transformer\Anime\AnimeTransformer;
use App\Facade\Site;
use App\Consts\ErrorConst;
use App\Exceptions\ApiException;
use App\Libs\ApiResponse;
use App\Libs\Utils;
use App\Models\MpGenerateVideoTask;
use App\Services\AIGeneration\AIImageGenerationService;
use App\Services\AIGeneration\AIVideoGenerationService;
use App\Services\Anime\AnimeService;
use App\Services\PointsService;
use App\Services\TaskCenterService;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller as BaseController;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;
use Illuminate\Support\Facades\Validator;

class AnimeController extends BaseController
{
    use ApiResponse;
    protected $AnimeService;
    protected $AIImageGenerationService;
    protected $AIVideoGenerationService;
    protected $pointsService;
    protected $taskCenterService;

    public function __construct(
        AnimeService $AnimeService,
        AIImageGenerationService $AIImageGenerationService,
        AIVideoGenerationService $AIVideoGenerationService,
        PointsService $pointsService,
        TaskCenterService $taskCenterService
    ) {
        $this->AnimeService = $AnimeService;
        $this->AIImageGenerationService = $AIImageGenerationService;
        $this->AIVideoGenerationService = $AIVideoGenerationService;
        $this->pointsService = $pointsService;
        $this->taskCenterService = $taskCenterService;
    }

    // 文字模型
    public function textModel() {
        $query = DB::table('mp_text_models')->where('is_enabled', 1);
        
        // 支持 model 搜索
        if ($model = request('model')) {
            $query->where('model', 'like', "%{$model}%");
        }
        
        // 支持 name 搜索
        if ($name = request('name')) {
            $query->where('name', 'like', "%{$name}%");
        }

        $is_multimodal = request('is_multimodal');
        if ($is_multimodal !== null) {
            $query->where('is_multimodal', $is_multimodal);
        }
        
        $models = $query->select('model', 'name', 'is_multimodal')->orderBy('order', 'desc')->orderBy('id', 'desc')->get()->map(function ($value) {
            return (array)$value;
        })->toArray();
        
        return $this->success($models);
    }

    // 图片模型
    public function imageModel() {
        $query = DB::table('mp_image_models')->where('is_enabled', 1);
        
        // 支持 model 搜索
        if ($model = request('model')) {
            $query->where('model', 'like', "%{$model}%");
        }
        
        // 支持 name 搜索
        if ($name = request('name')) {
            $query->where('name', 'like', "%{$name}%");
        }

        $is_multimodal = request('is_multimodal');
        if ($is_multimodal !== null) {
            $query->where('is_multimodal', $is_multimodal);
        }
        
        $models = $query->select('model', 'name', 'is_multimodal')->orderBy('order', 'desc')->orderBy('id', 'desc')->get()->map(function ($value) {
            return (array)$value;
        })->toArray();
        
        return $this->success($models);
    }

    // 视频模型
    public function videoModel() {
        $query = DB::table('mp_video_models')->where('is_enabled', 1);
        
        // 支持 model 搜索
        if ($model = request('model')) {
            $query->where('model', 'like', "%{$model}%");
        }
        
        // 支持 name 搜索
        if ($name = request('name')) {
            $query->where('name', 'like', "%{$name}%");
        }

        $is_multimodal = request('is_multimodal');
        if ($is_multimodal !== null) {
            $query->where('is_multimodal', $is_multimodal);
        }
        
        $models = $query->select('model', 'name', 'is_multimodal')->orderBy('order', 'desc')->orderBy('id', 'desc')->get()->map(function ($value) {
            return (array)$value;
        })->toArray();
        
        return $this->success($models);
    }

    public function artStyleList()
    {
        $result = [
            [
                'art_style' => '唯美真人风格',
                'pic_url' => "http://zw-ai.oss-cn-hangzhou.aliyuncs.com/mp_audio/art_styles/%E5%94%AF%E7%BE%8E%E7%9C%9F%E4%BA%BA.jpg"
            ],
            [
                'art_style' => '真人古风风格',
                'pic_url' => "http://zw-ai.oss-cn-hangzhou.aliyuncs.com/mp_audio/art_styles/%E7%9C%9F%E4%BA%BA%E5%8F%A4%E9%A3%8E.jpg"
            ],
            [
                'art_style' => '3D真人风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/3D真人风格.png"
            ],
            [
                'art_style' => '日系动漫风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/日系动漫风格.jpg"
            ],
            [
                'art_style' => '国漫风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/国漫风格.jpg"
            ],
            [
                'art_style' => 'Q版卡通风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/Q版卡通风格.jpg"
            ],
            [
                'art_style' => '简约扁平风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/简约扁平风格.jpg"
            ],
            [
                'art_style' => '古风仙侠风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/古风仙侠风格.jpg"
            ],
            [
                'art_style' => '武侠风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/武侠风格.jpg"
            ],
            [
                'art_style' => '新中式水墨风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/新中式水墨风格.jpg"
            ],
            [
                'art_style' => '写实插画风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/写实插画风格.jpg"
            ],
            [
                'art_style' => '3D卡通风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/3D卡通风格.jpg"
            ],
            [
                'art_style' => '条漫风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/条漫风格.jpg"
            ],
            [
                'art_style' => '赛博朋克风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/赛博朋克风格.jpg"
            ],
            [
                'art_style' => '暗黑悬疑风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/暗黑悬疑风格.jpg"
            ],
            [
                'art_style' => '治愈清新风格',
                'pic_url' => "https://cdn-zwai.ycsd.cn/mp_audio/art_styles/治愈清新风格.jpg"
            ],
        ];

        return $this->success($result);
    }

    // 新建动漫
    public function createAnime(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->createAnime($data);
        return $this->success(['anime_id' => $result]);
    }

    // 编辑动漫
    public function editAnime(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->editAnime($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 删除动漫
    public function delAnime(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->delAnime($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 批量生成主体图片
    public function batchSetRoleImg(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->batchSetRoleImg($data);
        return $this->success($result);
    }

    // 批量生成场景图片
    public function batchSetSceneImg(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->batchSetSceneImg($data);
        return $this->success($result);
    }

    // 修改分集主体列表
    public function changeEpisodeRoles(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->changeEpisodeRoles($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 修改分集场景列表
    public function changeEpisodeScenes(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->changeEpisodeScenes($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 修改分集道具列表
    public function changeEpisodeProps(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->changeEpisodeProps($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 编辑分镜剧本
    public function editSegment(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->editSegment($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 动漫对话列表
    public function chatList(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->chatList($data);
        return $this->success($result, [new AnimeTransformer(), 'newBuildChatList']);
    }

    // 动漫对话历史记录
    public function chatHistory(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->chatHistory($data);
        return $this->success($result);
    }

    // 动漫大纲
    public function animeDetail(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->animeDetail($data);
        return $this->success($result);
    }

    // 动漫剧集
    public function episodeInfo(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->episodeInfo($data);
        return $this->success($result);
    }

    // 动漫剧集(全能模式)
    public function episodeInfoForAce(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->episodeInfoForAce($data);
        return $this->success($result);
    }

    // 分镜信息
    public function segmentInfo(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->segmentInfo($data);
        return $this->success($result);
    }

    // 复制剧集副本
    public function copyEpisodeVersion(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->copyEpisodeVersion($data);
        return $this->success($result);
    }

    // 剧集副本列表
    public function episodeVersions(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->episodeVersions($data);
        return $this->success($result);
    }

    // 绑定剧集副本
    public function bindEpisodeVersion(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->bindEpisodeVersion($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }

    // 对话改图
    public function chatChangeImg(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->chatChangeImg($data);
        return $this->success(['img_url' => $result]);
    }

    public function segmentChatHistory(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->segmentChatHistory($data);
        return $this->success($result);
    }

    // 一键生成分镜
    public function batchSetSegmentPics(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->batchSetSegmentPics($data);
        return $this->success($result);
    }

    // 重新生成分镜
    public function reGenerateSegment(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->reGenerateSegment($data);
        return $this->success(['img_url'=>$result]);
    }

    // 添加分镜
    public function addSegment(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->addSegment($data);
        return $this->success($result);
    }

    // 复制分镜
    public function copySegment(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->copySegment($data);
        return $this->success($result);
    }

    // 移动分镜
    public function moveSegment(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->moveSegment($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    // 删除分镜
    public function delSegment(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->delSegment($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    public function applySegment(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->applySegment($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    // 添加片段
    public function addAct(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->addAct($data);
        return $this->success($result);
    }

    // 编辑片段
    public function editAct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->editAct($data);
        return $this->success($result);
    }

    // 复制片段
    public function copyAct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->copyAct($data);
        return $this->success($result);
    }

    // 移动片段
    public function moveAct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->moveAct($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    // 删除片段
    public function delAct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->delAct($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    // 应用片段
    public function applyAct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->applyAct($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    // 片段对话历史记录
    public function actChatHistory(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->actChatHistory($data);
        return $this->success($result);
    }

    // 分镜历史图片|视频
    public function segmentHistory(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->segmentHistory($data);
        return $this->success($result);
    }

    public function createSegmentVideoTask(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'segment_id' => 'required|string',
            'tail_frame' => 'nullable|string|max:500',
        ], [
            'segment_id.required' => '分镜ID不能为空',
            'tail_frame.max' => '尾帧描述不能超过500个字符',
        ]);
        
        if ($validator->fails()) {
            Utils::throwError('1002:' . $validator->errors()->first());
        }
        
        // 创建视频生成任务
        $result = $this->AnimeService->createSegmentVideoTask($data);
        $taskId = $result['task_id'];
        
        // 设置 SSE 响应头
        return response()->stream(function () use ($taskId, $result) {
            // 设置 SSE 响应头
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => $result
            ]) . "\n\n";
            if (ob_get_level() > 0) {
                ob_flush();
            }
            flush();
            
            $startTime = time();
            $maxDuration = 1800; // 5分钟超时
            $checkInterval = 5; // 每5秒检查一次
            $lastTaskData = null; // 记录上一次推送的任务数据，仅在有变化时发送update
            $lastQueueMessageTime = time(); // 记录上次发送队列消息的时间
            $queueMessageInterval = 60; // 队列消息发送间隔（秒）
            
            while (time() - $startTime < $maxDuration) {
                try {
                    // 查询任务状态
                    $task = \App\Models\MpGenerateVideoTask::find($taskId);
                    if (!$task) {
                        echo "data: " . json_encode([
                            'type' => 'error',
                            'message' => '任务不存在'
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                        break;
                    }
                    
                    // 视频任务结果由定时任务实时更新，此处直接读取任务表状态
                    
                    // 构建当前任务数据
                    $taskData = [
                        'status' => $task->status,
                        'result_url' => $task->result_url,
                        'error_message' => $task->error_message ? mapErrorMessage($task->error_message) : ''
                    ];
                    
                    // 首次查询只记录状态，不发送update（init已推送任务创建信息）
                    if ($lastTaskData === null) {
                        $lastTaskData = $taskData;
                    } elseif ($taskData != $lastTaskData) {
                        $lastTaskData = $taskData;
                        
                        // 有数据更新才发送update
                        echo "data: " . json_encode([
                            'type' => 'update',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'result_url' => $task->result_url,
                                'error_message' => $task->error_message ? mapErrorMessage($task->error_message) : '',
                                'elapsed_time' => time() - $startTime
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                    }
                    
                    // 如果任务完成（成功或失败），结束连接
                    if (in_array($task->status, [
                        'success',
                        'failed'
                    ])) {
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'video_url' => $task->compressed_url ?: $task->result_url,
                                'origin_video_url' => $task->result_url,
                                'last_frame_url' => $task->last_frame_url,
                                'error_message' => $task->error_message ? mapErrorMessage($task->error_message) : ''
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                        break;
                    }
                    
                    // 每分钟发送一次队列状态消息
                    $currentTime = time();
                    if ($currentTime - $lastQueueMessageTime >= $queueMessageInterval) {
                        echo "data: " . json_encode([
                            'type' => 'queue',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'elapsed_time' => $currentTime - $startTime,
                                'message' => '任务正在队列中执行...'
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                        $lastQueueMessageTime = $currentTime;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage()
                    ]) . "\n\n";
                    if (ob_get_level() > 0) {
                        ob_flush();
                    }
                    flush();
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '任务执行超时，请稍后查询任务状态',
                    'data' => [
                        'task_id' => $taskId
                    ]
                ]) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    

    /**
     * 批量生成分镜视频
     */
    public function batchSetSegmentVideos(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'anime_id' => 'required|string',
            'episode_id' => 'required|integer',
        ], [
            'anime_id.required' => '动漫对话ID不能为空',
            'episode_id.required' => '剧集ID不能为空',
            'episode_id.integer' => '剧集ID必须是整数',
        ]);
        
        if ($validator->fails()) {
            Utils::throwError('1002:' . $validator->errors()->first());
        }
        
        $animeId = $data['anime_id'];
        $episodeId = $data['episode_id'];

        $episode = DB::table('mp_anime_episodes')->where('id', $episodeId)->where('anime_id', $animeId)->first();
        if (!$episode) Utils::throwError('20003:分集不存在');
        $episodeNumber = $episode->episode_number;        
        $ratio = !empty($episode->ratio) ? $episode->ratio : '9:16';
        $generate_audio = getProp($data, 'generate_audio', 0);
        
        // 处理视频模型（在循环外统一处理）
        $model = getProp($data, 'model');
        if (!$model) {
            // 用户没有输入，从episode表获取
            $model = getProp($episode, 'video_model');
            if (!$model) {
                // episode表也没有，使用默认值
                $model = 'doubao-seedance-1-5-pro-251215';
            }
        }
        // 验证模型是否在可用模型表中
        if (!DB::table('mp_video_models')->where('model', $model)->where('is_enabled', 1)->exists()) {
            $model = 'doubao-seedance-1-5-pro-251215';
        }
        
        // 获取所有分镜信息
        $segments = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->whereNotIn('video_task_status', ['已完成', '生成中'])
            ->orderBy('segment_number')
            ->get();
            
        if ($segments->isEmpty()) {
            Utils::throwError('20003:未找到分镜数据');
        }
        
        // 余额预检：按实际需要生成的分镜逐条按时长估算积分，不足直接报错
        $needPoints = 0;
        foreach ($segments as $segment) {
            if ((int)$segment->current_type === 2) {
                continue;
            }
            $duration = (int)ceil((float)$segment->audio_duration);
            if ($duration <= 0) {
                $duration = 5; // 无音频时长时按默认5秒预估
            }
            $needPoints += $this->pointsService->getVideoChargePoints([
                'model' => $model,
                'video_resolution' => '720p',
                'video_duration' => $duration,
                'ratio' => $ratio,
                'generate_audio' => (int)$generate_audio,
            ]);
        }
        if ($needPoints > 0) {
            $this->pointsService->checkUserPointsEnough($needPoints);
        }
        
        // 批量创建视频任务
        $taskIds = [];
        $segmentTasks = [];
        
        foreach ($segments as $segment) {
            try {
                // 检查视频任务正在生成中或当前状态为视频
                if ($segment->video_task_status === '生成中' || (int)$segment->current_type === 2) {
                    continue;
                }
                
                // 获取分镜内容
                $segmentContent = $segment->segment_content ?: '';
                $tailFrame = $segment->tail_frame ?: '';
                
                // 判断 $segmentContent 是否有台词内容，如果有则确保使用中文左右双引号
                $hasDialogue = false;
                if (preg_match('/(?:台词内容|台词|对白|对话)[：:]\s*([^\n]+)/u', $segmentContent, $dialogueMatch)) {
                    $dialogue = trim($dialogueMatch[1]);
                    
                    // 如果台词不为空且不是"无"
                    if (!empty($dialogue) && $dialogue !== '无') {
                        // 过滤掉所有符号（引号、标点、空格等），只保留文字内容来判断是否有实际台词
                        $dialogueFiltered = preg_replace('/[""\'\'，。！？、；：…—\-\s\p{P}\p{S}]/u', '', $dialogue);
                        if (!empty($dialogueFiltered) && $dialogueFiltered !== '无') {
                            $hasDialogue = true;
                        }
                        
                        $dialogue = preg_replace('/^["”]/u', '“', $dialogue);   // 替换句首英文双引号或中文右双引号
                        $dialogue = preg_replace('/["“]$/u', '”', $dialogue);   // 替换句尾英文双引号或中文左双引号
                        // 句首或句尾没有中文双引号,则分别添加中文左右双引号
                        if (!preg_match('/^[“]/', $dialogue)) {
                            $dialogue = '“' . $dialogue;
                        }
                        if (!preg_match('/[”]$/', $dialogue)) {
                            $dialogue .= '”';
                        }
                        
                        // 将修改后的台词替换回 $segmentContent
                        $originalDialogue = $dialogueMatch[1];
                        $segmentContent = str_replace($originalDialogue, $dialogue, $segmentContent);
                    }
                }
                
                // 检查 $segmentContent 中是否已有尾帧描述
                $contentHasTailFrame = preg_match('/(?:尾帧描述|尾帧)[：:]\s*([^\n]+)/u', $segmentContent, $contentTailFrameMatch);
                
                // 确定最终使用的尾帧描述（优先级：segmentContent自带 > 分镜表字段）
                $finalTailFrame = '';
                if ($contentHasTailFrame) {
                    // segmentContent 中有尾帧描述，使用它
                    $finalTailFrame = trim($contentTailFrameMatch[1]);
                } else {
                    // segmentContent 中没有，使用分镜表中的尾帧描述
                    $finalTailFrame = $tailFrame;
                }
                
                // 构建完整的提示词
                $fullPrompt = $segmentContent;
                if ($finalTailFrame && !$contentHasTailFrame) {
                    // 只有当 segmentContent 中没有尾帧描述时才追加
                    $fullPrompt .= "\n尾帧描述：$finalTailFrame";
                }
                
                // 去除多余的换行符（将连续多个换行符替换为单个换行符）
                $fullPrompt = preg_replace('/\n{2,}/', "\n", $fullPrompt);
                $fullPrompt = trim($fullPrompt);

                // 当前是否启用音效同出(没台词强制关闭音效同出,节省资源收费)
                $current_generate_audio = $hasDialogue ? $generate_audio : 0;
                
                // 智能选择视频时长
                // $videoDuration = $this->AnimeService->calculateOptimalVideoDuration($segmentContent, $tailFrame);
                $videoDuration = -1;
                
                // 构建视频生成参数
                $videoParams = [
                    'model' => $model,
                    'alias_segment_id' => $segment->segment_id,
                    'prompt' => $fullPrompt,
                    'video_duration' => $videoDuration,
                    'video_resolution' => '720P',
                    'seed' => -1,
                    'ratio' => $ratio,
                    'generate_audio' => (int)$current_generate_audio === 0 ? false : true,
                    'draft' => false,
                    'watermark' => false,
                    'camera_fixed' => false,
                    // 'callback_url' => 'http://mpaudio.yqsd.cn/api/video/seedanceCallback'
                ];
                
                // 如果分镜有图片，作为首帧
                $hasImage = !empty($segment->img_url);
                $hasVideo = !empty($segment->video_url);
                
                if ($hasImage) {
                    $videoParams['first_frame_url'] = $segment->img_url;
                }
                
                // 构建content数组
                $videoParams['content'] = [
                    [
                        'type' => 'text',
                        'text' => $videoParams['prompt'],
                    ]
                ];
                
                // 如果有首帧图片，添加到content中
                if ($hasImage) {
                    if (in_array($model, ['doubao-seedance-2-0-260128', 'doubao-seedance-2-0-fast-260128'])) {
                        $videoParams['content'][] = [
                            'type' => 'image_url',
                            'image_url' => [
                                'url' => $videoParams['first_frame_url'],
                            ],
                            'role' => 'reference_image',
                        ];
                    }else {
                        $videoParams['content'][] = [
                            'type' => 'image_url',
                            'image_url' => [
                                'url' => $videoParams['first_frame_url'],
                            ],
                            'role' => 'first_frame',
                        ];
                    }
                }
                
                // 获取配音音频URL和时长
                $audioUrl = $segment->audio_url ?? '';
                $audioDuration = $segment->audio_duration ?? 0;
                
                // 音频传入的前提：必须有至少一张图片或一个视频
                $canUseAudio = ($hasImage || $hasVideo) && !empty($audioUrl);
                
                // 根据模型选择不同的视频生成方法
                if (strpos($model, 'jimeng') !== false) {
                    // 即梦模型参数调整
                    $videoParams['video_duration'] = $audioDuration > 5 ? 10 : 5; // 即梦只支持5s或10s
                    $videoParams['aspect_ratio'] = $videoParams['ratio']; // 即梦使用aspect_ratio
                    unset($videoParams['ratio']);
                    unset($videoParams['content']); // 即梦不使用content格式
                    $task = $this->AIVideoGenerationService->createJimengTask($videoParams);
                } elseif (strpos($model, 'kling') !== false) {
                    // Keling模型参数调整
                    $videoParams['video_duration'] = max(3, min(15, ceil($audioDuration))); // Keling支持3-15秒
                    $videoParams['aspect_ratio'] = $videoParams['ratio']; // Keling使用aspect_ratio
                    unset($videoParams['ratio']);
                    unset($videoParams['content']); // Keling不使用content格式
                    $task = $this->AIVideoGenerationService->createKelingOmniTask($videoParams);
                } elseif (strpos($model, 'zhizhen') !== false) {
                    // 智帧20等新模型使用统一API
                    // 构建统一API参数
                    $unifiedParams = [
                        'model_code' => $model,
                        'alias_segment_id' => $segment->segment_id,
                        'prompt' => trim($fullPrompt),
                        'video_duration' => $audioDuration > 0 ? max(5, min(15, ceil($audioDuration))) : 5,
                        'video_resolution' => strtolower($videoParams['video_resolution']),
                        'video_ratio' => $ratio,
                        'seed' => -1,
                    ];
                    
                    // 构建parameters参数
                    $parameters = [
                        'seconds' => $unifiedParams['video_duration'],
                        'resolution' => $unifiedParams['video_resolution'],
                        'ratio' => $ratio,
                        'video_mode' => 'multi_image',
                        'mode' => 'multi_image',
                        'generate_audio' => (int)$current_generate_audio === 1 ? true : false,
                    ];
                    
                    // 处理首帧和尾帧（智帧20模型必须要有首帧图片）
                    if ($hasImage) {
                        $parameters['first_frame_url'] = $videoParams['first_frame_url'];
                        
                        // 只有在有图片的情况下才能添加参考音频
                        if ($audioUrl) {
                            $parameters['reference_audios'] = [$audioUrl];
                        }
                    } else {
                        // 没有图片时，记录错误并跳过
                        $logData = [
                            'segment_id' => $segment->segment_id,
                            'model' => $model,
                            'error' => '智帧20模型需要提供首帧图片'
                        ];
                        dLog('anime')->error('智帧20模型缺少首帧图片', $logData);
                        logDB('anime', 'error', '智帧20模型缺少首帧图片', $logData);
                        continue;
                    }
                    
                    $unifiedParams['parameters'] = $parameters;
                    
                    // 调用统一API创建任务
                    $task = $this->AIVideoGenerationService->createUnifiedApiTask($unifiedParams);
                } else {
                    // Seedance模型（默认）
                    // 检查是否为 Seedance 2.0 模型，如果是则需要处理配音音频
                    if ($canUseAudio && in_array($model, ['doubao-seedance-2-0-260128', 'doubao-seedance-2-0-fast-260128'])) {
                        // 添加配音音频到content中
                        $videoParams['content'][] = [
                            'type' => 'audio_url',
                            'audio_url' => [
                                'url' => $audioUrl,
                            ],
                            'role' => 'reference_audio',
                        ];
                        
                        // 优化提示词，增加音频相关描述
                        $audioPrompt = "全程使用音频1作为视频配音。" . $fullPrompt;
                        $videoParams['prompt'] = $audioPrompt;
                        $videoParams['content'][0]['text'] = $audioPrompt;
                    } else if ($audioDuration) {
                        // 有音频时长则需将视频时长设置为比音频时长更长的整数
                        $videoParams['video_duration'] = max(4, min(12, ceil($audioDuration)));   // seedance支持2-12s
                    }
                    $task = $this->AIVideoGenerationService->createSeedanceTask($videoParams);
                }
                $taskIds[] = $task->id;
                
                // 更新分镜表的视频任务信息
                DB::table('mp_episode_segments')
                    ->where('segment_id', $segment->segment_id)
                    ->update([
                        'video_task_id' => $task->id,
                        'video_task_status' => '生成中',
                        'updated_at' => date('Y-m-d H:i:s')
                    ]);
                
                $segmentTasks[] = [
                    'segment_id' => $segment->segment_id,
                    'task_id' => $task->id,
                    'segment_number' => $segment->segment_number,
                    'tail_frame' => $segment->tail_frame,
                    'audio_duration' => $segment->audio_duration,
                ];
                
            } catch (\Exception $e) {
                $logData = [
                    'segment_id' => $segment->segment_id,
                    'anime_id' => $animeId,
                    'error' => $e->getMessage(),
                ];
                dLog('anime')->error('创建分镜视频任务失败', $logData);
                logDB('anime', 'error', '创建分镜视频任务失败', $logData);
                continue;
            }
        }
        
        if (empty($taskIds)) {
            Utils::throwError('20003:没有需要生成视频的分镜');
        }
        
        // 保存模型到episode表
        DB::table('mp_anime_episodes')->where('id', $episodeId)->update([
            'video_model' => $model,
            'updated_at' => date('Y-m-d H:i:s')
        ]);
        
        // 记录开始时间（包含创建任务的时间）
        $startTime = time();
        $maxDuration = 1800; // 30分钟超时
        
        // 设置 SSE 响应头并开始长连接
        return response()->stream(function () use ($taskIds, $segmentTasks, $episodeId, $startTime, $maxDuration) {
            $checkInterval = 10; // 每10秒检查一次
            $lastQueueMessageTime = time(); // 记录上次发送队列消息的时间
            $queueMessageInterval = 60; // 队列消息发送间隔（秒）
            
            // 初始化任务数组
            $totalTasks = $taskIds; // 所有任务ID
            $completeTasks = []; // 已完成的任务ID（包含失败）
            $successTasks = []; // 成功的任务ID
            
            // 发送初始任务创建信息
            echo "data: " . json_encode([
                'type' => 'init',
                'total_tasks_count' => count($totalTasks),
                'completed_tasks_count' => count($completeTasks),
                'success_tasks_count' => count($successTasks)
            ]) . "\n\n";
            if (ob_get_level() > 0) {
                ob_flush();
            }
            flush();
            
            while (time() - $startTime < $maxDuration) {
                try {
                    $hasUpdate = false; // 标记是否有更新
                    
                    // 获取所有任务的最新状态
                    foreach ($totalTasks as $taskId) {
                        // 如果任务已经在完成列表中，跳过
                        if (in_array($taskId, $completeTasks)) {
                            continue;
                        }
                        
                        $task = \App\Models\MpGenerateVideoTask::find($taskId);
                        if (!$task) {
                            continue;
                        }
                        
                        // 视频任务结果由定时任务实时更新，此处直接读取任务表状态
                        
                        // 检查任务是否完成（成功或失败）
                        if (in_array($task->status, ['success', 'failed'])) {
                            $completeTasks[] = $taskId;
                            $hasUpdate = true;
                            
                            if ($task->status === 'success') {
                                $successTasks[] = $taskId;
                            }
                        }
                    }
                    
                    // 如果有更新，发送update通知
                    if ($hasUpdate) {
                        echo "data: " . json_encode([
                            'type' => 'update',
                            'total_tasks_count' => count($totalTasks),
                            'completed_tasks_count' => count($completeTasks),
                            'success_tasks_count' => count($successTasks)
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                    }
                    
                    // 如果所有任务都完成了，结束连接
                    if (count($completeTasks) >= count($totalTasks)) {
                        // 获取所有成功任务的分镜信息
                        $successSegments = [];
                        foreach ($successTasks as $taskId) {
                            // 通过taskId找到对应的segmentTask
                            foreach ($segmentTasks as $segmentTask) {
                                if ($segmentTask['task_id'] == $taskId) {
                                    $segment = DB::table('mp_episode_segments')
                                        ->where('segment_id', $segmentTask['segment_id'])
                                        ->select('segment_id', 'video_url')
                                        ->first();
                                    
                                    if ($segment && !empty($segment->video_url)) {
                                        $successSegments[] = [
                                            'segment_id' => $segment->segment_id,
                                            'video_url' => $segment->video_url
                                        ];
                                    }
                                    break;
                                }
                            }
                        }
                        
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'total_tasks_count' => count($totalTasks),
                            'completed_tasks_count' => count($completeTasks),
                            'success_tasks_count' => count($successTasks),
                            'success_segments' => $successSegments
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                        break;
                    }
                    
                    // 每分钟发送一次队列状态消息
                    $currentTime = time();
                    if ($currentTime - $lastQueueMessageTime >= $queueMessageInterval) {
                        echo "data: " . json_encode([
                            'type' => 'queue',
                            'data' => [
                                'total_tasks_count' => count($totalTasks),
                                'completed_tasks_count' => count($completeTasks),
                                'success_tasks_count' => count($successTasks),
                                'elapsed_time' => $currentTime - $startTime,
                                'message' => '任务正在队列中执行...'
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                        $lastQueueMessageTime = $currentTime;
                    }
                    
                    // 检查是否超时
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage(),
                        'total_tasks_count' => count($totalTasks),
                        'completed_tasks_count' => count($completeTasks),
                        'success_tasks_count' => count($successTasks)
                    ]) . "\n\n";
                    if (ob_get_level() > 0) {
                        ob_flush();
                    }
                    flush();
                    
                    // 检查是否超时，如果超时则停止循环
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '批量视频生成已超时30分钟，停止状态查询',
                    'total_tasks_count' => count($totalTasks),
                    'completed_tasks_count' => count($completeTasks),
                    'success_tasks_count' => count($successTasks)
                ]) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    // 应用有声制作参数
    public function applyAudioData(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->applyAudioData($data);
        return $this->success($result);
    }

    // 获取分集生成图片信息
    public function episodePicsInfo(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();

        // 获取生成器函数
        $streamGenerator = $this->AnimeService->episodePicsInfo($data);

        // 返回 SSE 响应
        return response()->stream($streamGenerator, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    public function clipSegmentVideo(Request $request) {
        $data = $request->all();

        $result = $this->AnimeService->clipSegmentVideo($data);
        return $this->success(['success'=>$result ? 1: 0]);
    }

    /**
     * 创建完整视频合成任务
     * 
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function createCompleteVideoTask(Request $request)
    {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'anime_id' => 'required|string',
            'episode_id' => 'required|string',
        ], [
            'anime_id.required' => '请选择动漫',
            'episode_id.required' => '请选择分集',
        ]);
        
        if ($validator->fails()) {
            Utils::throwError('1002:' . $validator->errors()->first());
        }
        
        try {
            $result = $this->AnimeService->createCompleteVideoTask($data);
            return $this->success($result);
        } catch (\Exception $e) {
            $logData = [
                'anime_id' => $data['anime_id'] ?? '',
                'episode_id' => $data['episode_id'] ?? '',
                'error' => $e->getMessage()
            ];
            dLog('anime')->error('创建完整视频合成任务失败', $logData);
            logDB('anime', 'error', '创建完整视频合成任务失败', $logData);
            return $this->error('20003:'.$e->getMessage());
        }
    }

    // 文生图(通用)
    public function generateImg(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();

        // 兼容开关：stream=1 走 SSE 流式输出；默认不传时保持原有普通 JSON 响应
        $useStream = (int)($request->input('stream', 0)) === 1;

        if (!$useStream) {
            // 原有逻辑：同步等待结果，普通 JSON 响应（格式保持不变）
            $result = $this->AnimeService->generateImg($data);

            // 多张图片：data为首图URL，image_urls为全部图片URL数组，task_center_id为任务中心ID
            if (is_array($result) && isset($result['img_url']) && isset($result['image_urls'])) {
                return $this->respond([
                    'msg'            => '',
                    'code'           => 0,
                    'data'           => $result['img_url'],
                    'image_urls'     => $result['image_urls'],
                    'task_center_id' => $result['task_id'] ?? 0,
                ]);
            }

            // 单张图片：data为图片URL，task_center_id为任务中心ID
            if (is_array($result) && isset($result['img_url'])) {
                return $this->respond([
                    'msg'            => '',
                    'code'           => 0,
                    'data'           => $result['img_url'],
                    'task_center_id' => $result['task_id'] ?? 0,
                ]);
            }

            return $this->success($result);
        }

        // 设置 SSE 响应头
        return response()->stream(function () use ($data) {
            // 禁用所有输出缓冲
            if (ob_get_level()) {
                ob_end_clean();
            }
            ini_set('output_buffering', 'off');
            ini_set('zlib.output_compression', 'off');
            if (function_exists('apache_setenv')) {
                apache_setenv('no-gzip', '1');
            }

            try {
                // 创建图片生成任务，任务创建后立即回调发送init消息（包含任务中心ID和任务信息）
                $result = $this->AnimeService->generateImg($data, function ($taskCenterId, $taskInfo) {
                    echo "data: " . json_encode([
                        'type'           => 'init',
                        'data'           => $taskInfo,
                        'task_center_id' => $taskCenterId,
                    ], JSON_UNESCAPED_UNICODE) . "\n\n";
                    if (ob_get_level() > 0) {
                        ob_flush();
                    }
                    flush();
                }, function ($taskCenterId, $taskId, $elapsedTime) {
                    // 每分钟发送一次队列状态消息
                    echo "data: " . json_encode([
                        'type' => 'queue',
                        'data' => [
                            'task_id'      => $taskId,
                            'status'       => 'processing',
                            'elapsed_time' => $elapsedTime,
                            'message'               => '任务正在队列中执行...',
                        ],
                    ], JSON_UNESCAPED_UNICODE) . "\n\n";
                    if (ob_get_level() > 0) {
                        ob_flush();
                    }
                    flush();
                });

                // 最终结果：保持原有返回格式（msg/code/data/image_urls/task_center_id）
                if (is_array($result) && isset($result['img_url']) && isset($result['image_urls'])) {
                    $finalData = [
                        'msg'            => '',
                        'code'           => 0,
                        'data'           => $result['img_url'],
                        'image_urls'     => $result['image_urls'],
                        'task_center_id' => $result['task_id'] ?? 0,
                    ];
                } elseif (is_array($result) && isset($result['img_url'])) {
                    $finalData = [
                        'msg'            => '',
                        'code'           => 0,
                        'data'           => $result['img_url'],
                        'task_center_id' => $result['task_id'] ?? 0,
                    ];
                } else {
                    $finalData = [
                        'msg'  => '',
                        'code' => 0,
                        'data' => $result,
                    ];
                }

                echo "data: " . json_encode([
                    'type' => 'completed',
                    'data' => $finalData,
                ], JSON_UNESCAPED_UNICODE) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();

            } catch (\Exception $e) {
                echo "data: " . json_encode([
                    'type'    => 'error',
                    'message' => $e->getMessage(),
                ], JSON_UNESCAPED_UNICODE) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            }
        }, 200, [
            'Content-Type'    => 'text/event-stream',
            'Cache-Control'   => 'no-cache',
            'Connection'      => 'keep-alive',
            'X-Accel-Buffering' => 'no',
        ]);
    }

    /**
     * 导出动漫剧本为PDF
     * @param Request $request
     */
    public function exportAnimeScriptPdf(Request $request) {
        // 忽略超时限制（图片下载可能耗时较长）
        set_time_limit(0);
        ini_set('max_execution_time', '0');
        ini_set('memory_limit', '512M');

        $animeId = (int)$request->input('anime_id', 0);
        $episodeCount = (int)$request->input('episode_count', 8);
        if ($animeId <= 0) {
            Utils::throwError('20003:缺少anime_id');
        }

        return $this->AnimeService->exportAnimeScriptAsPdf($animeId, $episodeCount);
    }

    /**
     * 导出分集的全部图片（下载并打包）
     */
    public function exportEpisodeImages(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');
        ini_set('memory_limit', '512M');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'anime_id' => 'required|string',
            'episode_id' => 'required|string',
        ], [
            'anime_id.required' => '动漫ID不能为空',
            'episode_id.required' => '剧集ID不能为空',
        ]);
        
        if ($validator->fails()) {
            Utils::throwError('1002:' . $validator->errors()->first());
        }
        
        $animeId = $data['anime_id'];
        $episodeId = $data['episode_id'];
        
        try {
            // 获取动漫信息，判断是否为全能模式
            $anime = DB::table('mp_animes')
                ->where('id', $animeId)
                ->select('ace_mode')
                ->first();
            
            if (!$anime) {
                Utils::throwError('20003:未找到动漫信息');
            }
            
            $isAceMode = ($anime->ace_mode == 1);
            
            // 获取剧集信息
            $episode = DB::table('mp_anime_episodes')
                ->where('anime_id', $animeId)
                ->where('id', $episodeId)
                ->select('episode_number', 'title')
                ->first();
            
            if (!$episode) {
                Utils::throwError('20003:未找到剧集信息');
            }
            
            // 根据模式查询和排序分镜数据
            if ($isAceMode) {
                // 全能模式：只查询有视频的分镜，按act_number排序
                $segments = DB::table('mp_episode_segments')
                    ->where('anime_id', $animeId)
                    ->where('episode_id', $episodeId)
                    ->whereNotNull('video_url')
                    ->where('video_url', '!=', '')
                    ->orderBy('act_number')
                    ->select('id as act_id', 'act_number', 'video_url', 'act_title')
                    ->get();
                
                if ($segments->isEmpty()) {
                    Utils::throwError('20003:该剧集暂无视频可导出');
                }
            } else {
                // 普通模式：查询所有分镜，按segment_number排序
                $segments = DB::table('mp_episode_segments')
                    ->where('anime_id', $animeId)
                    ->where('episode_id', $episodeId)
                    ->orderBy('segment_number')
                    ->select('segment_id', 'segment_number', 'img_url', 'video_url', 'audio_url')
                    ->get();
                
                if ($segments->isEmpty()) {
                    Utils::throwError('20003:该剧集暂无分镜数据');
                }
                
                // 过滤出有图片或视频的分镜
                $validSegments = $segments->filter(function($segment) {
                    return (!empty($segment->img_url) || !empty($segment->video_url));
                });
                
                if ($validSegments->isEmpty()) {
                    Utils::throwError('20003:该剧集暂无图片或视频可导出');
                }
                
                $segments = $validSegments->values();
            }
            
            // 创建临时目录
            $tempDir = storage_path('app/temp/episode_images_' . time() . '_' . mt_rand(1000, 9999));
            if (!file_exists($tempDir)) {
                mkdir($tempDir, 0755, true);
            }
            
            // 并行下载文件（使用 cURL multi）
            $downloadedFiles = [];
            $multiHandle = curl_multi_init();
            $curlHandles = [];
            $fileInfos = [];
            
            // 准备所有下载任务
            foreach ($segments as $index => $segment) {
                try {
                    if ($isAceMode) {
                        // 全能模式：只下载视频
                        $mediaUrl = $segment->video_url;
                    } else {
                        // 普通模式：优先使用video_url，如果没有则使用img_url
                        $mediaUrl = !empty($segment->video_url) ? $segment->video_url : $segment->img_url;
                    }
                    
                    if (empty($mediaUrl)) {
                        continue;
                    }
                    
                    // 获取文件扩展名
                    $extension = pathinfo(parse_url($mediaUrl, PHP_URL_PATH), PATHINFO_EXTENSION);
                    if (empty($extension)) {
                        // 根据URL类型设置默认扩展名
                        $extension = !empty($segment->video_url) ? 'mp4' : 'jpg';
                    }
                    
                    // 构建文件名
                    if ($isAceMode) {
                        // 全能模式：使用act_number
                        $fileName = sprintf('%03d.%s', $segment->act_number, $extension);
                    } else {
                        // 普通模式：使用segment_number
                        $fileName = sprintf('%03d.%s', $segment->segment_number, $extension);
                    }
                    $filePath = $tempDir . '/' . $fileName;
                    
                    // 创建 cURL 句柄
                    $ch = curl_init($mediaUrl);
                    $fp = fopen($filePath, 'wb');
                    
                    curl_setopt($ch, CURLOPT_FILE, $fp);
                    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
                    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
                    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
                    curl_setopt($ch, CURLOPT_TIMEOUT, 60);
                    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
                    
                    curl_multi_add_handle($multiHandle, $ch);
                    
                    $curlHandles[(int)$ch] = [
                        'handle' => $ch,
                        'file' => $fp,
                        'path' => $filePath,
                        'url' => $mediaUrl,
                        'segment' => $segment
                    ];
                    
                } catch (\Exception $e) {
                    $logData = ['error' => $e->getMessage()];
                    if ($isAceMode) {
                        $logData['act_id'] = $segment->act_id;
                    } else {
                        $logData['segment_id'] = $segment->segment_id;
                    }
                    logDB('anime', 'error', '准备下载任务异常', $logData);
                    continue;
                }
            }
            
            // 执行并行下载
            $running = null;
            do {
                curl_multi_exec($multiHandle, $running);
                curl_multi_select($multiHandle, 0.1);
            } while ($running > 0);
            
            // 处理下载结果
            foreach ($curlHandles as $info) {
                $ch = $info['handle'];
                $fp = $info['file'];
                $filePath = $info['path'];
                $segment = $info['segment'];
                
                fclose($fp);
                
                $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                
                if ($httpCode == 200 && file_exists($filePath) && filesize($filePath) > 0) {
                    $downloadedFiles[] = $filePath;
                } else {
                    // 删除失败的文件
                    if (file_exists($filePath)) {
                        @unlink($filePath);
                    }
                    
                    $logData = [
                        'media_url' => $info['url'],
                        'http_code' => $httpCode,
                        'type' => $isAceMode ? 'video' : 'image'
                    ];
                    
                    if ($isAceMode) {
                        $logData['act_id'] = $segment->act_id;
                    } else {
                        $logData['segment_id'] = $segment->segment_id;
                    }
                    
                    logDB('anime', 'warning', '文件下载失败', $logData);
                }
                
                curl_multi_remove_handle($multiHandle, $ch);
                curl_close($ch);
            }
            
            curl_multi_close($multiHandle);
            
            if (empty($downloadedFiles)) {
                // 清理临时目录
                if (file_exists($tempDir)) {
                    array_map('unlink', glob("$tempDir/*"));
                    rmdir($tempDir);
                }
                Utils::throwError('20003:没有成功下载任何文件');
            }
            
            // 处理音频合成（仅普通模式）
            $mergedAudioPath = null;
            if (!$isAceMode) {
                try {
                    // 检查 FFmpeg 是否可用
                    exec('which ffmpeg 2>&1', $ffmpegCheck, $ffmpegReturnCode);
                    $hasFfmpeg = ($ffmpegReturnCode === 0);
                    
                    if ($hasFfmpeg) {
                        // 下载所有分镜的音频文件
                        $audioFiles = [];
                        foreach ($segments as $segment) {
                            if (!empty($segment->audio_url)) {
                                try {
                                    $context = stream_context_create([
                                        'http' => [
                                            'timeout' => 30,
                                            'follow_location' => 1,
                                            'ignore_errors' => true
                                        ],
                                        'ssl' => [
                                            'verify_peer' => false,
                                            'verify_peer_name' => false
                                        ]
                                    ]);
                                    
                                    $audioData = @file_get_contents($segment->audio_url, false, $context);
                                    
                                    if ($audioData !== false && !empty($audioData)) {
                                        // 获取音频文件扩展名
                                        $audioExtension = pathinfo(parse_url($segment->audio_url, PHP_URL_PATH), PATHINFO_EXTENSION);
                                        if (empty($audioExtension)) {
                                            $audioExtension = 'wav';
                                        }
                                        
                                        $audioFileName = sprintf('audio_%03d.%s', $segment->segment_number, $audioExtension);
                                        $audioFilePath = $tempDir . '/' . $audioFileName;
                                        file_put_contents($audioFilePath, $audioData);
                                        $audioFiles[] = $audioFilePath;
                                    } else {
                                        logDB('anime', 'warning', '音频下载失败', [
                                            'segment_id' => $segment->segment_id,
                                            'audio_url' => $segment->audio_url
                                        ]);
                                    }
                                } catch (\Exception $e) {
                                    logDB('anime', 'error', '下载音频异常', [
                                        'segment_id' => $segment->segment_id,
                                        'audio_url' => $segment->audio_url,
                                        'error' => $e->getMessage()
                                    ]);
                                }
                            }
                        }
                        
                        // 如果有音频文件，则进行合成
                        if (!empty($audioFiles)) {
                            // 创建 FFmpeg concat 文件列表
                            $concatFile = $tempDir . '/concat.txt';
                            $concatContent = '';
                            foreach ($audioFiles as $audioFile) {
                                // 使用相对路径，避免路径中的特殊字符问题
                                $concatContent .= "file '" . basename($audioFile) . "'\n";
                            }
                            file_put_contents($concatFile, $concatContent);
                            
                            // 合成音频文件
                            $mergedAudioPath = $tempDir . '/tts.wav';
                            
                            // 使用 FFmpeg 合并音频，转换为统一的 WAV 格式
                            $ffmpegCommand = sprintf(
                                'cd %s && ffmpeg -f concat -safe 0 -i %s -ar 44100 -ac 2 -y %s 2>&1',
                                escapeshellarg($tempDir),
                                escapeshellarg(basename($concatFile)),
                                escapeshellarg(basename($mergedAudioPath))
                            );
                            
                            exec($ffmpegCommand, $ffmpegOutput, $ffmpegReturnCode);
                            
                            if ($ffmpegReturnCode !== 0 || !file_exists($mergedAudioPath)) {
                                logDB('anime', 'error', 'FFmpeg 合成音频失败', [
                                    'command' => $ffmpegCommand,
                                    'output' => implode("\n", $ffmpegOutput),
                                    'return_code' => $ffmpegReturnCode
                                ]);
                                $mergedAudioPath = null;
                            } else {
                                logDB('anime', 'info', '音频合成成功', [
                                    'audio_count' => count($audioFiles),
                                    'output_file' => $mergedAudioPath,
                                    'file_size' => filesize($mergedAudioPath)
                                ]);
                            }
                            
                            // 清理临时音频文件和 concat 文件
                            foreach ($audioFiles as $audioFile) {
                                if (file_exists($audioFile)) {
                                    @unlink($audioFile);
                                }
                            }
                            if (file_exists($concatFile)) {
                                @unlink($concatFile);
                            }
                        }
                    } else {
                        logDB('anime', 'warning', 'FFmpeg 未安装，跳过音频合成', []);
                    }
                } catch (\Exception $e) {
                    logDB('anime', 'error', '音频合成过程异常', [
                        'error' => $e->getMessage(),
                        'trace' => $e->getTraceAsString()
                    ]);
                    // 音频合成失败不影响图片导出
                    $mergedAudioPath = null;
                }
            }
            
            // 创建zip文件（使用安全的文件名）
            $safeTitle = preg_replace('/[^\p{L}\p{N}\s\-_]/u', '', $episode->title ?: '未命名');
            $safeTitle = trim($safeTitle) ?: '未命名';
            $zipFileName = sprintf('%s_%s.zip', $safeTitle, time());
            $zipFilePath = storage_path('app/temp/' . $zipFileName);
            
            // 确保 temp 目录存在
            $tempZipDir = storage_path('app/temp');
            if (!file_exists($tempZipDir)) {
                mkdir($tempZipDir, 0755, true);
            }
            
            $zip = new \ZipArchive();
            $openResult = $zip->open($zipFilePath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE);
            
            if ($openResult !== true) {
                // 清理临时文件
                array_map('unlink', $downloadedFiles);
                if ($mergedAudioPath && file_exists($mergedAudioPath)) {
                    @unlink($mergedAudioPath);
                }
                rmdir($tempDir);
                
                logDB('anime', 'error', '创建ZIP文件失败', [
                    'zip_path' => $zipFilePath,
                    'open_result' => $openResult
                ]);
                
                Utils::throwError('20003:创建ZIP文件失败');
            }
            
            // 设置压缩级别为最快（0=不压缩，1=最快，9=最好压缩）
            // 对于视频和图片，压缩效果不明显，使用最快速度
            $zip->setCompressionIndex(0, \ZipArchive::CM_STORE); // 不压缩，直接存储
            
            // 添加文件到zip
            foreach ($downloadedFiles as $file) {
                if (file_exists($file)) {
                    $zip->addFile($file, basename($file));
                }
            }
            
            // 添加合成的音频文件到zip（仅普通模式）
            if (!$isAceMode && $mergedAudioPath && file_exists($mergedAudioPath)) {
                $zip->addFile($mergedAudioPath, 'tts.wav');
            }
            
            // 关闭 ZIP 文件
            $zip->close();
            
            // 验证 ZIP 文件是否创建成功
            if (!file_exists($zipFilePath) || filesize($zipFilePath) == 0) {
                // 清理临时文件
                array_map('unlink', $downloadedFiles);
                if ($mergedAudioPath && file_exists($mergedAudioPath)) {
                    @unlink($mergedAudioPath);
                }
                rmdir($tempDir);
                
                logDB('anime', 'error', 'ZIP文件创建后无效', ['zip_path' => $zipFilePath]);
                
                Utils::throwError('20003:ZIP文件创建失败或文件为空');
            }
            
            // 清理临时文件
            array_map('unlink', $downloadedFiles);
            
            // 清理合成的音频文件
            if ($mergedAudioPath && file_exists($mergedAudioPath)) {
                @unlink($mergedAudioPath);
            }
            
            rmdir($tempDir);
            
            // 清空所有输出缓冲区，避免污染ZIP文件
            while (ob_get_level() > 0) {
                ob_end_clean();
            }
            
            // 返回文件下载响应
            return response()->download($zipFilePath, $zipFileName)->deleteFileAfterSend(true);
            
        } catch (\Exception $e) {
            logDB('anime', 'error', '导出分集图片失败', [
                'anime_id' => $animeId,
                'episode_id' => $episodeId,
                'error' => $e->getMessage()
            ]);
            
            // 清理可能存在的临时文件
            if (isset($tempDir) && file_exists($tempDir)) {
                array_map('unlink', glob("$tempDir/*"));
                rmdir($tempDir);
            }
            if (isset($zipFilePath) && file_exists($zipFilePath)) {
                unlink($zipFilePath);
            }
            
            throw $e;
        }
    }

    /**
     * 监控分镜图片和音频生成任务进度（SSE）
     */
    public function monitorSegmentTasks(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'anime_id' => 'required|string',
            'episode_id' => 'required|string',
        ], [
            'anime_id.required' => '动漫ID不能为空',
            'episode_id.required' => '剧集ID不能为空',
        ]);
        
        if ($validator->fails()) {
            Utils::throwError('1002:' . $validator->errors()->first());
        }
        
        $animeId = $data['anime_id'];
        $episodeId = $data['episode_id'];
        
        // 查询没有pic_task_id的分镜个数
        $noPicTaskCount = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->where(function($query) {
                $query->whereNull('pic_task_id')
                      ->orWhere('pic_task_id', '');
            })
            ->count('id');
        
        // 获取所有分镜信息
        $segments = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->where('pic_task_id', '!=', '')
            ->orderBy('segment_number')
            ->get();


        // 判断是否有未完成的任务
        $uncompleted_pic_count = DB::table('mp_episode_segments')->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)->where('pic_task_id', '<>', '')->whereNotIn('pic_task_status', ['已完成', '失败'])->count('id');
        
        // 获取dialogue和voice_type存在但audio_url不存在的分镜个数
        $uncompleted_audio_count = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->where('dialogue', '<>', '')
            ->whereNotNull('dialogue')
            ->where('voice_type', '<>', '')
            ->whereNotNull('voice_type')
            ->where(function($query) {
                $query->whereNull('audio_url')
                      ->orWhere('audio_url', '');
            })
            ->count('id');
            
        if ($segments->isEmpty()) {
            Utils::throwError('20003:未找到分镜任务数据');
        }
        
        $startTime = time();
        $maxDuration = 900; // 15分钟超时
        $checkInterval = 5; // 每5秒检查一次
        
        // 设置 SSE 响应头并开始长连接
        return response()->stream(function () use ($segments, $animeId, $episodeId, $startTime, $maxDuration, $checkInterval, $uncompleted_pic_count, $uncompleted_audio_count, $noPicTaskCount) {

            if ($uncompleted_pic_count == 0 && $uncompleted_audio_count == 0) {
                $completedCount = DB::table('mp_episode_segments')->where('anime_id', $animeId)->where('episode_id', $episodeId)->where('pic_task_id', '<>', '')->where('pic_task_status', '已完成')->count('id');

                // 获取剧集信息之前先处理视频截止时间点
                $this->handleVideoTimePointEnd();

                // 获取剧集信息
                $episode = DB::table('mp_anime_episodes')
                    ->where('anime_id', $animeId)
                    ->where('id', $episodeId)
                    ->select('id as episode_id', 'anime_id', 'episode_number', 'title', 'intro', 'art_style', 'roles', 'scenes')
                    ->first();
                
                if ($episode) {
                    $episode = (array)$episode;
                    $episode['roles'] = json_decode($episode['roles'], true);
                    $episode['scenes'] = json_decode($episode['scenes'], true);
                    
                    // 获取所有分镜信息
                    $allSegments = DB::table('mp_episode_segments')
                        ->where('anime_id', $animeId)
                        ->where('episode_id', $episodeId)
                        ->orderBy('segment_number')
                        ->select('*')
                        ->get()
                        ->map(function ($value) {
                            return (array)$value;
                        })->toArray();
                    
                    // 按照episodeInfo的格式组织数据
                    $segmentsStructure = $this->AnimeService->buildEpisodeSegmentsStructure($allSegments);
                    $episode['acts'] = $segmentsStructure['acts'];
                    $episode['total_duration'] = $segmentsStructure['total_duration'];
                }

                echo "data: " . json_encode([
                    'type' => 'completed',
                    'data' => [
                        'anime_id' => $animeId,
                        'episode_id' => $episodeId,
                        'completed_count' => $completedCount, // 成功完成的数量
                        'processed_count' => count($segments) + $noPicTaskCount, // 已处理完成的数量（成功+失败）+ 没有pic_task_id的分镜
                        'total_count' => count($segments) + $noPicTaskCount, // 总数包含没有pic_task_id的分镜
                        'total_elapsed_time' => time() - $startTime,
                        'episode_info' => $episode ?? null
                    ]
                ]) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
                return;
            }

            // 发送初始任务信息
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => [
                    'anime_id' => $animeId,
                    'episode_id' => $episodeId,
                    'total_segments' => count($segments) + $noPicTaskCount, // 总数包含没有pic_task_id的分镜
                    'start_time' => $startTime,
                    'max_duration' => $maxDuration
                ]
            ]) . "\n\n";
            if (ob_get_level() > 0) {
                ob_flush();
            }
            flush();
            
            $completedSegments = [];
            $processedSegments = []; // 记录已处理完成的分镜（成功或失败）
            $notifiedSegments = []; // 记录已通知过的分镜，避免重复通知
            
            while (time() - $startTime < $maxDuration) {
                try {
                    $updatedImages = []; // 记录本次循环中更新的图片信息
                    
                    foreach ($segments as $segment) {
                        $segmentId = $segment->segment_id;
                        $picTaskId = $segment->pic_task_id;
                        $audioUrl = $segment->audio_url;
                        
                        // 跳过已处理完成的分镜
                        if (in_array($segmentId, $processedSegments)) {
                            continue;
                        }
                        
                        $picCompleted = false;
                        $audioCompleted = false;
                        $picProcessed = false;
                        $audioProcessed = false;
                        
                        // 检查图片任务状态
                        if ($picTaskId) {
                            $picTask = DB::table('mp_generate_pic_tasks')
                                ->where('id', $picTaskId)
                                ->select('status', 'result_url', 'error_message')
                                ->first();
                            
                            if ($picTask && in_array($picTask->status, ['success', 'failed'])) {
                                $updateData = [
                                    'pic_task_status' => $picTask->status === 'success' ? '已完成' : '失败',
                                    'updated_at' => date('Y-m-d H:i:s')
                                ];
                                
                                $imgUrl = '';
                                if ($picTask->status === 'success' && !empty($picTask->result_url)) {
                                    // 更新分镜表的图片URL
                                    $resultUrls = json_decode($picTask->result_url, true);
                                    $imgUrl = is_array($resultUrls) ? $resultUrls[0] : $picTask->result_url;
                                    $updateData['img_url'] = $imgUrl;
                                    $picCompleted = true;
                                } else if ($picTask->status === 'failed') {
                                    // 失败时清空图片URL
                                    $updateData['img_url'] = '';
                                }
                                
                                DB::table('mp_episode_segments')
                                    ->where('segment_id', $segmentId)
                                    ->update($updateData);
                                
                                // 记录更新的图片信息（只有未通知过的才记录）
                                if (!in_array($segmentId, $notifiedSegments)) {
                                    $updatedImages[] = [
                                        'segment_id' => $segmentId,
                                        'segment_number' => $segment->segment_number,
                                        'img_url' => $imgUrl,
                                        'status' => $picTask->status === 'success' ? 'success' : 'failed'
                                    ];
                                    
                                    // 标记为已通知
                                    $notifiedSegments[] = $segmentId;
                                }
                                
                                $picProcessed = true;
                            }
                        }
                        
                        // 检查音频状态
                        // 获取分镜的dialogue、voice_type和audio_url信息
                        $segmentInfo = DB::table('mp_episode_segments')
                            ->where('segment_id', $segmentId)
                            ->select('dialogue', 'voice_type', 'audio_url')
                            ->first();
                        
                        $needAudio = false;
                        $currentAudioUrl = '';
                        
                        if ($segmentInfo) {
                            $dialogue = trim((string)getProp($segmentInfo, 'dialogue'));
                            $voiceType = trim((string)getProp($segmentInfo, 'voice_type'));
                            $currentAudioUrl = trim((string)getProp($segmentInfo, 'audio_url'));
                            
                            // 如果有对话和音色类型，则需要音频
                            if (!empty($dialogue) && !empty($voiceType)) {
                                $needAudio = true;
                            }
                        }
                        
                        // 判断音频状态
                        if ($needAudio) {
                            // 需要音频的情况下，检查audio_url是否有值
                            if (!empty($currentAudioUrl)) {
                                $audioCompleted = true;
                                $audioProcessed = true;
                            } else {
                                // 需要音频但还没有，继续等待
                                $audioCompleted = false;
                                $audioProcessed = false;
                            }
                        } else {
                            // 不需要音频，直接标记为已处理
                            $audioCompleted = false;
                            $audioProcessed = true;
                        }
                        
                        // 如果图片和音频都成功完成，标记为已完成
                        if ($picCompleted && ($audioCompleted || !$needAudio)) {
                            $completedSegments[] = $segmentId;
                        }
                        
                        // 如果图片和音频都已处理完成（成功或失败），标记为已处理
                        if ($picProcessed && $audioProcessed) {
                            $processedSegments[] = $segmentId;
                        }
                        
                    }
                    
                    // 如果有图片更新，发送具体的图片更新信息
                    if (!empty($updatedImages)) {
                        echo "data: " . json_encode([
                            'type' => 'update',
                            'data' => [
                                'anime_id' => $animeId,
                                'episode_id' => $episodeId,
                                'updated_images' => $updatedImages,
                                'completed_count' => count($completedSegments), // 成功完成的数量
                                'processed_count' => count($processedSegments) + $noPicTaskCount, // 已处理完成的数量（成功+失败）+ 没有pic_task_id的分镜
                                'total_count' => count($segments) + $noPicTaskCount, // 总数包含没有pic_task_id的分镜
                                'elapsed_time' => time() - $startTime,
                                'remaining_time' => max(0, $maxDuration - (time() - $startTime))
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) {
                            ob_flush();
                        }
                        flush();
                    }
                    
                    // 如果所有分镜都已处理完成（成功或失败），获取最终结果并结束连接
                    if (count($processedSegments) === count($segments)) {
                        // 获取剧集信息之前先处理视频截止时间点
                        $this->handleVideoTimePointEnd();

                        // 获取剧集信息
                        $episode = DB::table('mp_anime_episodes')
                            ->where('anime_id', $animeId)
                            ->where('id', $episodeId)
                            ->select('id as episode_id', 'anime_id', 'episode_number', 'title', 'intro', 'art_style', 'roles', 'scenes')
                            ->first();
                        
                        if ($episode) {
                            $episode = (array)$episode;
                            $episode['roles'] = json_decode($episode['roles'], true);
                            $episode['scenes'] = json_decode($episode['scenes'], true);
                            
                            // 获取所有分镜信息
                            $allSegments = DB::table('mp_episode_segments')
                                ->where('anime_id', $animeId)
                                ->where('episode_id', $episodeId)
                                ->orderBy('segment_number')
                                ->select('*')
                                ->get()
                                ->map(function ($value) {
                                    return (array)$value;
                                })->toArray();
                            
                            // 按照episodeInfo的格式组织数据
                            $segmentsStructure = $this->AnimeService->buildEpisodeSegmentsStructure($allSegments);
                            $episode['acts'] = $segmentsStructure['acts'];
                            $episode['total_duration'] = $segmentsStructure['total_duration'];
                        }
                        
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'anime_id' => $animeId,
                                'episode_id' => $episodeId,
                                'completed_count' => count($completedSegments), // 成功完成的数量
                                'processed_count' => count($processedSegments) + $noPicTaskCount, // 已处理完成的数量（成功+失败）+ 没有pic_task_id的分镜
                                'total_count' => count($segments) + $noPicTaskCount, // 总数包含没有pic_task_id的分镜
                                'total_elapsed_time' => time() - $startTime,
                                'episode_info' => $episode ?? null
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }
                    
                    // 检查是否超时
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage(),
                        'elapsed_time' => time() - $startTime,
                        'remaining_time' => max(0, $maxDuration - (time() - $startTime))
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                    
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '分镜任务监控已超时15分钟，停止状态查询',
                    'data' => [
                        'anime_id' => $animeId,
                        'episode_id' => $episodeId,
                        'completed_count' => count($completedSegments), // 成功完成的数量
                        'processed_count' => count($processedSegments) + $noPicTaskCount, // 已处理完成的数量（成功+失败）+ 没有pic_task_id的分镜
                        'total_count' => count($segments) + $noPicTaskCount, // 总数包含没有pic_task_id的分镜
                        'total_elapsed_time' => time() - $startTime,
                        'timeout_duration' => $maxDuration
                    ]
                ]) . "\n\n";
                if (ob_get_level() > 0) ob_flush();
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    /**
     * 音频试听接口
     * 创建音频任务并返回结果
     */
    public function previewAudio(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->previewAudio($data);
        return $this->success($result);
    }

    // 角色库
    public function globalProducts(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->globalProducts($data);
        return $this->success($result);
    }

    // 新建角色
    public function createProduct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->createProduct($data);
        return $this->success($result);
    }

    // 编辑角色
    public function editProduct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->editProduct($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }
    
    // 获取角色版本历史
    public function getProductVersions(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->getProductVersions($data);
        return $this->success($result);
    }
    
    // 恢复到指定版本
    public function restoreProductVersion(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->restoreProductVersion($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }

    // 删除角色
    public function deleteProduct(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->deleteProduct($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }
    
    // 新建文件夹
    public function createFolder(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->createFolder($data);
        return $this->success(['id' => $result]);
    }
    
    // 重命名文件夹或角色
    public function renameFolder(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->renameFolder($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }
    
    // 移动角色或文件夹
    public function moveProductOrFolder(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->moveProductOrFolder($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }
    
    // 获取文件夹路径（面包屑导航）
    public function getFolderPath(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->getFolderPath($data);
        return $this->success($result);
    }

    // 生成三视图
    public function generateThreeView(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->generateThreeView($data);
        return $this->success($result);
    }

    // 推送资产或文件夹到目标位置
    public function pushProductOrFolder(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->pushProductOrFolder($data);
        return $this->success($result);
    }

    /**
     * 保存剧本资产关联关系
     * @param Request $request
     * @return mixed
     */
    public function saveScriptProducts(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        $result = $this->AnimeService->saveScriptProducts($data);
        
        // 判断是否是 SSE 流（Generator）
        if ($result instanceof \Generator) {
            // 返回 SSE 响应
            return response()->stream(function () use ($result) {
                // 设置不缓冲输出
                if (ob_get_level()) {
                    ob_end_flush();
                }
                
                foreach ($result as $event) {
                    echo $event;
                    if (ob_get_level()) {
                        ob_flush();
                    }
                    flush();
                }
            }, 200, [
                'Content-Type' => 'text/event-stream',
                'Cache-Control' => 'no-cache',
                'Connection' => 'keep-alive',
                'X-Accel-Buffering' => 'no'
            ]);
        }
        
        // 普通JSON响应
        return $this->success($result);
    }

    /**
     * 获取剧本关联的资产列表
     * @param Request $request
     * @return mixed
     */
    public function getScriptProducts(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->getScriptProducts($data);
        return $this->success($result);
    }

    /**
     * 获取剧本总集数
     * @param Request $request
     * @return mixed
     */
    public function getScriptTotalEpisodes(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->getScriptTotalEpisodes($data);
        return $this->success($result);
    }

    private function handleVideoTimePointEnd() {
        // 处理音频时长，循环查询dub_video_task_queue列表中的任务
        $queueLength = Redis::llen('dub_video_task_queue');
        if ($queueLength > 0) {
            $processedTaskIds = []; // 记录已处理的任务ID
            
            // 遍历队列中的所有任务
            for ($i = 0; $i < $queueLength; $i++) {
                $dubTaskId = Redis::lindex('dub_video_task_queue', $i);
                if (!$dubTaskId) continue;
                
                // 查询任务状态
                $dubTask = DB::table('mp_dub_video_tasks')
                    ->where('id', $dubTaskId)
                    ->first();
                
                if (!$dubTask) {
                    // 任务不存在，标记为需要删除
                    $processedTaskIds[] = $dubTaskId;
                    continue;
                }
                
                // 如果任务状态是已完成
                if ($dubTask->generate_status === '执行成功') {
                    // 获取对应的分镜信息
                    $segment = DB::table('mp_episode_segments')
                        ->where('segment_id', $dubTask->alias_segment_id)
                        ->first();
                    
                    // 如果分镜存在且audio_duration大于0
                    if ($segment && isset($segment->audio_duration) && $segment->audio_duration > 0) {
                        // 更新video_time_point_end字段
                        DB::table('mp_episode_segments')
                            ->where('segment_id', $dubTask->alias_segment_id)
                            ->update([
                                'video_time_point_end' => $segment->audio_duration,
                                'updated_at' => date('Y-m-d H:i:s')
                            ]);
                        
                        dLog('anime')->info('更新分镜视频截止时间点', [
                            'task_id' => $dubTaskId,
                            'segment_id' => $dubTask->alias_segment_id,
                            'audio_duration' => $segment->audio_duration
                        ]);
                    }
                    
                    // 标记为需要从队列中删除
                    $processedTaskIds[] = $dubTaskId;
                }
            }
            
            // 从Redis列表中删除已处理的任务ID
            foreach ($processedTaskIds as $taskId) {
                Redis::lrem('dub_video_task_queue', 0, $taskId);
            }
        }
    }

    // 确认片段
    public function confirmActs(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->confirmActs($data);
        return $this->success($result);
    }

    public function saveActVideoGenerateParams(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->saveActVideoGenerateParams($data);
        return $this->success(['success' => $result ? 1 : 0]);
    }

    public function createActVideoTask(Request $request) {
        $uid = Site::getUid();
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 创建视频生成任务
        $result = $this->AnimeService->createActVideoTask($data);
        $taskId = $result['task_id'];
        
        // 设置 SSE 响应头
        return response()->stream(function () use ($taskId, $result, $uid) {
            // 立即发送 init 消息
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => $result
            ]) . "\n\n";
            if (ob_get_level() > 0) ob_flush();
            flush();
            
            $startTime = time();
            $maxDuration = 3600; // 超时设置
            $checkInterval = 5; // 检查间隔
            $lastQueueMessageTime = time(); // 记录上次发送队列消息的时间
            $queueMessageInterval = 60; // 队列消息发送间隔（秒）
            
            while (time() - $startTime < $maxDuration) {
                try {
                    // 查询任务状态
                    $task = \App\Models\MpGenerateVideoTask::find($taskId);
                    if (!$task) {
                        echo "data: " . json_encode([
                            'type' => 'error',
                            'message' => '任务不存在'
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }
                    
                    // 如果任务完成（成功或失败），结束连接
                    if (in_array($task->status, [
                        'success',
                        'failed'
                    ])) {
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'video_url' => $task->compressed_url ?: $task->result_url,
                                'origin_video_url' => $task->result_url,
                                'last_frame_url' => $task->last_frame_url,
                                'error_message' => $task->error_message ? mapErrorMessage($task->error_message) : ''
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }
                    
                    // 每分钟发送一次队列状态消息
                    $currentTime = time();
                    if ($currentTime - $lastQueueMessageTime >= $queueMessageInterval) {
                        echo "data: " . json_encode([
                            'type' => 'queue',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'elapsed_time' => $currentTime - $startTime,
                                'message' => '任务正在队列中执行...'
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        $lastQueueMessageTime = $currentTime;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage()
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '任务执行超时，请稍后查询任务状态',
                    'data' => [
                        'task_id' => $taskId
                    ]
                ]) . "\n\n";
                if (ob_get_level() > 0) ob_flush();
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    /**
     * 文生视频（通用）
     * 支持传入视频参数、提示词、参考图等信息，不支持products入参
     */
    public function generateVideo(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();

        // 创建视频生成任务
        $result = $this->AnimeService->generateVideo($data);
        $taskId = $result['task_id'];

        // 创建任务中心记录并关联视频任务ID
        $taskCenter = $this->taskCenterService->createTask('video', [
            'title'       => '文生视频',
            'ref_task_id' => $taskId,
            // 'prompt'      => getProp($data, 'prompt', ''),
            // 'params'      => json_encode($data, JSON_UNESCAPED_UNICODE),
        ]);
        $taskCenterId = $taskCenter->id;

        // 设置 SSE 响应头
        return response()->stream(function () use ($taskId, $taskCenterId, $result) {
            // 立即发送 init 消息
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => $result,
                'task_center_id' => $taskCenterId,
            ]) . "\n\n";
            if (ob_get_level() > 0) ob_flush();
            flush();

            $startTime = time();
            $maxDuration = 3600; // 超时设置
            $checkInterval = 5; // 检查间隔
            $lastQueueMessageTime = time(); // 记录上次发送队列消息的时间
            $queueMessageInterval = 60; // 队列消息发送间隔（秒）

            while (time() - $startTime < $maxDuration) {
                try {
                    // 查询任务状态
                    $task = \App\Models\MpGenerateVideoTask::find($taskId);
                    if (!$task) {
                        echo "data: " . json_encode([
                            'type' => 'error',
                            'message' => '任务不存在'
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }

                    // 如果任务完成（成功或失败），结束连接
                    if (in_array($task->status, [
                        'success',
                        'failed'
                    ])) {
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'video_url' => $task->compressed_url ?: $task->result_url,
                                'origin_video_url' => $task->result_url,
                                'last_frame_url' => $task->last_frame_url,
                                'error_message' => $task->error_message ? mapErrorMessage($task->error_message) : ''
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }

                    // 每分钟发送一次队列状态消息
                    $currentTime = time();
                    if ($currentTime - $lastQueueMessageTime >= $queueMessageInterval) {
                        echo "data: " . json_encode([
                            'type' => 'queue',
                            'data' => [
                                'task_id' => $task->id,
                                'status' => $task->status,
                                'elapsed_time' => $currentTime - $startTime,
                                'message' => '任务正在队列中执行...'
                            ]
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        $lastQueueMessageTime = $currentTime;
                    }

                    sleep($checkInterval);

                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage()
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                    sleep($checkInterval);
                }
            }

            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '任务执行超时，请稍后查询任务状态',
                    'data' => [
                        'task_id' => $taskId
                    ]
                ]) . "\n\n";
                if (ob_get_level() > 0) ob_flush();
                flush();
            }

        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }

    /**
     * 预估视频生成所需积分（单一/批量）
     * 传参与创建接口一致，批量场景需额外传 type=batch_segment / batch_act
     *
     * @param Request $request
     * @return mixed
     */
    public function previewCharge(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->previewCharge($data);
        return $this->success($result);
    }

    /**
     * 批量生成片段视频
     */
    public function batchSetActVideos(Request $request) {
        // 忽略所有超时限制
        set_time_limit(0);
        ini_set('max_execution_time', '0');

        $data = $request->all();
        
        // 验证参数
        $validator = Validator::make($data, [
            'anime_id' => 'required|string',
            'episode_id' => 'required|integer',
        ], [
            'anime_id.required' => '动漫对话ID不能为空',
            'episode_id.required' => '剧集ID不能为空',
            'episode_id.integer' => '剧集ID必须是整数',
        ]);
        
        if ($validator->fails()) {
            return response()->stream(function () use ($validator) {
                echo "data: " . json_encode([
                    'type' => 'error',
                    'message' => $validator->errors()->first()
                ]) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            }, 200, [
                'Content-Type' => 'text/event-stream',
                'Cache-Control' => 'no-cache',
                'Connection' => 'keep-alive',
                'X-Accel-Buffering' => 'no',
            ]);
        }
        
        $animeId = $data['anime_id'];
        $episodeId = $data['episode_id'];

        $episode = DB::table('mp_anime_episodes')->where('id', $episodeId)->where('anime_id', $animeId)->first();
        if (!$episode) {
            return response()->stream(function () {
                echo "data: " . json_encode([
                    'type' => 'error',
                    'message' => '分集不存在'
                ]) . "\n\n";
                if (ob_get_level() > 0) {
                    ob_flush();
                }
                flush();
            }, 200, [
                'Content-Type' => 'text/event-stream',
                'Cache-Control' => 'no-cache',
                'Connection' => 'keep-alive',
                'X-Accel-Buffering' => 'no',
            ]);
        }
        $episodeNumber = $episode->episode_number;        
        $ratio = !empty($episode->ratio) ? $episode->ratio : '9:16';
        $generate_audio = getProp($data, 'generate_audio', 1);

        // 合并角色、场景和道具作为products，统一字段名为product_name
        $products = [];
        $roles = json_decode(getProp($episode, 'roles'), true) ?: [];
        $scenes = json_decode(getProp($episode, 'scenes'), true) ?: [];
        $props = json_decode(getProp($episode, 'props'), true) ?: [];
        
        // 处理角色数组
        foreach ($roles as $role) {
            $product = $role;
            // 将role字段重命名为product_name
            if (isset($product['role'])) {
                $product['product_name'] = $product['role'];
                unset($product['role']);
            }
            $product['product'] = 1; // 标记类型为角色
            $products[] = $product;
        }
        
        // 处理场景数组
        foreach ($scenes as $scene) {
            $product = $scene;
            // 将scene字段重命名为product_name
            if (isset($product['scene'])) {
                $product['product_name'] = $product['scene'];
                unset($product['scene']);
            }
            $product['product'] = 2; // 标记类型为场景
            $products[] = $product;
        }
        
        // 处理道具数组
        foreach ($props as $prop) {
            $product = $prop;
            // 将prop字段重命名为product_name
            if (isset($product['prop'])) {
                $product['product_name'] = $product['prop'];
                unset($product['prop']);
            }
            $product['product'] = 3; // 标记类型为道具
            $products[] = $product;
        }
        
        // 处理视频模型（在循环外统一处理）
        // $model = getProp($data, 'model');
        // if (!$model) {
        //     // 用户没有输入，从episode表获取
        //     $model = getProp($episode, 'video_model');
        //     if (!$model) {
        //         // episode表也没有，使用默认值
        //         $model = 'zhizhen-20';
        //     }
        // }
        $model = 'zhizhen-20'; // 使用默认值
        // 验证模型是否在可用模型表中
        if (!DB::table('mp_video_models')->where('model', $model)->where('is_enabled', 1)->exists()) {
            $model = 'zhizhen-20';
        }
        
        // 获取所有分镜信息
        $acts = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->orderBy('act_number')
            ->get();
            
        if ($acts->isEmpty()) {
            return response()->stream(function () {
                echo "data: " . json_encode([
                    'type' => 'error',
                    'message' => '未找到分镜数据'
                ]) . "\n\n";
                if (ob_get_level() > 0) ob_flush();
                flush();
            }, 200, [
                'Content-Type' => 'text/event-stream',
                'Cache-Control' => 'no-cache',
                'Connection' => 'keep-alive',
                'X-Accel-Buffering' => 'no',
            ]);
        }

        foreach($acts as $act) {
            $videoDuration = $act->act_duration;
            if (!$videoDuration || $videoDuration <= 0) {
                return response()->stream(function () {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '请检查是否有时长为空的片段'
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                }, 200, [
                    'Content-Type' => 'text/event-stream',
                    'Cache-Control' => 'no-cache',
                    'Connection' => 'keep-alive',
                    'X-Accel-Buffering' => 'no',
                ]);
            }
        }   
        
        // 余额预检：按实际需要生成的片段逐条按时长估算积分，不足直接报错
        $needPoints = 0;
        foreach ($acts as $act) {
            if ($act->video_task_status === '生成中' || (int)$act->current_type === 2) {
                continue;
            }
            $duration = (int)ceil((float)$act->act_duration);
            if ($duration <= 0) {
                $duration = 5; // 无时长时按默认5秒预估
            }
            $needPoints += $this->pointsService->getVideoChargePoints([
                'model' => $model,
                'video_resolution' => '720p',
                'video_duration' => $duration,
                'ratio' => $ratio,
                'generate_audio' => (int)$generate_audio,
            ]);
        }
        if ($needPoints > 0) {
            $this->pointsService->checkUserPointsEnough($needPoints);
        }
        
        // 批量创建视频任务
        $taskIds = [];
        $actTasks = [];
        
        foreach ($acts as $act) {
            try {
                // 检查视频任务正在生成中或当前状态为视频
                if ($act->video_task_status === '生成中') {
                    $actTasks[] = [
                        'act_id' => $act->id,
                        'task_id' => $act->video_task_id,
                        'act_number' => $act->act_number,
                        'act_content' => $act->act_content,
                        'audio_duration' => $act->audio_duration,
                    ];
                    continue;
                }

                if ((int)$act->current_type === 2) {
                    continue;
                }
                
                // 获取分镜内容
                $actContent = $act->act_show_content ?: '';
                // 构建完整的提示词
                $processResult = $this->AnimeService->processActContentWithProducts($actContent, $products);
                $fullPrompt = $processResult['content'];
                $reference_images = $processResult['reference_images'];
                $videoDuration = $act->act_duration;                
                
                // 构建视频生成参数
                $videoParams = [
                    'model' => $model,
                    'alias_act_id' => $act->id,
                    'prompt' => $fullPrompt,
                    'video_duration' => $videoDuration,
                    'video_resolution' => '720P',
                    'seed' => -1,
                    'ratio' => $ratio,
                    'generate_audio' => (int)$generate_audio === 0 ? false : true,
                    'draft' => false,
                    'watermark' => false,
                    'camera_fixed' => false,
                    // 'callback_url' => 'http://mpaudio.yqsd.cn/api/video/seedanceCallback'
                ];
                
                // 如果分镜有图片，作为首帧
                $hasImage = !empty($act->img_url);
                $hasVideo = !empty($act->video_url);
                
                if ($hasImage) {
                    $videoParams['first_frame_url'] = $act->img_url;
                }
                
                // 构建content数组
                $videoParams['content'] = [
                    [
                        'type' => 'text',
                        'text' => $videoParams['prompt'],
                    ]
                ];
                
                // 如果有首帧图片，添加到content中
                if ($hasImage) {
                    if (in_array($model, ['doubao-seedance-2-0-260128', 'doubao-seedance-2-0-fast-260128'])) {
                        $videoParams['content'][] = [
                            'type' => 'image_url',
                            'image_url' => [
                                'url' => $videoParams['first_frame_url'],
                            ],
                            'role' => 'reference_image',
                        ];
                    }else {
                        $videoParams['content'][] = [
                            'type' => 'image_url',
                            'image_url' => [
                                'url' => $videoParams['first_frame_url'],
                            ],
                            'role' => 'first_frame',
                        ];
                    }
                }
                
                // 获取配音音频URL和时长
                $audioUrl = $act->audio_url ?? '';
                $audioDuration = $act->audio_duration ?? 0;
                
                // 音频传入的前提：必须有至少一张图片或一个视频
                $canUseAudio = ($hasImage || $hasVideo) && !empty($audioUrl);
                
                // 根据模型选择不同的视频生成方法
                if (strpos($model, 'jimeng') !== false) {
                    // 即梦模型参数调整
                    $videoParams['video_duration'] = $videoDuration > 5 ? 10 : 5; // 即梦只支持5s或10s
                    $videoParams['aspect_ratio'] = $videoParams['ratio']; // 即梦使用aspect_ratio
                    unset($videoParams['ratio']);
                    unset($videoParams['content']); // 即梦不使用content格式
                    $task = $this->AIVideoGenerationService->createJimengTask($videoParams);
                } elseif (strpos($model, 'kling') !== false) {
                    // Keling模型参数调整
                    $videoParams['video_duration'] = max(3, min(15, ceil($videoDuration))); // Keling支持3-15秒
                    $videoParams['aspect_ratio'] = $videoParams['ratio']; // Keling使用aspect_ratio
                    unset($videoParams['ratio']);
                    unset($videoParams['content']); // Keling不使用content格式
                    $task = $this->AIVideoGenerationService->createKelingOmniTask($videoParams);
                } elseif (strpos($model, 'zhizhen') !== false) {
                    // 构建统一API参数
                    $unifiedParams = [
                        'model_code' => $model,
                        'alias_act_id' => $act->id,
                        'prompt' => trim($fullPrompt),
                        'video_duration' => $videoDuration,
                        'video_resolution' => strtolower($videoParams['video_resolution']),
                        'video_ratio' => $ratio,
                        'seed' => -1,
                    ];
                    
                    // 构建parameters参数
                    $parameters = [
                        'seconds' => $unifiedParams['video_duration'],
                        'resolution' => $unifiedParams['video_resolution'],
                        'ratio' => $ratio,
                        // 'video_mode' => 'multi_image',
                        // 'mode' => 'multi_image',
                        'generate_audio' => (int)$generate_audio === 1 ? true : false,
                    ];
                    
                    $hasImage = false;
                    // 处理首帧和尾帧（智帧20模型必须要有首帧图片）
                    if ($hasImage) {
                        $parameters['first_frame_url'] = $videoParams['first_frame_url'];
                        if (isset($videoParams['tail_frame_url'])) {
                            $parameters['last_frame_url'] = $videoParams['tail_frame_url'];
                        }
                    }

                    if ($reference_images) {
                        $unifiedParams['ref_image_url'] = json_encode($reference_images, 256);
                        $reference_images = $this->AIImageGenerationService->processReferenceImagesToAssets($reference_images, $unifiedParams['prompt']);
                        $parameters['reference_images'] = $reference_images;
                        $parameters['video_mode'] = 'multi_image';
                        $parameters['mode'] = 'multi_image';
                    }
                    
                    $unifiedParams['parameters'] = $parameters;
                    
                    // 调用统一API创建任务
                    $task = $this->AIVideoGenerationService->createUnifiedApiTask($unifiedParams);
                } else {
                    // Seedance模型（默认）
                    // 检查是否为 Seedance 2.0 模型，如果是则需要处理配音音频
                    if ($canUseAudio && in_array($model, ['doubao-seedance-2-0-260128', 'doubao-seedance-2-0-fast-260128'])) {
                        // 添加配音音频到content中
                        $videoParams['content'][] = [
                            'type' => 'audio_url',
                            'audio_url' => [
                                'url' => $audioUrl,
                            ],
                            'role' => 'reference_audio',
                        ];
                        
                        // 优化提示词，增加音频相关描述
                        $audioPrompt = "全程使用音频1作为视频配音。" . $fullPrompt;
                        $videoParams['prompt'] = $audioPrompt;
                        $videoParams['content'][0]['text'] = $audioPrompt;
                    } else if ($videoDuration) {
                        // 有音频时长则需将视频时长设置为比音频时长更长的整数
                        $videoParams['video_duration'] = max(4, min(12, ceil($videoDuration)));   // seedance支持2-12s
                    }
                    $task = $this->AIVideoGenerationService->createSeedanceTask($videoParams);
                }
                $taskIds[] = $task->id;
                
                // 更新分镜表的视频任务信息
                DB::table('mp_episode_segments')
                    ->where('id', $act->id)
                    ->update([
                        'video_task_id' => $task->id,
                        'video_task_status' => '生成中',
                        'updated_at' => date('Y-m-d H:i:s')
                    ]);
                
                // 如果是全能模式，并且是第一集的第一个片段，将act_id存入Redis
                if ((int)$episodeNumber === 1 && (int)$act->act_number === 1) {
                    Redis::sadd('anime_act_first_frame_urls', $act->id);
                }
                
                $actTasks[] = [
                    'act_id' => $act->id,
                    'task_id' => $task->id,
                    'act_number' => $act->act_number,
                    'content' => $fullPrompt,
                    'audio_duration' => $act->audio_duration,
                ];
                
            } catch (\Exception $e) {
                $logData = [
                    'act_id' => $act->id,
                    'anime_id' => $animeId,
                    'error' => $e->getMessage(),
                ];
                dLog('anime')->error('创建分镜视频任务失败', $logData);
                logDB('anime', 'error', '创建分镜视频任务失败', $logData);
                continue;
            }
        }
        
        if (empty($taskIds)) {
            // 没有任务时，获取完整剧集信息进行验证
            $episode = $this->AnimeService->episodeInfoForAce([
                'anime_id' => $animeId,
                'episode_id' => $episodeId
            ]);
            
            // 检查所有片段是否都已生成视频且current_type=2
            $allActsValid = true;
            $invalidActs = [];
            
            $total_tasks_count = count($episode['acts']);
            foreach ($episode['acts'] as $act) {
                $videoUrl = getProp($act, 'video_url');
                $currentType = getProp($act, 'current_type');
                // 检查视频是否已生成
                if (!$videoUrl) {
                    $allActsValid = false;
                    $invalidActs[] = [
                        'act_number' => getProp($act, 'act_number'),
                        'reason' => '视频未生成'
                    ];
                    continue;
                }
                
                // 检查current_type是否为2
                if ($currentType != 2) {
                    $allActsValid = false;
                    $invalidActs[] = [
                        'act_number' => getProp($act, 'act_number'),
                        'reason' => '当前不是视频模式'
                    ];
                }
            }
            
            // 如果所有分镜都满足条件，使用SSE格式返回完成状态
            if ($allActsValid) {
                return response()->stream(function () use ($episode, $total_tasks_count) {
                    echo "data: " . json_encode([
                        'type' => 'completed',
                        'total_tasks_count' => $total_tasks_count,
                        'completed_tasks_count' => $total_tasks_count,
                        'success_tasks_count' => $total_tasks_count,
                        'episode' => $episode
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                }, 200, [
                    'Content-Type' => 'text/event-stream',
                    'Cache-Control' => 'no-cache',
                    'Connection' => 'keep-alive',
                    'X-Accel-Buffering' => 'no',
                ]);
            } else {
                // 有未完成或不满足条件的分镜，使用SSE格式报错
                $errorMsg = '存在未完成的片段：' . "\n";
                foreach ($invalidActs as $invalid) {
                    $errorMsg .= "分镜{$invalid['act_number']}：{$invalid['reason']}\n";
                }
                return response()->stream(function () use ($errorMsg) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => trim($errorMsg)
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                }, 200, [
                    'Content-Type' => 'text/event-stream',
                    'Cache-Control' => 'no-cache',
                    'Connection' => 'keep-alive',
                    'X-Accel-Buffering' => 'no',
                ]);
            }
        }
        
        // 保存模型到episode表
        DB::table('mp_anime_episodes')->where('id', $episodeId)->update([
            'video_model' => $model,
            'updated_at' => date('Y-m-d H:i:s')
        ]);
        
        // 记录开始时间（包含创建任务的时间）
        $startTime = time();
        $maxDuration = 7200;
        
        $uid = Site::getUid();
        // 设置 SSE 响应头并开始长连接
        return response()->stream(function () use ($taskIds, $actTasks, $animeId, $episodeNumber, $episodeId, $startTime, $maxDuration, $uid) {
            $checkInterval = 10; // 每10秒检查一次
            
            // 初始化任务数组
            $totalTasks = $taskIds; // 所有任务ID
            $completeTasks = []; // 已完成的任务ID（包含失败）
            $successTasks = []; // 成功的任务ID
            
            // 发送初始任务创建信息
            echo "data: " . json_encode([
                'type' => 'init',
                'total_tasks_count' => count($totalTasks),
                'completed_tasks_count' => count($completeTasks),
                'success_tasks_count' => count($successTasks)
            ]) . "\n\n";
            if (ob_get_level() > 0) ob_flush();
            flush();
            
            while (time() - $startTime < $maxDuration) {
                try {
                    $hasUpdate = false; // 标记是否有更新
                    
                    // 获取所有任务的最新状态
                    foreach ($totalTasks as $taskId) {
                        // 如果任务已经在完成列表中，跳过
                        if (in_array($taskId, $completeTasks)) {
                            continue;
                        }
                        
                        $task = \App\Models\MpGenerateVideoTask::find($taskId);
                        if (!$task) {
                            continue;
                        }
                        
                        // // 如果任务还在处理中，查询最新状态
                        // if ($task->status === 'processing') {
                        //     // 根据任务类型查询不同的状态
                        //     if ($task->api_type === 'jimeng') {
                        //         $statusResult = $this->AIVideoGenerationService->queryJimengTaskStatus($task);
                        //     } elseif ($task->api_type === 'keling') {
                        //         $statusResult = $this->AIVideoGenerationService->queryKelingOmniTaskStatus($task);
                        //     } elseif ($task->api_type === 'zzengine') {
                        //         $statusResult = $this->AIVideoGenerationService->queryUnifiedApiTaskStatus($task);
                        //     } else {
                        //         $statusResult = $this->AIVideoGenerationService->querySeedanceTaskStatus($task);
                        //     }
                            
                        //     if (isset($statusResult['status'])) {
                        //         // 更新任务状态
                        //         $task->update([
                        //             'status' => $statusResult['status'],
                        //             'result_json' => $statusResult['result_json'] ?? [],
                        //             'result_url' => $statusResult['result_url'] ?? null,
                        //             'last_frame_url' => $statusResult['last_frame_url'] ?? '',
                        //             'error_message' => $statusResult['error_message'] ?? null,
                        //             'completed_at' => in_array($statusResult['status'], [
                        //                 'success',
                        //                 'failed'
                        //             ]) ? now() : null
                        //         ]);
                                
                        //         // 如果任务成功，更新分镜表
                        //         if ($statusResult['status'] === 'success' && isset($statusResult['result_url'])) {
                        //             try {
                        //                 DB::beginTransaction();
                                        
                        //                 $now = date('Y-m-d H:i:s');
                                        
                        //                 // 获取分镜ID
                        //                 $actId = null;
                        //                 foreach ($actTasks as $actTask) {
                        //                     if ($actTask['task_id'] == $taskId) {
                        //                         $actId = $actTask['act_id'];
                        //                         $content = $actTask['content'];
                        //                         $audio_duration = $actTask['audio_duration'];
                        //                         break;
                        //                     }
                        //                 }
                                        
                        //                 if ($actId) {
                        //                     // 更新分镜表
                        //                     $actUpdateData = [
                        //                         'origin_video_url' => $statusResult['result_url'],
                        //                         'video_task_status' => '已完成',
                        //                         'last_frame_url' => $statusResult['last_frame_url'] ?? '',
                        //                         'current_type' => 2,
                        //                         'updated_at' => $now
                        //                     ];
                        //                     $compressed_video_url = compressVideo($statusResult['result_url']);
                        //                     $actUpdateData['video_url'] = $compressed_video_url ?: $statusResult['result_url'];
                                            
                        //                     // 只有当video_duration存在且大于0时才更新
                        //                     if (isset($statusResult['video_duration']) && $statusResult['video_duration'] > 0) {
                        //                         $actUpdateData['video_duration'] = $statusResult['video_duration'];
                        //                         $actUpdateData['video_time_point_start'] = 0;
                        //                         $actUpdateData['video_time_point_end'] = $statusResult['video_duration'];
                        //                     }
                                            
                        //                     $updateResult = DB::table('mp_episode_segments')
                        //                         ->where('id', $actId)
                        //                         ->update($actUpdateData);
                                            
                        //                     if ($updateResult) {
                        //                         // 更新分镜视频成功后新增对话记录
                        //                         // 获取参考图记录
                        //                         $reference_images = getProp($task, 'ref_image_url');
                        //                         if (!$reference_images) $reference_images = json_encode([], 256);
                        //                         $records = [
                        //                             [
                        //                                 'uid'           => $uid,
                        //                                 'anime_id'      => $animeId,
                        //                                 'sequence'      => $episodeNumber,
                        //                                 'role'          => 'user',
                        //                                 'content'       => '片段转视频',
                        //                                 'act_id'        => $actId,
                        //                                 'video_url'     => '',
                        //                                 'created_at'    => $now,
                        //                                 'updated_at'    => $now
                        //                             ],
                        //                             [
                        //                                 'uid'           => $uid,
                        //                                 'anime_id'      => $animeId,
                        //                                 'sequence'      => $episodeNumber,
                        //                                 'role'          => 'assistant',
                        //                                 'content'       => $content ?? '',
                        //                                 'act_id'        => $actId,
                        //                                 'video_url'     => $statusResult['result_url'],
                        //                                 'reference_images' => $reference_images,
                        //                                 'created_at'    => $now,
                        //                                 'updated_at'    => $now
                        //                             ]
                        //                         ];
                                                
                        //                         DB::table('mp_anime_records')->insert($records);
                        //                     }
                        //                 }
                                        
                        //                 DB::commit();
                                        
                        //             } catch (\Exception $e) {
                        //                 DB::rollBack();
                                        
                        //                 $logData = [
                        //                     'task_id' => $taskId,
                        //                     'error' => $e->getMessage()
                        //                 ];
                        //                 dLog('anime')->error('视频任务处理失败', $logData);
                        //                 logDB('anime', 'error', '视频任务处理失败', $logData);
                        //             }
                                    
                        //         } elseif ($statusResult['status'] === 'failed') {
                        //             // 获取分镜ID并更新失败状态
                        //             foreach ($actTasks as $actTask) {
                        //                 if ($actTask['task_id'] == $taskId) {
                        //                     DB::table('mp_episode_segments')
                        //                         ->where('id', $actTask['act_id'])
                        //                         ->update([
                        //                             'video_task_status' => '失败',
                        //                             'updated_at' => date('Y-m-d H:i:s')
                        //                         ]);
                        //                     break;
                        //                 }
                        //             }
                        //         }
                        //     }
                        // }
                        
                        // 检查任务是否完成（成功或失败）
                        if (in_array($task->status, ['success', 'failed'])) {
                            $completeTasks[] = $taskId;
                            $hasUpdate = true;
                            
                            if ($task->status === 'success') {
                                $successTasks[] = $taskId;
                            }
                        }
                    }
                    
                    // 如果有更新，发送update通知
                    if ($hasUpdate) {
                        echo "data: " . json_encode([
                            'type' => 'update',
                            'total_tasks_count' => count($totalTasks),
                            'completed_tasks_count' => count($completeTasks),
                            'success_tasks_count' => count($successTasks)
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                    }
                    
                    // 如果所有任务都完成了，结束连接
                    if (count($completeTasks) >= count($totalTasks)) {
                        
                        // 重新获取完整的剧集信息
                        $updatedEpisode = $this->AnimeService->episodeInfoForAce([
                            'anime_id' => $animeId,
                            'episode_id' => $episodeId
                        ]);
                        
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'total_tasks_count' => count($totalTasks),
                            'completed_tasks_count' => count($completeTasks),
                            'success_tasks_count' => count($successTasks),
                            'episode' => $updatedEpisode
                        ]) . "\n\n";
                        if (ob_get_level() > 0) ob_flush();
                        flush();
                        break;
                    }
                    
                    // 检查是否超时
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage(),
                        'total_tasks_count' => count($totalTasks),
                        'completed_tasks_count' => count($completeTasks),
                        'success_tasks_count' => count($successTasks)
                    ]) . "\n\n";
                    if (ob_get_level() > 0) ob_flush();
                    flush();
                    
                    // 检查是否超时，如果超时则停止循环
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '批量视频生成已超时，停止状态查询',
                    'total_tasks_count' => count($totalTasks),
                    'completed_tasks_count' => count($completeTasks),
                    'success_tasks_count' => count($successTasks)
                ]) . "\n\n";
                if (ob_get_level() > 0) ob_flush();
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }
}