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 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;

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

    // 文字模型
    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}%");
        }
        
        $models = $query->select('model', 'name')->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}%");
        }
        
        $models = $query->select('model', 'name')->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}%");
        }
        
        $models = $query->select('model', 'name')->get()->map(function ($value) {
            return (array)$value;
        })->toArray();
        
        return $this->success($models);
    }

    public function artStyleList()
    {
        $result = [
            [
                '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 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 editAnime(Request $request) {
        $data = $request->all();
        $result = $this->AnimeService->editAnime($data);
        return $this->success(['success'=>$result ? 1 : 0]);
    }

    // 修改分集主体列表
    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 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 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 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 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";
            ob_flush();
            flush();
            
            $startTime = time();
            $maxDuration = 300; // 5分钟超时
            $checkInterval = 5; // 每5秒检查一次
            
            while (time() - $startTime < $maxDuration) {
                try {
                    // 查询任务状态
                    $task = \App\Models\MpGenerateVideoTask::find($taskId);
                    if (!$task) {
                        echo "data: " . json_encode([
                            'type' => 'error',
                            'message' => '任务不存在'
                        ]) . "\n\n";
                        ob_flush();
                        flush();
                        break;
                    }
                    
                    // 如果任务还在处理中，查询最新状态
                    if ($task->status === 'processing') {
                        // 根据任务类型查询不同的状态
                        if ($task->task_type === 'jimeng') {
                            $statusResult = $this->AIVideoGenerationService->queryJimengTaskStatus($task);
                        } elseif ($task->task_type === 'keling') {
                            $statusResult = $this->AIVideoGenerationService->queryKelingOmniTaskStatus($task);
                        } else {
                            $statusResult = $this->AIVideoGenerationService->querySeedanceTaskStatus($task);
                        }
                        if (isset($statusResult['status'])) {
                            // 更新任务状态
                            $task->update([
                                'status' => $statusResult['status'],
                                '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
                                    $segment = DB::table('mp_episode_segments')
                                        ->where('video_task_id', $taskId)
                                        ->first();
                                    
                                    if (!$segment) {
                                        throw new \Exception('未找到对应的分镜记录');
                                    }
                                    
                                    $segmentId = $segment->segment_id;
                                    
                                    // 更新分镜表
                                    $updateResult = DB::table('mp_episode_segments')
                                        ->where('segment_id', $segmentId)
                                        ->update([
                                            'video_url' => $statusResult['result_url'],
                                            'video_task_status' => '已完成',
                                            'last_frame_url' => $statusResult['last_frame_url'] ?? '',
                                            'updated_at' => $now
                                        ]);
                                    
                                    if (!$updateResult) {
                                        Utils::throwError('20003:更新分镜表失败');
                                    }
                                    
                                    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') {
                                DB::table('mp_episode_segments')
                                    ->where('video_task_id', $taskId)
                                    ->update([
                                        'video_task_status' => '失败',
                                        'updated_at' => date('Y-m-d H:i:s')
                                    ]);
                            }
                        }
                    }
                    
                    // 发送当前状态
                    echo "data: " . json_encode([
                        'type' => 'update',
                        'data' => [
                            'task_id' => $task->id,
                            'status' => $task->status,
                            'result_url' => $task->result_url,
                            'error_message' => $task->error_message,
                            'elapsed_time' => time() - $startTime
                        ]
                    ]) . "\n\n";
                    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->result_url,
                                'last_frame_url' => $task->last_frame_url,
                                'error_message' => $task->error_message
                            ]
                        ]) . "\n\n";
                        ob_flush();
                        flush();
                        break;
                    }
                    
                    sleep($checkInterval);
                    
                } catch (\Exception $e) {
                    echo "data: " . json_encode([
                        'type' => 'error',
                        'message' => '查询任务状态失败: ' . $e->getMessage()
                    ]) . "\n\n";
                    ob_flush();
                    flush();
                    sleep($checkInterval);
                }
            }
            
            // 超时处理
            if (time() - $startTime >= $maxDuration) {
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '任务执行超时，请稍后查询任务状态',
                    'data' => [
                        'task_id' => $taskId
                    ]
                ]) . "\n\n";
                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;        
        // 获取所有分镜信息
        $segments = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            ->whereNotIn('video_task_status', ['已完成', '生成中'])
            ->orderBy('segment_number')
            ->limit(2)
            ->get();
            
        if ($segments->isEmpty()) {
            Utils::throwError('20003:未找到分镜数据');
        }
        
        // 批量创建视频任务
        $taskIds = [];
        $segmentTasks = [];
        
        foreach ($segments as $segment) {
            try {
                // 检查是否已有视频或正在生成中
                if (!empty($segment->video_url) || $segment->video_task_status === '生成中') {
                    continue;
                }
                
                // 获取分镜内容
                $segmentContent = $segment->segment_content ?: '';
                $tailFrame = $segment->tail_frame ?: '';
                
                // 构建完整的提示词
                $fullPrompt = $segmentContent;
                if ($tailFrame) {
                    $fullPrompt .= "\n尾帧描述：$tailFrame";
                }
                
                // 智能选择视频时长
                // $videoDuration = $this->AnimeService->calculateOptimalVideoDuration($segmentContent, $tailFrame);
                $videoDuration = -1;
                
                // 默认模型
                // $model = getProp($data, 'model', 'doubao-seedance-1-0-pro-250528');
                $model = getProp($data, 'model', 'doubao-seedance-1-5-pro-251215');
                
                // 构建视频生成参数
                $videoParams = [
                    'model' => $model,
                    'alias_segment_id' => $segment->segment_id,
                    'prompt' => $fullPrompt,
                    'video_duration' => $videoDuration,
                    'video_resolution' => '720P',
                    'seed' => -1,
                    'ratio' => '16:9',
                    'generate_audio' => false,
                    'draft' => false,
                    'watermark' => false,
                    'camera_fixed' => false,
                    // 'callback_url' => 'http://mpaudio.yqsd.cn/api/video/seedanceCallback'
                ];
                
                // 如果分镜有图片，作为首帧
                if (!empty($segment->img_url)) {
                    $videoParams['first_frame_url'] = $segment->img_url;
                }
                
                // 构建content数组
                $videoParams['content'] = [
                    [
                        'type' => 'text',
                        'text' => $videoParams['prompt'],
                    ]
                ];
                
                // 如果有首帧图片，添加到content中
                if (isset($videoParams['first_frame_url'])) {
                    $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;
                
                // 根据模型选择不同的视频生成方法
                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);
                } else {
                    // 检查是否为 Seedance 2.0 模型，如果是则需要处理配音音频
                    if (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(2, min(12, ceil($audioDuration)));   // seedance支持2-12s
                    }
                    // Seedance模型（默认）
                    $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,
                ];
                
            } 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:没有需要生成视频的分镜');
        }
        
        // 记录开始时间（包含创建任务的时间）
        $startTime = time();
        $maxDuration = 1800; // 30分钟超时
        
        // 设置 SSE 响应头并开始长连接
        return response()->stream(function () use ($taskIds, $segmentTasks, $animeId, $episodeNumber, $episodeId, $startTime, $maxDuration) {
            // 发送初始任务创建信息
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => [
                    'anime_id' => $animeId,
                    'episode_id' => $episodeId,
                    'episode_number' => $episodeNumber,
                    'total_tasks' => count($taskIds),
                    'task_ids' => $taskIds,
                    'segments' => $segmentTasks,
                    'start_time' => $startTime,
                    'max_duration' => $maxDuration
                ]
            ]) . "\n\n";
            ob_flush();
            flush();
            
            $checkInterval = 10; // 每10秒检查一次
            $completedTasks = [];
            $failedTasks = [];
            
            // 检查是否已经超时（包含创建任务的时间）
            while (time() - $startTime < $maxDuration) {
                try {
                    $allCompleted = true;
                    $currentStatus = [];
                    
                    foreach ($segmentTasks as $segmentTask) {
                        $taskId = $segmentTask['task_id'];
                        $segmentId = $segmentTask['segment_id'];
                        
                        // 跳过已完成或失败的任务
                        if (in_array($taskId, $completedTasks) || in_array($taskId, $failedTasks)) {
                            continue;
                        }
                        
                        // 查询任务状态
                        $task = \App\Models\MpGenerateVideoTask::find($taskId);
                        if (!$task) {
                            $failedTasks[] = $taskId;
                            continue;
                        }
                        
                        // 如果任务还在处理中，查询最新状态
                        if ($task->status === 'processing') {
                            // 根据任务类型查询不同的状态
                            if ($task->task_type === 'jimeng') {
                                $statusResult = $this->AIVideoGenerationService->queryJimengTaskStatus($task);
                            } elseif ($task->task_type === 'keling') {
                                $statusResult = $this->AIVideoGenerationService->queryKelingOmniTaskStatus($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');
                                        // 更新分镜表
                                        $updateResult = DB::table('mp_episode_segments')
                                            ->where('segment_id', $segmentId)
                                            ->update([
                                                'video_url' => $statusResult['result_url'],
                                                'video_task_status' => '已完成',
                                                'last_frame_url' => $statusResult['last_frame_url'] ?? '',
                                                'updated_at' => $now
                                            ]);
                                        
                                        if (!$updateResult) {
                                            Utils::throwError('20003:更新分镜表失败');
                                        }
                                        
                                        DB::commit();
                                        
                                        $completedTasks[] = $taskId;
                                        
                                        // 发送单个任务完成通知
                                        echo "data: " . json_encode([
                                            'type' => 'update',
                                            'data' => [
                                                'segment_id' => $segmentId,
                                                'task_id' => $taskId,
                                                'segment_number' => $segmentTask['segment_number'],
                                                'status' => 'success',
                                                'video_url' => $statusResult['result_url'],
                                                'last_frame_url' => $statusResult['last_frame_url'] ?? '',
                                                'completed_count' => count($completedTasks),
                                                'total_count' => count($segmentTasks)
                                            ]
                                        ]) . "\n\n";
                                        ob_flush();
                                        flush();
                                        
                                    } catch (\Exception $e) {
                                        DB::rollBack();
                                        
                                        $logData = [
                                            'segment_id' => $segmentId,
                                            'task_id' => $taskId,
                                            'error' => $e->getMessage()
                                        ];
                                        dLog('anime')->error('视频任务处理失败', $logData);
                                        logDB('anime', 'error', '视频任务处理失败', $logData);
                                        
                                        // 发送任务处理失败通知
                                        echo "data: " . json_encode([
                                            'type' => 'error',
                                            'data' => [
                                                'segment_id' => $segmentId,
                                                'task_id' => $taskId,
                                                'segment_number' => $segmentTask['segment_number'],
                                                'error_message' => '任务处理失败: ' . $e->getMessage()
                                            ]
                                        ]) . "\n\n";
                                        ob_flush();
                                        flush();
                                    }
                                    
                                } elseif ($statusResult['status'] === 'failed') {
                                    $updateResult = DB::table('mp_episode_segments')
                                        ->where('segment_id', $segmentId)
                                        ->update([
                                            'video_task_status' => '失败',
                                            'updated_at' => date('Y-m-d H:i:s')
                                        ]);
                                    
                                    $failedTasks[] = $taskId;
                                    
                                    // 发送任务失败通知
                                    echo "data: " . json_encode([
                                        'type' => 'update',
                                        'data' => [
                                            'segment_id' => $segmentId,
                                            'task_id' => $taskId,
                                            'segment_number' => $segmentTask['segment_number'],
                                            'status' => 'failed',
                                            'error_message' => $statusResult['error_message'] ?? '视频生成失败',
                                            'failed_count' => count($failedTasks),
                                            'total_count' => count($segmentTasks)
                                        ]
                                    ]) . "\n\n";
                                    ob_flush();
                                    flush();
                                }
                            }
                        }
                        
                        // 收集当前状态
                        $currentStatus[] = [
                            'segment_id' => $segmentId,
                            'task_id' => $taskId,
                            'segment_number' => $segmentTask['segment_number'],
                            'status' => $task->status,
                            'video_url' => $task->result_url,
                            'error_message' => $task->error_message
                        ];
                        
                        // 检查是否还有未完成的任务
                        if (!in_array($task->status, ['success', 'failed'])) {
                            $allCompleted = false;
                        }
                    }
                    
                    // 发送整体进度更新
                    echo "data: " . json_encode([
                        'type' => 'update',
                        'data' => [
                            'anime_id' => $animeId,
                            'episode_id' => $episodeId,
                            'episode_number' => $episodeNumber,
                            'completed_count' => count($completedTasks),
                            'failed_count' => count($failedTasks),
                            'total_count' => count($segmentTasks),
                            'elapsed_time' => time() - $startTime,
                            'remaining_time' => max(0, $maxDuration - (time() - $startTime)),
                            'segments_status' => $currentStatus
                        ]
                    ]) . "\n\n";
                    ob_flush();
                    flush();
                    
                    // 如果所有任务都完成了，结束连接
                    if ($allCompleted) {
                        // 获取最终结果
                        $finalSegments = DB::table('mp_episode_segments')
                            ->where('anime_id', $animeId)
                            ->where('episode_id', $episodeId)
                            ->orderBy('segment_number')
                            ->select('segment_id', 'segment_number', 'video_url', 'video_task_status', 'last_frame_url')
                            ->get();
                        
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'anime_id' => $animeId,
                                'episode_id' => $episodeId,
                                'episode_number' => $episodeNumber,
                                'completed_count' => count($completedTasks),
                                'failed_count' => count($failedTasks),
                                'total_count' => count($segmentTasks),
                                'total_elapsed_time' => time() - $startTime,
                                'segments' => $finalSegments->map(function($segment) {
                                    return [
                                        'segment_id' => $segment->segment_id,
                                        'segment_number' => $segment->segment_number,
                                        'video_url' => $segment->video_url,
                                        'status' => $segment->video_task_status,
                                        'last_frame_url' => $segment->last_frame_url
                                    ];
                                })->toArray()
                            ]
                        ]) . "\n\n";
                        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";
                    ob_flush();
                    flush();
                    
                    // 检查是否超时，如果超时则停止循环
                    if (time() - $startTime >= $maxDuration) {
                        break;
                    }
                    
                    sleep($checkInterval);
                }
            }
            
            // 超时处理 - 只有在真正超时时才执行
            if (time() - $startTime >= $maxDuration) {
                // 获取当前所有任务状态
                $timeoutSegments = DB::table('mp_episode_segments')
                    ->where('anime_id', $animeId)
                    ->where('episode_id', $episodeId)
                    ->orderBy('segment_number')
                    ->select('segment_id', 'segment_number', 'video_task_id', 'video_task_status', 'video_url')
                    ->get();
                
                echo "data: " . json_encode([
                    'type' => 'time_out',
                    'message' => '批量视频生成已超时30分钟，停止状态查询',
                    'data' => [
                        'anime_id' => $animeId,
                        'episode_id' => $episodeId,
                        'episode_number' => $episodeNumber,
                        'completed_count' => count($completedTasks),
                        'failed_count' => count($failedTasks),
                        'total_count' => count($segmentTasks),
                        'total_elapsed_time' => time() - $startTime,
                        'timeout_duration' => $maxDuration,
                        'segments' => $timeoutSegments->map(function($segment) {
                            return [
                                'segment_id' => $segment->segment_id,
                                'segment_number' => $segment->segment_number,
                                'task_id' => $segment->video_task_id,
                                'status' => $segment->video_task_status,
                                'video_url' => $segment->video_url
                            ];
                        })->toArray()
                    ]
                ]) . "\n\n";
                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(['success' => $result ? 1 : 0]);
    }

    // 获取分集生成图片信息
    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 缓冲
        ]);
    }

    /**
     * 创建完整视频合成任务
     * 
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function createCompleteVideoTask(Request $request)
    {
        $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) {
        $data = $request->all();

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

    /**
     * 导出分集的全部图片（下载并打包）
     */
    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 {
            // 获取剧集信息
            $episode = DB::table('mp_anime_episodes')
                ->where('anime_id', $animeId)
                ->where('id', $episodeId)
                ->select('episode_number', 'title')
                ->first();
            
            if (!$episode) {
                Utils::throwError('20003:未找到剧集信息');
            }
            
            // 获取所有分镜图片和音频
            $segments = DB::table('mp_episode_segments')
                ->where('anime_id', $animeId)
                ->where('episode_id', $episodeId)
                ->whereNotNull('img_url')
                ->where('img_url', '!=', '')
                ->orderBy('segment_number')
                ->select('segment_id', 'segment_number', 'img_url', 'audio_url', 'act_number', 'act_title')
                ->get();
            
            if ($segments->isEmpty()) {
                Utils::throwError('20003:该剧集暂无图片可导出');
            }
            
            // 创建临时目录
            $tempDir = storage_path('app/temp/episode_images_' . time() . '_' . mt_rand(1000, 9999));
            if (!file_exists($tempDir)) {
                mkdir($tempDir, 0755, true);
            }
            
            // 下载图片
            $downloadedFiles = [];
            foreach ($segments as $segment) {
                try {
                    $imgUrl = $segment->img_url;
                    if (empty($imgUrl)) {
                        continue;
                    }
                    
                    // 获取图片扩展名
                    $extension = pathinfo(parse_url($imgUrl, PHP_URL_PATH), PATHINFO_EXTENSION);
                    if (empty($extension)) {
                        $extension = 'jpg';
                    }
                    
                    // 构建文件名：分镜序号.扩展名
                    $fileName = sprintf(
                        '%03d.%s',
                        $segment->segment_number,
                        $extension
                    );
                    $filePath = $tempDir . '/' . $fileName;
                    
                    // 下载图片（使用file_get_contents，兼容性更好）
                    $context = stream_context_create([
                        'http' => [
                            'timeout' => 30,
                            'follow_location' => 1,
                            'ignore_errors' => true
                        ],
                        'ssl' => [
                            'verify_peer' => false,
                            'verify_peer_name' => false
                        ]
                    ]);
                    
                    $imageData = @file_get_contents($imgUrl, false, $context);
                    
                    if ($imageData !== false && !empty($imageData)) {
                        file_put_contents($filePath, $imageData);
                        $downloadedFiles[] = $filePath;
                    } else {
                        $logData = [
                            'segment_id' => $segment->segment_id,
                            'img_url' => $imgUrl
                        ];
                        dLog('anime')->warning('图片下载失败', $logData);
                        logDB('anime', 'warning', '图片下载失败', $logData);
                    }
                    
                } catch (\Exception $e) {
                    $logData = [
                        'segment_id' => $segment->segment_id,
                        'img_url' => $segment->img_url,
                        'error' => $e->getMessage()
                    ];
                    dLog('anime')->error('下载图片异常', $logData);
                    logDB('anime', 'error', '下载图片异常', $logData);
                    continue;
                }
            }
            
            if (empty($downloadedFiles)) {
                // 清理临时目录
                if (file_exists($tempDir)) {
                    array_map('unlink', glob("$tempDir/*"));
                    rmdir($tempDir);
                }
                Utils::throwError('20003:没有成功下载任何图片');
            }
            
            // 处理音频合成
            $mergedAudioPath = null;
            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 {
                                    $logData = [
                                        'segment_id' => $segment->segment_id,
                                        'audio_url' => $segment->audio_url
                                    ];
                                    dLog('anime')->warning('音频下载失败', $logData);
                                    logDB('anime', 'warning', '音频下载失败', $logData);
                                }
                            } catch (\Exception $e) {
                                $logData = [
                                    'segment_id' => $segment->segment_id,
                                    'audio_url' => $segment->audio_url,
                                    'error' => $e->getMessage()
                                ];
                                dLog('anime')->error('下载音频异常', $logData);
                                logDB('anime', 'error', '下载音频异常', $logData);
                            }
                        }
                    }
                    
                    // 如果有音频文件，则进行合成
                    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)) {
                            $logData = [
                                'command' => $ffmpegCommand,
                                'output' => implode("\n", $ffmpegOutput),
                                'return_code' => $ffmpegReturnCode
                            ];
                            dLog('anime')->error('FFmpeg 合成音频失败', $logData);
                            logDB('anime', 'error', 'FFmpeg 合成音频失败', $logData);
                            $mergedAudioPath = null;
                        } else {
                            $logData = [
                                'audio_count' => count($audioFiles),
                                'output_file' => $mergedAudioPath,
                                'file_size' => filesize($mergedAudioPath)
                            ];
                            dLog('anime')->info('音频合成成功', $logData);
                            logDB('anime', 'info', '音频合成成功', $logData);
                        }
                        
                        // 清理临时音频文件和 concat 文件
                        foreach ($audioFiles as $audioFile) {
                            if (file_exists($audioFile)) {
                                @unlink($audioFile);
                            }
                        }
                        if (file_exists($concatFile)) {
                            @unlink($concatFile);
                        }
                    }
                } else {
                    dLog('anime')->warning('FFmpeg 未安装，跳过音频合成');
                    logDB('anime', 'warning', 'FFmpeg 未安装，跳过音频合成', []);
                }
            } catch (\Exception $e) {
                $logData = [
                    'error' => $e->getMessage(),
                    'trace' => $e->getTraceAsString()
                ];
                dLog('anime')->error('音频合成过程异常', $logData);
                logDB('anime', 'error', '音频合成过程异常', $logData);
                // 音频合成失败不影响图片导出
                $mergedAudioPath = null;
            }
            
            // 创建zip文件
            $zipFileName = sprintf(
                '%s.zip',
                $episode->title ?: '未命名'
            );
            $zipFilePath = storage_path('app/temp/' . $zipFileName);
            
            $zip = new \ZipArchive();
            if ($zip->open($zipFilePath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
                // 清理临时文件
                array_map('unlink', $downloadedFiles);
                rmdir($tempDir);
                Utils::throwError('20003:创建ZIP文件失败');
            }
            
            // 添加图片文件到zip
            foreach ($downloadedFiles as $file) {
                $zip->addFile($file, basename($file));
            }
            
            // 添加合成的音频文件到zip
            if ($mergedAudioPath && file_exists($mergedAudioPath)) {
                $zip->addFile($mergedAudioPath, 'tts.wav');
            }
            
            $zip->close();
            
            // 清理临时图片文件
            array_map('unlink', $downloadedFiles);
            
            // 清理合成的音频文件
            if ($mergedAudioPath && file_exists($mergedAudioPath)) {
                @unlink($mergedAudioPath);
            }
            
            rmdir($tempDir);
            
            // 返回文件下载响应
            return response()->download($zipFilePath, $zipFileName)->deleteFileAfterSend(true);
            
        } catch (\Exception $e) {
            $logData = [
                'anime_id' => $animeId,
                'episode_id' => $episodeId,
                'error' => $e->getMessage()
            ];
            dLog('anime')->error('导出分集图片失败', $logData);
            logDB('anime', 'error', '导出分集图片失败', $logData);
            
            // 清理可能存在的临时文件
            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'];
        
        // 获取所有分镜信息
        $segments = DB::table('mp_episode_segments')
            ->where('anime_id', $animeId)
            ->where('episode_id', $episodeId)
            // ->whereNotNull('pic_task_id')
            ->orderBy('segment_number')
            ->select('segment_id', 'segment_number', 'pic_task_id', 'pic_task_status', 'audio_task_id', 'audio_task_status', 'img_url', 'audio_url')
            ->get();
            
        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) {
            // 发送初始任务信息
            echo "data: " . json_encode([
                'type' => 'init',
                'data' => [
                    'anime_id' => $animeId,
                    'episode_id' => $episodeId,
                    'total_segments' => count($segments),
                    'start_time' => $startTime,
                    'max_duration' => $maxDuration
                ]
            ]) . "\n\n";
            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;
                        
                        // 跳过已处理完成的分镜
                        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;
                            }
                        }
                        
                        // 检查音频任务状态
                        $audioTask = DB::table('mp_dub_video_tasks')
                            ->where('alias_segment_id', $segmentId)
                            ->orderBy('id', 'desc')
                            ->select('generate_status', 'audio_url')
                            ->first();
                        
                        if ($audioTask && in_array($audioTask->generate_status, ['执行成功', '执行失败'])) {
                            $updateData = [
                                'audio_task_status' => $audioTask->generate_status === '执行成功' ? '已完成' : '失败',
                                'updated_at' => date('Y-m-d H:i:s')
                            ];
                            
                            if ($audioTask->generate_status === '执行成功' && !empty($audioTask->audio_url)) {
                                $updateData['audio_url'] = $audioTask->audio_url;
                                $audioCompleted = true;
                            } else if ($audioTask->generate_status === '执行失败') {
                                // 失败时清空音频URL
                                $updateData['audio_url'] = '';
                            }
                            
                            // 静默更新分镜表的音频URL（不输出通知）
                            DB::table('mp_episode_segments')
                                ->where('segment_id', $segmentId)
                                ->update($updateData);
                            
                            $audioProcessed = true;
                        }
                        
                        // 如果图片和音频都成功完成，标记为已完成
                        if ($picCompleted && $audioCompleted) {
                            $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), // 已处理完成的数量（成功+失败）
                                'total_count' => count($segments),
                                'elapsed_time' => time() - $startTime,
                                'remaining_time' => max(0, $maxDuration - (time() - $startTime))
                            ]
                        ]) . "\n\n";
                        ob_flush();
                        flush();
                    }
                    
                    // 如果所有分镜都已处理完成（成功或失败），获取最终结果并结束连接
                    if (count($processedSegments) === count($segments)) {
                        // 获取剧集信息
                        $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的格式组织数据
                            $acts = [];
                            foreach($allSegments as $segment) {
                                $segmentData = [
                                    'segment_id' => getProp($segment, 'segment_id'),
                                    'segment_number' => getProp($segment, 'segment_number'),
                                    'segment_content' => getProp($segment, 'segment_content'),
                                    'description' => getProp($segment, 'description'),
                                    'composition' => getProp($segment, 'composition'),
                                    'camera_movement' => getProp($segment, 'camera_movement'),
                                    'voice_actor' => getProp($segment, 'voice_actor'),
                                    'dialogue' => getProp($segment, 'dialogue'),
                                    'frame_type' => getProp($segment, 'frame_type'),
                                    'scene' => getProp($segment, 'scene'),
                                    'characters' => getProp($segment, 'characters'),
                                    'tail_frame' => getProp($segment, 'tail_frame'),
                                    'emotion' => getProp($segment, 'emotion'),
                                    'emotion_type' => getProp($segment, 'emotion_type'),
                                    'gender' => getProp($segment, 'gender'),
                                    'speed_ratio' => getProp($segment, 'speed_ratio'),
                                    'loudness_ratio' => getProp($segment, 'loudness_ratio'),
                                    'emotion_scale' => getProp($segment, 'emotion_scale'),
                                    'pitch' => getProp($segment, 'pitch'),
                                    'voice_name' => getProp($segment, 'voice_name'),
                                    'voice_type' => getProp($segment, 'voice_type'),
                                    'voice_audio_url' => getProp($segment, 'voice_audio_url'),
                                    'img_url' => getProp($segment, 'img_url'),
                                    'audio_url' => getProp($segment, 'audio_url'),
                                    'video_url' => getProp($segment, 'video_url'),
                                    'last_frame_url' => getProp($segment, 'last_frame_url'),
                                ];
                                
                                $actNumber = getProp($segment, 'act_number');
                                if (isset($acts[$actNumber])) {
                                    $acts[$actNumber]['segments'][] = $segmentData;
                                } else {
                                    $acts[$actNumber] = [
                                        'act_number' => $actNumber,
                                        'act_title' => getProp($segment, 'act_title'),
                                        'segments' => [$segmentData]
                                    ];
                                }
                            }
                            $episode['acts'] = array_values($acts);
                        }
                        
                        echo "data: " . json_encode([
                            'type' => 'completed',
                            'data' => [
                                'anime_id' => $animeId,
                                'episode_id' => $episodeId,
                                'completed_count' => count($completedSegments), // 成功完成的数量
                                'processed_count' => count($processedSegments), // 已处理完成的数量（成功+失败）
                                'total_count' => count($segments),
                                'total_elapsed_time' => time() - $startTime,
                                'episode_info' => $episode ?? null
                            ]
                        ]) . "\n\n";
                        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";
                    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), // 已处理完成的数量（成功+失败）
                        'total_count' => count($segments),
                        'total_elapsed_time' => time() - $startTime,
                        'timeout_duration' => $maxDuration
                    ]
                ]) . "\n\n";
                ob_flush();
                flush();
            }
            
        }, 200, [
            'Content-Type' => 'text/event-stream',
            'Cache-Control' => 'no-cache',
            'Connection' => 'keep-alive',
            'X-Accel-Buffering' => 'no', // 禁用 Nginx 缓冲
        ]);
    }
}