mp_audio_manage/app/Services/AIGeneration/AIVideoGenerationService.php

<?php

namespace App\Services\AIGeneration;

use App\Libs\Utils;
use App\Models\MpGenerateVideoTask;
use App\Models\AIElement;
use App\Services\VolcEngineService;
use GuzzleHttp\Client;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Redis;

class AIVideoGenerationService
{
    private $volcEngineService;

    public function __construct(VolcEngineService $volcEngineService)
    {
        $this->volcEngineService = $volcEngineService;
    }

    /**
     * 异步创建视频生成任务
     *
     * @param array $params
     * @return MpGenerateVideoTask
     */
    public function createJimengTask(array $params): MpGenerateVideoTask
    {
        // 生成唯一的任务ID
        $taskId = 'vid_gen_' . time() . '_' . uniqid();

        // 创建任务记录
        $task = MpGenerateVideoTask::create([
            'task_id' => $taskId,
            'prompt' => $params['prompt'] ?? '',
            'first_frame_url' => $params['first_frame_url'] ?? null,
            'tail_frame_url' => $params['tail_frame_url'] ?? null,
            'seed' => $params['seed'] ?? -1,
            'frames' => $params['video_duration'] ? ($params['video_duration'] * 24 + 1) : 121,
            'video_resolution' => $params['video_resolution'] ?? '720P',
            'status' => MpGenerateVideoTask::STATUS_PENDING,
            'api_type' => 'jimeng',
        ]);

        // 发送异步请求到即梦AI API创建任务
        $this->submitTaskToApi($task);

        return $task;
    }

    /**
     * 提交任务到即梦AI API
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function submitTaskToApi(MpGenerateVideoTask $task): void
    {
        try {
            // 验证环境变量配置
            $accessKey = env('VOLC_AI_AK');
            $secretKey = env('VOLC_AI_SK');
                
            if (empty($accessKey) || empty($secretKey)) {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '火山引擎访问密钥未配置，请检查环境变量AK和SK'
                ]);
                return;
            }

            // 根据任务类型选择对应的req_key
            if ($task->first_frame_url && $task->tail_frame_url) {
                $req_key = $task->video_resolution == '720P' ? 'jimeng_i2v_first_tail_v30' : 'jimeng_i2v_first_tail_v30_1080';
            }else if($task->first_frame_url){
                $req_key = $task->video_resolution == '720P' ? 'jimeng_i2v_first_v30' : 'jimeng_i2v_first_v30_1080';
            }else{
                $req_key = $task->video_resolution == '720P' ? 'jimeng_t2v_v30' : 'jimeng_t2v_v30_1080p';
            }
                
            // 构建即梦AI 3.0 视频生成API请求参数
            $apiParams = [
                'req_key' => $req_key,
                'prompt' => $task->prompt,
                'seed' => (int)$task->seed,
                'frames' => $task->frames,
            ];

            // 添加图片URL参数
            if ($task->first_frame_url) {
                $apiParams['image_urls'] = [
                    $task->first_frame_url
                ];

                if ($task->tail_frame_url) $apiParams['image_urls'][] = $task->tail_frame_url;
            }
            
            dLog('generate')->info('图生视频参数: ', $apiParams);
            logDB('generate', 'info', '即梦AI视频生成任务提交', ['id' => $task->id, 'params' => $apiParams]);
            
            // 调用即梦AI 3.0 视频生成API提交任务
            $response = $this->volcEngineService->request(
                'POST',
                'visual.volcengineapi.com', // 即梦AI API域名
                '/', // 使用根路径
                [], // Query参数
                json_encode($apiParams),
                $accessKey,
                $secretKey,
                'cv', // 服务标识
                'cn-north-1', // 区域
                'CVSync2AsyncSubmitTask',
                '2022-08-31',
                'application/json'
            );

            $responseData = json_decode($response['body'], true);
            dLog('generate')->info('即梦AI 3.0 视频生成API提交任务响应: ', $responseData);
            logDB('generate', 'info', '即梦AI视频生成API响应', ['id' => $task->id, 'response' => $responseData]);
                
            if ($responseData['code'] !== 10000) {
                // API返回错误
                logDB('generate', 'error', '即梦AI视频生成任务提交失败', ['id' => $task->id, 'error' => $responseData['message'] ?? 'API Error']);
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => $responseData['message'] ?? 'API Error',
                    'extra_params' => $responseData['data'] ?? []
                ]);
            } else {
                // 任务提交成功，更新状态为处理中
                $updateData = [];
                // 存储API返回的任务ID
                if (isset($responseData['data']['task_id'])) {
                    $updateData['task_id'] = $responseData['data']['task_id'];
                    $updateData['extra_params'] = $responseData['data'] ?? [];
                    $updateData['extra_params']['req_key'] = $req_key;
                    $updateData['extra_params']['request_id'] = isset($responseData['request_id']) ? $responseData['request_id'] : '';
                }

                $task->updateStatus(MpGenerateVideoTask::STATUS_PROCESSING, $updateData);
            }
        } catch (\Exception $e) {
            // 记录错误
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
            Utils::throwError('1001:'.$e->getMessage());
        }
    }

    /**
     * 查询任务状态(即梦AI)
     *
     * @param MpGenerateVideoTask $task
     * @return array
     */
    public function queryJimengTaskStatus(MpGenerateVideoTask $task): array
    {
        try {
            // 获取API任务ID
            $apiTaskId = $task->task_id ?? null;
                
            if (!$apiTaskId) {
                return [
                    'status' => 'failed',
                    'error_message' => 'API任务ID不存在',
                    'result_url' => null
                ];
            }

            // 根据任务类型选择对应的req_key
            if ($task->first_frame_url && $task->tail_frame_url) {
                $req_key = $task->video_resolution == '720P' ? 'jimeng_i2v_first_tail_v30' : 'jimeng_i2v_first_tail_v30_1080';
            }else if($task->first_frame_url){
                $req_key = $task->video_resolution == '720P' ? 'jimeng_i2v_first_v30' : 'jimeng_i2v_first_v30_1080';
            }else{
                $req_key = $task->video_resolution == '720P' ? 'jimeng_t2v_v30' : 'jimeng_t2v_v30_1080p';
            }
    
            // 构建查询参数
            $apiParams = [
                'req_key' => $req_key,
                'task_id' => $apiTaskId,
                // 'req_json' => '{"return_url":true}' // 返回URL格式
            ];
    
            // 调用即梦AI 3.0 视频生成API查询任务状态
            $response = $this->volcEngineService->request(
                'POST',
                'visual.volcengineapi.com',
                '/', // 使用根路径
                [], // Query参数
                json_encode($apiParams),
                env('VOLC_AI_AK'),
                env('VOLC_AI_SK'),
                'cv',
                'cn-north-1',
                'CVSync2AsyncGetResult',
                '2022-08-31',
                'application/json'
            );
    
            $responseData = json_decode($response['body'], true);
            dLog('generate')->info('即梦AI 3.0 视频生成API查询任务状态响应: ', $responseData);
            logDB('generate', 'info', '即梦AI视频任务状态查询', ['id' => $task->id, 'response' => $responseData]);
    
            if ($responseData['code'] !== 10000) {
                // API返回错误
                logDB('generate', 'error', '即梦AI视频任务状态查询失败', ['id' => $task->id, 'error' => $responseData['message'] ?? 'API Error']);
                return [
                    'status' => 'failed',
                    'error_message' => $responseData['message'] ?? 'API Error',
                    'result_url' => null,
                    'result_json' => $responseData ?? []
                ];
            }
    
            // 解析API响应
            $result = $responseData['data'] ?? [];
            $taskStatus = $result['status'] ?? 'failed';
    
            $returnData = [
                'status' => $taskStatus,
                'error_message' => null,
                'result_url' => null,
                'result_json' => $responseData ?? []
            ];
    
            // 如果任务成功，获取结果URL
            if ($taskStatus === 'done' && isset($result['video_url'])) {
                if (isset($result['video_url'])) {
                    $video_name = 'ai_generation_' . time() . '_' . uniqid();
                    $video_ext = getVideoExtFromUrl($result['video_url']);
                    $video_name = $video_name . $video_ext;
                    // 将视频另存到tos
                    $url = uploadStreamByTos('video', file_get_contents($result['video_url']), $video_name);
                    $returnData['result_url'] = $url;
                    
                    // 压缩视频
                    $compressed_video_url = compressVideo($url);
                    $returnData['compressed_url'] = $compressed_video_url ?: $url;
                }
                
                // 计算视频时长
                $video_duration = 0;
                if (isset($result['duration'])) {
                    $video_duration = (int)$result['duration'];
                } elseif (isset($result['frames']) && isset($result['framespersecond'])) {
                    $frames = (int)$result['frames'];
                    $fps = (int)$result['framespersecond'];
                    if ($fps > 0) {
                        $video_duration = (int)floor($frames / $fps);
                    }
                }
                
                // 如果没有计算出时长，使用任务表中的设定值
                if ($video_duration <= 0 && !empty($task->extra_params)) {
                    $extraParams = is_array($task->extra_params) ? $task->extra_params : json_decode($task->extra_params, true);
                    if (isset($extraParams['duration'])) {
                        $video_duration = (int)$extraParams['duration'];
                    }
                }
                
                // 只有当video_duration > 0时才添加到返回数据中
                if ($video_duration > 0) {
                    $returnData['video_duration'] = $video_duration;
                    $returnData['video_time_point_start'] = 0;
                    $returnData['video_time_point_end'] = $video_duration;
                }
                
                $returnData['status'] = 'success';
            } elseif (in_array($taskStatus, ['not_found', 'expired'])) {
                $returnData['status'] = 'failed';
                $returnData['error_message'] = '任务未找到或已过期';
            } elseif ($taskStatus === 'failed') {
                $returnData['status'] = 'failed';
                $returnData['error_message'] = '任务执行失败';
            }
            // in_queue 或 generating状态保持原status
    
            return $returnData;
        } catch (\Exception $e) {
            return [
                'status' => 'failed',
                'error_message' => $e->getMessage(),
                'result_url' => null
            ];
        }
    }

    /**
     * 更新所有待处理任务的状态
     *
     * @return void
     */
    public function updatePendingTasks(): void
    {
        // 获取所有处理中的任务
        $tasks = MpGenerateVideoTask::where('status', MpGenerateVideoTask::STATUS_PROCESSING)
            ->get();

        foreach ($tasks as $task) {
            $api_type = getProp($task, 'api_type');
            switch($api_type) {
                case 'seedance':
                    $this->updateSeedanceTask($task);
                    break;
                case 'jimeng':
                    $this->updateJimengTask($task);
                    break;
                case 'keling':
                    $this->updateKelingOmniTask($task);
                    break;
                case 'zzengine':
                    $this->updateUnifiedApiTask($task);
                    break;
                case 'video_enhance':
                    $this->updateVideoEnhanceTask($task);
                    break;
                default:
                    break;
            }
        }
    }

    // 更新即梦AI视频任务状态
    private function updateJimengTask($task) {
        $statusInfo = $this->queryJimengTaskStatus($task);
        if (!isset($statusInfo['status'])) return;

        if ($statusInfo['status'] === 'success') {
            logDB('generate', 'info', '即梦AI视频生成任务成功', ['id' => $task->id, 'result_url' => $statusInfo['result_url']]);
            
            // 同步调整分镜视频状态和结果（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id && isset($statusInfo['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    // 在事务中更新任务状态
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 构建更新数据
                    $segmentUpdateData = [
                        'origin_video_url' => $statusInfo['result_url'],
                        'video_task_status' => '已完成',
                        'current_type' => 2,
                        'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                        'updated_at' => $now
                    ];
                    
                    // 使用查询任务时已压缩的视频URL，避免重复压缩
                    $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
                    
                    // 只有当video_duration存在且大于0时才更新
                    if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                        $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                        $segmentUpdateData['video_time_point_start'] = 0;
                        
                        $audio_duration = $this->getAudioDuration($task, $segment_id, $statusInfo['video_duration'] ?? null);
                        $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                    }
                    
                    // 更新分镜表（兼容act模式）
                    $this->updateSegmentTable($task, $segmentUpdateData);
                    
                    // 添加视频生成对话记录
                    $this->addVideoGenerationRecords($task, $segment_id, $statusInfo['result_url']);
                    
                    DB::commit();
                    
                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('generate')->error('即梦视频任务处理失败', [
                        'segment_id' => $segment_id,
                        'task_id' => $task->id,
                        'error' => $e->getMessage()
                    ]);
                }
            } else {
                // 没有segment_id的情况下，直接更新任务状态
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
            }
        } elseif ($statusInfo['status'] === 'failed') {
            logDB('generate', 'error', '即梦AI视频生成任务失败', ['id' => $task->id, 'error' => $statusInfo['error_message']]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, $statusInfo);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
        // 如果仍然是处理中状态，不做任何操作
        
        // 处理：如果任务处理超过12小时，标记为失败
        $processingTime = now()->diffInHours($task->created_at);
        if ($processingTime > 12) {
            logDB('generate', 'warning', '即梦AI视频生成任务超时', ['id' => $task->id, 'processing_hours' => $processingTime]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => '任务处理超时（超过12小时）'
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
    }
    
    public function getTaskList($data)
    {
        $task_id = getProp($data, 'task_id');
        $status = getProp($data, 'status');

        $query = MpGenerateVideoTask::select('*');
        if ($task_id) {
            $query->where('id', $task_id);
        }
        if ($status) {
            $query->where('status', $status);
        }

        return $query->orderBy('created_at', 'desc')->paginate();
    }

    /**
     * 创建 Seedance 1.5 Pro 视频生成任务
     *
     * @param array $params
     * @return MpGenerateVideoTask
     */
    public function createSeedanceTask(array $params): MpGenerateVideoTask
    {
        // 生成唯一的任务ID
        $taskId = 'seedance_' . time() . '_' . uniqid();

        // 创建任务记录，复用现有表结构
        $task = MpGenerateVideoTask::create([
            'task_id' => $taskId,
            'alias_segment_id' => $params['alias_segment_id'] ?? '',
            'alias_act_id' => $params['alias_act_id'] ?? '',
            'prompt' => $params['prompt'] ?? '',
            'first_frame_url' => $params['first_frame_url'] ?? '',
            'tail_frame_url' => $params['tail_frame_url'] ?? '',
            'seed' => $params['seed'] ?? -1,
            'frames' => $params['video_duration'] ? ($params['video_duration'] * 24 + 1) : null,
            'video_resolution' => $params['video_resolution'] ?? '720P',
            'status' => MpGenerateVideoTask::STATUS_PENDING,
            'api_type' => 'seedance', // 标识为 Seedance 1.5 Pro API
            'extra_params' => [
                'model' => $params['model'] ?? 'doubao-seedance-1-5-pro-251215',
                'content' => $params['content'],
                'callback_url' => $params['callback_url'] ?? '',
                'return_last_frame' => $params['return_last_frame'] ?? true,
                'service_tier' => $params['service_tier'] ?? 'default',
                'execution_expires_after' => $params['execution_expires_after'] ?? 172800,
                'video_resolution' => $params['video_resolution'] ?? '720P',
                'generate_audio' => $params['generate_audio'] ?? false,
                'draft' => $params['draft'] ?? false,
                'ratio' => $params['ratio'] ?? '9:16',
                'duration' => $params['video_duration'] ?? 5,
                'camera_fixed' => $params['camera_fixed'] ?? false,
                'watermark' => $params['watermark'] ?? false,
            ]
        ]);

        // 提交任务到火山引擎 API
        $this->submitSeedanceTaskToApi($task);

        return $task;
    }

    /**
     * 提交 Seedance 任务到火山引擎 API
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function submitSeedanceTaskToApi(MpGenerateVideoTask $task): void
    {
        $client = new Client(['verify'=>false,'timeout'=>120]);
        try {
            // 验证环境变量配置
            $apiKey = env('VOLC_AI_API_KEY');
                
            if (empty($apiKey)) {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '火山引擎访问密钥未配置，请检查环境变量API Key'
                ]);
                return;
            }

            $extraParams = $task->extra_params;
            
            // 构建火山引擎 Seedance API 请求参数
            $apiParams = [
                'model' => isset(\App\Consts\BaseConst::MODELS_MAP[$extraParams['model']]) ? \App\Consts\BaseConst::MODELS_MAP[$extraParams['model']] : $extraParams['model'],
                'content' => $extraParams['content'],
            ];

            // 添加可选参数
            if (!empty($extraParams['callback_url'])) {
                $apiParams['callback_url'] = $extraParams['callback_url'];
            }
            if (isset($extraParams['return_last_frame'])) {
                $apiParams['return_last_frame'] = $extraParams['return_last_frame'];
            }
            if (!empty($extraParams['service_tier']) && !in_array($extraParams['model'], ['doubao-seedance-2-0-260128', 'doubao-seedance-2-0-fast-260128'])) {
                $apiParams['service_tier'] = $extraParams['service_tier'];
            }
            if (!empty($extraParams['execution_expires_after'])) {
                $apiParams['execution_expires_after'] = $extraParams['execution_expires_after'];
            }
            if (isset($extraParams['generate_audio'])) {
                $apiParams['generate_audio'] = $extraParams['generate_audio'];
            }
            if (isset($extraParams['draft'])) {
                $apiParams['draft'] = $extraParams['draft'];
            }
            if (!empty($extraParams['video_resolution'])) {
                $apiParams['resolution'] = strtolower($task->video_resolution);
            }
            if (!empty($extraParams['ratio'])) {
                $apiParams['ratio'] = $extraParams['ratio'];
            }
            if (!empty($extraParams['duration'])) {
                $apiParams['duration'] = (int)$extraParams['duration'];
            }
            if (isset($task->frames)) {
                // $apiParams['frames'] = $task->frames;
            }
            if ($task->seed !== -1) {
                $apiParams['seed'] = (int)$task->seed;
            }
            if (isset($extraParams['camera_fixed'])) {
                $apiParams['camera_fixed'] = $extraParams['camera_fixed'];
            }
            if (isset($extraParams['watermark'])) {
                $apiParams['watermark'] = $extraParams['watermark'];
            }
            
            dLog('generate')->info('Seedance 1.5 Pro 视频生成参数: ', $apiParams);
            logDB('generate', 'info', 'Seedance视频生成任务提交', ['id' => $task->id, 'params' => $apiParams]);
            
            // 调用火山引擎 Seedance API
            $response = $client->post('https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams
            ]);


            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('Seedance 1.5 Pro API 响应: ', $responseData);
            logDB('generate', 'info', 'Seedance视频生成API响应', ['id' => $task->id, 'response' => $responseData]);
                
            if (isset($responseData['error'])) {
                // API返回错误
                logDB('generate', 'error', 'Seedance视频生成任务提交失败', ['id' => $task->id, 'error' => $responseData['error']['message'] ?? 'API Error']);
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => $responseData['error']['message'] ?? 'API Error',
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            } elseif (isset($responseData['id'])) {
                // 任务提交成功，更新状态为处理中
                $updateData = [
                    'task_id' => $responseData['id'], // 使用 API 返回的任务 ID
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ];
                $task->updateStatus(MpGenerateVideoTask::STATUS_PROCESSING, $updateData);
            } else {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '未知的 API 响应格式',
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            }
        } catch (\Exception $e) {
            // 记录错误
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
            Utils::throwError('1001:'.$e->getMessage());
        }
    }

    // 更新Seedance视频任务状态
    private function updateSeedanceTask($task) {
        $statusInfo = $this->querySeedanceTaskStatus($task);
        if (!isset($statusInfo['status'])) return;

        if ($statusInfo['status'] === 'success') {
            logDB('generate', 'info', 'Seedance视频生成任务成功', ['id' => $task->id, 'result_url' => $statusInfo['result_url']]);
            
            // 同步调整分镜视频状态和结果（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id && isset($statusInfo['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    // 在事务中更新任务状态
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 构建更新数据
                    $segmentUpdateData = [
                        'origin_video_url' => $statusInfo['result_url'],
                        'video_task_status' => '已完成',
                        'current_type' => 2,
                        'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                        'updated_at' => $now
                    ];
                    
                    // 使用查询任务时已压缩的视频URL，避免重复压缩
                    $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
                    
                    // 只有当video_duration存在且大于0时才更新
                    if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                        $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                        $segmentUpdateData['video_time_point_start'] = 0;
                        
                        // 获取video_time_point_end（兼容全能模式）
                        $audio_duration = $this->getAudioDuration($task, $segment_id, $statusInfo['video_duration'] ?? null);
                        $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                    }
                    
                    // 更新分镜表（兼容act模式）
                    $this->updateSegmentTable($task, $segmentUpdateData);
                    
                    // 添加视频生成对话记录
                    $this->addVideoGenerationRecords($task, $segment_id, $statusInfo['result_url']);
                    
                    DB::commit();
                    
                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('generate')->error('Seedance视频任务处理失败', [
                        'segment_id' => $segment_id,
                        'task_id' => $task->id,
                        'error' => $e->getMessage()
                    ]);
                }
            } else {
                // 没有segment_id的情况下，直接更新任务状态
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
            }
        } elseif ($statusInfo['status'] === 'failed') {
            logDB('generate', 'error', 'Seedance视频生成任务失败', ['id' => $task->id, 'error' => $statusInfo['error_message']]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => $statusInfo['error_message'],
                'result_json'   => $statusInfo['result_json'] ?? []
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
        // 如果仍然是处理中状态，不做任何操作
        
        // 处理：如果任务处理超过48小时，标记为失败
        $processingTime = now()->diffInHours($task->created_at);
        if ($processingTime > 48) {
            logDB('generate', 'warning', 'Seedance视频生成任务超时', ['id' => $task->id, 'processing_hours' => $processingTime]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => '任务处理超时（超过48小时）'
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
    }

    /**
     * 查询 Seedance 任务状态
     *
     * @param MpGenerateVideoTask $task
     * @return array
     */
    public function querySeedanceTaskStatus(MpGenerateVideoTask $task): array
    {
        $client = new Client(['verify'=>false,'timeout'=>120]);
        try {

            // 如果任务已完成，直接返回结果
            if (in_array($task->status, [MpGenerateVideoTask::STATUS_SUCCESS, MpGenerateVideoTask::STATUS_FAILED])) {
                return [
                    'success' => true,
                    'data' => [
                        'id' => $task->id,
                        'status' => $this->mapTaskStatus($task->status),
                        'result_url' => $task->result_url,
                        'error_message' => $task->error_message,
                        'created_at' => $task->created_at,
                        'started_at' => $task->started_at,
                        'completed_at' => $task->completed_at
                    ]
                ];
            }

            // 调用火山引擎 API 查询任务状态
            $apiKey = env('VOLC_AI_API_KEY');
                
            if (empty($apiKey)) {
                return [
                    'status'    => MpGenerateVideoTask::STATUS_FAILED,
                    'result_json' => [],
                    'error_message' => '火山引擎访问密钥未配置'
                ];
            }

            // 构建查询 URL
            $url = 'https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/' . $task->task_id;
            
            $response = $client->get($url, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $apiKey,
                    'Content-Type' => 'application/json',
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('Seedance 任务状态查询响应: ', $responseData);
            logDB('generate', 'info', 'Seedance任务状态查询', ['id' => $task->id, 'response' => $responseData]);

            if (isset($responseData['error'])) {
                logDB('generate', 'error', 'Seedance任务状态查询失败', ['id' => $task->id, 'error' => $responseData['error']['message'] ?? 'API查询失败']);
                return [
                    'status'    => MpGenerateVideoTask::STATUS_FAILED,
                    'result_json' => $responseData,
                    'error_message' => $responseData['error']['message'] ?? 'API查询失败'
                ];
            }

            // 解析任务状态
            $apiStatus = $responseData['status'] ?? 'unknown';
            $taskStatus = $this->mapApiStatusToTaskStatus($apiStatus);
            
            $updateData = ['result_json' => $responseData];
            
            if ($taskStatus === MpGenerateVideoTask::STATUS_SUCCESS) {
                $updateData['status'] = MpGenerateVideoTask::STATUS_SUCCESS;
                // 任务成功，处理结果
                if (isset($responseData['content']['video_url'])) {
                    $video_url = $responseData['content']['video_url'];
                    // 下载并保存视频
                    $video_name = 'ai_generation_' . time() . '_' . uniqid();
                    $video_ext = getVideoExtFromUrl($video_url);
                    $video_name = $video_name . $video_ext;
                    $url = uploadStreamByTos('video', file_get_contents($video_url), $video_name);
                    $updateData['result_url'] = $url;
                    
                    // 压缩视频
                    $compressed_video_url = compressVideo($url);
                    $updateData['compressed_url'] = $compressed_video_url ?: $url;
                }
                
                // 计算视频时长
                $video_duration = 0;
                if (isset($responseData['duration'])) {
                    // 如果直接返回duration，使用该值
                    $video_duration = (int)$responseData['duration'];
                } elseif (isset($responseData['frames']) && isset($responseData['framespersecond'])) {
                    // 如果返回frames和framespersecond，计算时长
                    $frames = (int)$responseData['frames'];
                    $fps = (int)$responseData['framespersecond'];
                    if ($fps > 0) {
                        $video_duration = (int)floor($frames / $fps);
                    }
                }
                
                // 如果没有计算出时长，使用任务表中的设定值
                if ($video_duration <= 0 && !empty($task->extra_params)) {
                    $extraParams = is_array($task->extra_params) ? $task->extra_params : json_decode($task->extra_params, true);
                    if (isset($extraParams['duration'])) {
                        $video_duration = (int)$extraParams['duration'];
                    }
                }
                
                // 只有当video_duration > 0时才添加到更新数据中
                if ($video_duration > 0) {
                    $updateData['video_duration'] = $video_duration;
                    $updateData['video_time_point_start'] = 0;
                    $updateData['video_time_point_end'] = $video_duration;
                }
                
                // 处理尾帧图片（如果启用了 return_last_frame）
                if (isset($responseData['content']['last_frame_url']) && !empty($responseData['content']['last_frame_url'])) {
                    $pic_url = $responseData['content']['last_frame_url'];
                    $pic_name = 'ai_generation_' . time() . '_' . uniqid();
                    $pic_ext = getImgExtFromUrl($pic_url);
                    $pic_name = $pic_name . $pic_ext;
                    
                    if ($pic_ext === '.png') {
                        $comporessed_data = compressRemoteImageUrlToSize($pic_url);
                        $url = uploadStreamByTos('image', $comporessed_data, $pic_name);
                    }else {
                        // 将图片另存到tos
                        $url = uploadStreamByTos('image', file_get_contents($pic_url), $pic_name);
                    }
                    $updateData['last_frame_url'] = $url;
                }
                return $updateData;
            } elseif ($taskStatus === MpGenerateVideoTask::STATUS_FAILED) {
                $updateData['status'] = MpGenerateVideoTask::STATUS_FAILED;
                $updateData['error_message'] =  $responseData['error_message'] ?? '任务执行失败';
                return $updateData;
            }
            // 其他状态保持不变

            return [
                'success' => true,
                'data' => [
                    'id' => $task->id,
                    'status' => $this->mapTaskStatus($task->status),
                    'result_url' => $task->result_url,
                    'error_message' => $task->error_message,
                    'created_at' => $task->created_at,
                    'started_at' => $task->started_at,
                    'completed_at' => $task->completed_at,
                    'api_response' => $responseData
                ]
            ];
        } catch (\Exception $e) {
            dLog('generate')->info('Seedance 任务状态查询异常: '.$e->getMessage());
            return [
                'success' => false,
                'message' => '查询失败: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 映射 API 状态到任务状态
     *
     * @param string $apiStatus
     * @return string
     */
    private function mapApiStatusToTaskStatus(string $apiStatus): string
    {
        switch ($apiStatus) {
            case 'queued':
            case 'running':
                return MpGenerateVideoTask::STATUS_PROCESSING;
            case 'succeeded':
                return MpGenerateVideoTask::STATUS_SUCCESS;
            case 'failed':
            case 'expired':
                return MpGenerateVideoTask::STATUS_FAILED;
            default:
                return MpGenerateVideoTask::STATUS_PROCESSING;
        }
    }

    public function seedanceCallback($data) {
        try {
            dLog('generate')->info('Seedance 回调数据: ', $data);
            logDB('generate', 'info', 'Seedance回调接收', ['task_id' => $data['id'] ?? null, 'status' => $data['status'] ?? null]);
            
            // 从回调数据中获取任务ID
            $taskId = $data['id'] ?? null;
            if (!$taskId) {
                dLog('generate')->error('Seedance 回调缺少任务ID');
                logDB('generate', 'error', 'Seedance回调缺少任务ID', ['data' => $data]);
                return ['success' => false, 'message' => '缺少任务ID'];
            }
            
            // 查找对应的任务记录
            $task = MpGenerateVideoTask::where('task_id', $taskId)->first();
            if (!$task) {
                dLog('generate')->error('Seedance 回调找不到任务: ' . $taskId);
                logDB('generate', 'error', 'Seedance回调找不到任务', ['task_id' => $taskId]);
                return ['success' => false, 'message' => '任务不存在'];
            }
            
            // 解析任务状态
            $apiStatus = $data['status'] ?? 'unknown';
            $taskStatus = $this->mapApiStatusToTaskStatus($apiStatus);
            
            // 准备更新数据
            $updateData = [
                'result_json' => $data,
                'updated_at' => now()
            ];
            
            if ($taskStatus === MpGenerateVideoTask::STATUS_SUCCESS) {
                $updateData['status'] = MpGenerateVideoTask::STATUS_SUCCESS;
                $updateData['completed_at'] = now();
                
                // 处理视频结果
                if (isset($data['content']['video_url'])) {
                    $video_url = $data['content']['video_url'];
                    try {
                        // 下载并保存视频
                        $video_name = 'ai_generation_' . time() . '_' . uniqid();
                        $video_ext = getVideoExtFromUrl($video_url);
                        $video_name = $video_name . $video_ext;
                        $url = uploadStreamByTos('video', file_get_contents($video_url), $video_name);
                        $updateData['result_url'] = $url;
                        $compressed_video_url = compressVideo($url);
                        $updateData['compressed_url'] = $compressed_video_url ?: $url;
                        
                        dLog('generate')->info('Seedance 视频保存成功: ' . $url);
                    } catch (\Exception $e) {
                        dLog('generate')->error('Seedance 视频保存失败: ' . $e->getMessage());
                        // 如果保存失败，直接使用原始URL
                        $updateData['result_url'] = $video_url;
                    }
                }
                
                // 处理尾帧图片（如果启用了 return_last_frame）
                if (isset($data['content']['last_frame_url']) && !empty($data['content']['last_frame_url'])) {
                    $pic_url = $data['content']['last_frame_url'];
                    try {
                        $pic_name = 'ai_generation_' . time() . '_' . uniqid();
                        $pic_ext = getImgExtFromUrl($pic_url);
                        $pic_name = $pic_name . $pic_ext;
                        
                        if ($pic_ext === '.png') {
                            $compressed_data = compressRemoteImageUrlToSize($pic_url);
                            $url = uploadStreamByTos('image', $compressed_data, $pic_name);
                        } else {
                            $url = uploadStreamByTos('image', file_get_contents($pic_url), $pic_name);
                        }
                        $updateData['last_frame_url'] = $url;
                        
                        dLog('generate')->info('Seedance 尾帧图片保存成功: ' . $url);
                    } catch (\Exception $e) {
                        dLog('generate')->error('Seedance 尾帧图片保存失败: ' . $e->getMessage());
                        // 如果保存失败，直接使用原始URL
                        $updateData['last_frame_url'] = $pic_url;
                    }
                }
                
            } elseif ($taskStatus === MpGenerateVideoTask::STATUS_FAILED) {
                $updateData['status'] = MpGenerateVideoTask::STATUS_FAILED;
                $updateData['completed_at'] = now();
                $updateData['error_message'] = $data['error_message'] ?? $data['failure_reason'] ?? '任务执行失败';
                
            } else {
                // 处理中状态
                $updateData['status'] = $taskStatus;
                if ($taskStatus === MpGenerateVideoTask::STATUS_PROCESSING && !$task->started_at) {
                    $updateData['started_at'] = now();
                }
            }
            
            // 更新任务记录
            $task->update($updateData);
            
            // 如果任务成功，更新分镜表
            if ($taskStatus === MpGenerateVideoTask::STATUS_SUCCESS && isset($updateData['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 获取分镜ID（兼容分镜模式和全能模式）
                    $segment = DB::table('mp_episode_segments')
                        ->where('video_task_id', $task->id)
                        ->first();
                    
                    if ($segment) {
                        // 兼容两种模式
                        $recordId = $segment->id;
                        $segmentId = $segment->segment_id ?: $segment->id;
                        $anime_id = $segment->anime_id;
                        $episode_number = $segment->episode_number;
                        $tail_frame = $segment->tail_frame;
                        $uid = $segment->uid ?? 0;
                        
                        // 更新分镜表
                        $segmentUpdateData = [
                            'origin_video_url' => $updateData['result_url'],
                            'video_task_status' => '已完成',
                            'last_frame_url' => $updateData['last_frame_url'] ?? '',
                            'current_type' => 2,
                            'updated_at' => $now
                        ];
                        $segmentUpdateData['video_url'] = $updateData['compressed_url'] ?? $updateData['result_url'];
                        
                        // 只有当video_duration存在且大于0时才更新
                        if (isset($data['content']['video_duration']) && $data['content']['video_duration'] > 0) {
                            $segmentUpdateData['video_duration'] = $data['content']['video_duration'];
                            $segmentUpdateData['video_time_point_start'] = 0;
                            $audio_duration = $this->getAudioDuration($task, $segmentId, $segmentUpdateData['video_duration']);
                            $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                        }
                        
                        // 使用主键id更新（兼容两种模式）
                        $updateResult = DB::table('mp_episode_segments')
                            ->where('id', $recordId)
                            ->update($segmentUpdateData);
                        
                        if (!$updateResult) {
                            throw new \Exception('更新分镜表失败');
                        }

                        // 更新分镜视频成功后新增对话记录
                        $records = [
                            [
                                'uid'           => $uid,
                                'anime_id'      => $anime_id,
                                'sequence'      => $episode_number,
                                'role'          => 'user',
                                'content'       => '图片转视频',
                                'segment_id'    => $segmentId,
                                'video_url'     => '',
                                'created_at'    => $now,
                                'updated_at'    => $now
                            ],
                            [
                                'uid'           => $uid,
                                'anime_id'      => $anime_id,
                                'sequence'      => $episode_number,
                                'role'          => 'assistant',
                                'content'       => $tail_frame,
                                'segment_id'    => $segmentId,
                                'video_url'     => $updateData['result_url'],
                                'created_at'    => $now,
                                'updated_at'    => $now
                            ]
                        ];

                        DB::table('mp_anime_records')->insert($records);
                        
                        dLog('generate')->info('Seedance 分镜表更新成功: ' . $segmentId);
                    }
                    
                    DB::commit();
                    
                } catch (\Exception $e) {
                    DB::rollBack();
                    
                    $logData = [
                        'task_id' => $task->id,
                        'error' => $e->getMessage()
                    ];
                    dLog('generate')->error('Seedance 分镜表更新失败', $logData);
                    logDB('generate', 'error', 'Seedance分镜表更新失败', $logData);
                }
            } elseif ($taskStatus === MpGenerateVideoTask::STATUS_FAILED) {
                // 任务失败，更新分镜表状态
                DB::table('mp_episode_segments')
                    ->where('video_task_id', $task->id)
                    ->update([
                        'video_task_status' => '失败',
                        'updated_at' => date('Y-m-d H:i:s')
                    ]);
            }
            
            dLog('generate')->info('Seedance 回调处理完成: ' . $taskId . ', 状态: ' . $taskStatus);
            logDB('generate', 'info', 'Seedance回调处理完成', ['task_id' => $taskId, 'status' => $taskStatus]);
            
            return [
                'success' => true,
                'message' => '回调处理成功',
                'task_id' => $taskId,
                'status' => $taskStatus
            ];
            
        } catch (\Exception $e) {
            dLog('generate')->error('Seedance 回调处理异常: ' . $e->getMessage());
            logDB('generate', 'error', 'Seedance回调处理异常', ['error' => $e->getMessage()]);
            return [
                'success' => false,
                'message' => '回调处理失败: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 更新分镜表的视频任务状态
     * 
     * @param MpGenerateVideoTask $task
     * @param string $taskStatus
     * @param array $updateData
     */
    private function updateSegmentVideoStatus(MpGenerateVideoTask $task, string $taskStatus, array $updateData) {
        try {
            // 查找关联的分镜记录
            $segment = DB::table('mp_episode_segments')
                ->where('video_task_id', $task->id)
                ->first();
                
            if (!$segment) {
                dLog('generate')->info('未找到关联的分镜记录: ' . $task->id);
                return;
            }
            
            $segmentUpdateData = ['updated_at' => date('Y-m-d H:i:s')];

            if (isset($updateData['last_frame_url']) && $updateData['last_frame_url']) {
                $segmentUpdateData['last_frame_url'] = $updateData['last_frame_url'];
            }
            
            if ($taskStatus === MpGenerateVideoTask::STATUS_SUCCESS) {
                $segmentUpdateData['video_task_status'] = '已完成';
                if (isset($updateData['result_url'])) {
                    $segmentUpdateData['origin_video_url'] = $updateData['result_url'];
                    // 如果有压缩视频URL，使用压缩后的
                    if (isset($updateData['compressed_url'])) {
                        $segmentUpdateData['video_url'] = $updateData['compressed_url'];
                    } else {
                        $segmentUpdateData['video_url'] = $updateData['result_url'];
                    }
                }
            } elseif ($taskStatus === MpGenerateVideoTask::STATUS_FAILED) {
                $segmentUpdateData['video_task_status'] = '失败';
            } elseif ($taskStatus === MpGenerateVideoTask::STATUS_PROCESSING) {
                $segmentUpdateData['video_task_status'] = '生成中';
            }
            
            // 更新分镜表
            DB::table('mp_episode_segments')
                ->where('video_task_id', $task->id)
                ->update($segmentUpdateData);
                
            dLog('generate')->info('分镜视频状态更新成功: ' . $segment->segment_id . ', 状态: ' . ($segmentUpdateData['video_task_status'] ?? '未知'));
            
        } catch (\Exception $e) {
            dLog('generate')->error('更新分镜视频状态失败: ' . $e->getMessage());
        }
    }

    /**
     * 生成可灵AI的JWT Token
     *
     * @return string
     */
    private function generateKelingJwtToken(): string
    {
        $ak = env('KELING_AK');
        $sk = env('KELING_SK');
        
        if (empty($ak) || empty($sk)) {
            throw new \Exception('可灵AI访问密钥未配置，请检查环境变量KELING_AK和KELING_SK');
        }

        // JWT头部
        $header = [
            'alg' => 'HS256',
            'typ' => 'JWT'
        ];

        // JWT载荷
        $payload = [
            'iss' => $ak,  // 签发者，使用Access Key
            'exp' => time() + 1800,  // 过期时间，30分钟后过期
            'nbf' => time() - 5  // 生效时间，5秒前开始生效
        ];

        // Base64URL编码
        $headerEncoded = $this->base64UrlEncode(json_encode($header));
        $payloadEncoded = $this->base64UrlEncode(json_encode($payload));

        // 创建签名
        $signature = hash_hmac('sha256', $headerEncoded . '.' . $payloadEncoded, $sk, true);
        $signatureEncoded = $this->base64UrlEncode($signature);

        // 返回完整的JWT token
        return $headerEncoded . '.' . $payloadEncoded . '.' . $signatureEncoded;
    }

    /**
     * Base64URL编码（JWT标准编码）
     *
     * @param string $data
     * @return string
     */
    private function base64UrlEncode(string $data): string
    {
        return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
    }

    /**
     * 创建可灵AI Omni视频生成任务
     *
     * @param array $params
     * @return MpGenerateVideoTask
     */
    public function createKelingOmniTask(array $params): MpGenerateVideoTask
    {
        // 生成唯一的任务ID
        $taskId = 'keling_omni_' . time() . '_' . uniqid();

        // 创建任务记录，复用现有表结构
        $task = MpGenerateVideoTask::create([
            'task_id' => $taskId,
            'prompt' => $params['prompt'] ?? '',
            'first_frame_url' => $params['first_frame_url'] ?? '',
            'tail_frame_url' => $params['tail_frame_url'] ?? '',
            'seed' => $params['seed'] ?? -1,
            'frames' => $params['video_duration'] ? ($params['video_duration'] * 24 + 1) : null,
            'video_resolution' => $params['video_resolution'] ?? '720P',
            'status' => MpGenerateVideoTask::STATUS_PENDING,
            'api_type' => 'keling', // 标识为可灵AI Omni API
            'extra_params' => [
                'api_type' => 'keling',
                'model' => $params['model'] ?? 'kling-video-o1',
                'prompt' => $params['prompt'] ?? '',
                'multi_prompt' => $params['multi_prompt'] ?? [],
                'shot_type' => $params['shot_type'] ?? 'customize',
                'image_list' => $params['image_list'] ?? [],
                'element_list' => $params['element_list'] ?? [],
                'sound' => $params['sound'] ?? 'off',
                // 'aspect_ratio' => $params['aspect_ratio'] ?? '16:9',
                'duration' => $params['video_duration'] ?? 5,
                'mode' => $params['mode'] ?? 'std',
                'callback_url' => $params['callback_url'] ?? '',
            ]
        ]);

        // 提交任务到可灵AI Omni API
        $this->submitKelingOmniTaskToApi($task);

        return $task;
    }

    /**
     * 提交可灵AI Omni任务到API
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function submitKelingOmniTaskToApi(MpGenerateVideoTask $task): void
    {
        $client = new Client(['verify'=>false,'timeout'=>120]);
        
        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();
            
            $extraParams = $task->extra_params;
            
            // 构建可灵AI Omni API请求参数
            $apiParams = [
                'model_name' => $extraParams['model'],
                'prompt' => $extraParams['prompt'],
                'mode' => $extraParams['mode'],
                // 'aspect_ratio' => $extraParams['aspect_ratio'],
                'duration' => (int)$extraParams['duration'],
            ];

            // 添加可选参数
            if (!empty($extraParams['multi_prompt'])) {
                $apiParams['multi_prompt'] = $extraParams['multi_prompt'];
            }
            if (!empty($extraParams['shot_type'])) {
                $apiParams['shot_type'] = $extraParams['shot_type'];
            }
            if (!empty($extraParams['image_list'])) {
                $apiParams['image_list'] = $extraParams['image_list'];
            }
            if (!empty($extraParams['element_list'])) {
                $apiParams['element_list'] = json_decode($extraParams['element_list'], true);
            }
            if (isset($extraParams['sound'])) {
                $apiParams['sound'] = $extraParams['sound'];
            }
            // if (!empty($extraParams['callback_url'])) {
            //     $apiParams['callback_url'] = $extraParams['callback_url'];
            // }
            
            dLog('generate')->info('可灵AI Omni视频生成参数: ', $apiParams);
            logDB('generate', 'info', '可灵AI Omni视频生成任务提交', ['id' => $task->id, 'params' => $apiParams]);

            // 调用可灵AI Omni API
            $response = $client->post('https://api-beijing.klingai.com/v1/videos/omni-video', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI Omni API响应: ', $responseData);
            logDB('generate', 'info', '可灵AI Omni API响应', ['id' => $task->id, 'response' => $responseData]);
                
            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                // API返回错误
                $errorMessage = $responseData['error']['message'] ?? $responseData['message'] ?? 'API Error';
                logDB('generate', 'error', '可灵AI Omni任务提交失败', ['id' => $task->id, 'error' => $errorMessage]);
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => $errorMessage,
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            } elseif (isset($responseData['data']['task_id'])) {
                // 任务提交成功，更新状态为处理中
                $updateData = [
                    'task_id' => $responseData['data']['task_id'], // 使用API返回的任务ID
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ];
                $task->updateStatus(MpGenerateVideoTask::STATUS_PROCESSING, $updateData);
            } else {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '未知的API响应格式',
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            }
        } catch (\Exception $e) {
            // 记录错误
            logDB('generate', 'error', '可灵AI Omni任务异常', ['id' => $task->id, 'error' => $e->getMessage()]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
            dLog('generate')->error('可灵AI Omni API请求异常: ' . $e->getMessage());
        }
    }

    /**
     * 查询可灵AI Omni任务状态
     *
     * @param MpGenerateVideoTask $task
     * @return array
     */
    public function queryKelingOmniTaskStatus(MpGenerateVideoTask $task): array
    {
        $client = new Client(['verify'=>false,'timeout'=>120]);
        
        try {
            // 如果任务已完成，直接返回结果
            if (in_array($task->status, [MpGenerateVideoTask::STATUS_SUCCESS, MpGenerateVideoTask::STATUS_FAILED])) {
                return [
                    'success' => true,
                    'data' => [
                        'task_id' => $task->task_id,
                        'task_status' => $this->mapTaskStatusToKelingStatus($task->status),
                        'result_url' => $task->result_url,
                        'error_message' => $task->error_message,
                        'created_at' => $task->created_at,
                        'updated_at' => $task->updated_at
                    ]
                ];
            }

            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();
            
            // 构建查询URL
            $url = 'https://api-beijing.klingai.com/v1/videos/omni-video/' . $task->task_id;
            
            $response = $client->get($url, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI Omni任务状态查询响应: ', $responseData);
            logDB('generate', 'info', '可灵AI Omni任务状态查询', ['id' => $task->id, 'response' => $responseData]);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                logDB('generate', 'error', '可灵AI Omni任务状态查询失败', ['id' => $task->id, 'error' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API查询失败']);
                return [
                    'status' => 'failed',
                    'error_message' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API查询失败',
                    'result_json' => $responseData
                ];
            }

            // 解析任务状态
            $taskData = $responseData['data'] ?? [];
            $taskStatus = $taskData['task_status'] ?? 'unknown';
            
            $updateData = ['result_json' => $responseData];
            
            if ($taskStatus === 'succeed') {
                $updateData['status'] = 'success';
                // 任务成功，处理结果
                if (isset($taskData['task_result']['videos']) && !empty($taskData['task_result']['videos'])) {
                    $video = $taskData['task_result']['videos'][0];
                    $video_url = $video['url'];
                    
                    // 下载并保存视频
                    $video_name = 'ai_generation_' . time() . '_' . uniqid();
                    $video_ext = getVideoExtFromUrl($video_url);
                    $video_name = $video_name . $video_ext;
                    $url = uploadStreamByTos('video', file_get_contents($video_url), $video_name);
                    $updateData['result_url'] = $url;
                    
                    // 压缩视频
                    $compressed_video_url = compressVideo($url);
                    $updateData['compressed_url'] = $compressed_video_url ?: $url;
                    
                    // 计算视频时长
                    $video_duration = 0;
                    if (isset($video['duration'])) {
                        $video_duration = (int)$video['duration'];
                    } elseif (isset($taskData['duration'])) {
                        $video_duration = (int)$taskData['duration'];
                    } elseif (isset($video['frames']) && isset($video['framespersecond'])) {
                        $frames = (int)$video['frames'];
                        $fps = (int)$video['framespersecond'];
                        if ($fps > 0) {
                            $video_duration = (int)floor($frames / $fps);
                        }
                    }
                    
                    // 如果没有计算出时长，使用任务表中的设定值
                    if ($video_duration <= 0 && !empty($task->extra_params)) {
                        $extraParams = is_array($task->extra_params) ? $task->extra_params : json_decode($task->extra_params, true);
                        if (isset($extraParams['duration'])) {
                            $video_duration = (int)$extraParams['duration'];
                        }
                    }
                    
                    // 只有当video_duration > 0时才添加到更新数据中
                    if ($video_duration > 0) {
                        $updateData['video_duration'] = $video_duration;
                        $updateData['video_time_point_start'] = 0;
                        $updateData['video_time_point_end'] = $video_duration;
                    }
                }
                return $updateData;
            } elseif ($taskStatus === 'failed') {
                $updateData = [
                    'status' => 'failed',
                    'error_message' => '任务执行失败',
                    'result_json' => $responseData
                ];
                return $updateData;
            }
            // 其他状态（processing等）保持不变

            return [
                'success' => true,
                'data' => [
                    'task_id' => $task->task_id,
                    'task_status' => $taskStatus,
                    'result_url' => $task->result_url,
                    'error_message' => $task->error_message,
                    'created_at' => $task->created_at,
                    'updated_at' => $task->updated_at,
                    'api_response' => $responseData
                ]
            ];
        } catch (\Exception $e) {
            dLog('generate')->error('可灵AI Omni任务状态查询异常: ' . $e->getMessage());
            return [
                'success' => false,
                'message' => '查询失败: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 映射任务状态到可灵AI状态格式
     *
     * @param string $taskStatus
     * @return string
     */
    private function mapTaskStatusToKelingStatus(string $taskStatus): string
    {
        switch ($taskStatus) {
            case MpGenerateVideoTask::STATUS_PENDING:
                return 'submitted';
            case MpGenerateVideoTask::STATUS_PROCESSING:
                return 'processing';
            case MpGenerateVideoTask::STATUS_SUCCESS:
                return 'succeed';
            case MpGenerateVideoTask::STATUS_FAILED:
                return 'failed';
            default:
                return 'unknown';
        }
    }

    /**
     * 更新可灵AI Omni视频任务状态
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function updateKelingOmniTask($task): void
    {
        $statusInfo = $this->queryKelingOmniTaskStatus($task);
        if (!isset($statusInfo['status'])) return;

        if ($statusInfo['status'] === 'success') {
            logDB('generate', 'info', '可灵AI Omni视频生成任务成功', ['id' => $task->id, 'result_url' => $statusInfo['result_url']]);
            
            // 同步调整分镜视频状态和结果（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id && isset($statusInfo['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    // 在事务中更新任务状态
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 构建更新数据
                    $segmentUpdateData = [
                        'origin_video_url' => $statusInfo['result_url'],
                        'video_task_status' => '已完成',
                        'current_type' => 2,
                        'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                        'updated_at' => $now
                    ];
                    
                    // 使用查询任务时已压缩的视频URL，避免重复压缩
                    $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
                    
                    // 只有当video_duration存在且大于0时才更新
                    if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                        $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                        $segmentUpdateData['video_time_point_start'] = 0;
                        
                        // 获取video_time_point_end（兼容全能模式）
                        $audio_duration = $this->getAudioDuration($task, $segment_id, $statusInfo['video_duration']);
                        $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                    }
                    
                    // 更新分镜表（兼容act模式）
                    $this->updateSegmentTable($task, $segmentUpdateData);
                    
                    // 添加视频生成对话记录
                    $this->addVideoGenerationRecords($task, $segment_id, $statusInfo['result_url']);
                    
                    DB::commit();
                    
                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('generate')->error('可灵视频任务处理失败', [
                        'segment_id' => $segment_id,
                        'task_id' => $task->id,
                        'error' => $e->getMessage()
                    ]);
                }
            } else {
                // 没有segment_id的情况下，直接更新任务状态
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
            }
        } elseif ($statusInfo['status'] === 'failed') {
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => $statusInfo['error_message'],
                'result_json' => $statusInfo['result_json'] ?? []
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
        // 如果仍然是处理中状态，不做任何操作
        
        // 处理：如果任务处理超过24小时，标记为失败
        $processingTime = now()->diffInHours($task->created_at);
        if ($processingTime > 24) {
            logDB('generate', 'warning', '可灵AI Omni视频生成任务超时', ['id' => $task->id, 'processing_hours' => $processingTime]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => '任务处理超时（超过24小时）'
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
    }

    /**
     * 映射任务状态到前端显示状态
     *
     * @param string $taskStatus
     * @return string
     */
    private function mapTaskStatus(string $taskStatus): string
    {
        switch ($taskStatus) {
            case MpGenerateVideoTask::STATUS_PENDING:
                return 'queued';
            case MpGenerateVideoTask::STATUS_PROCESSING:
                return 'running';
            case MpGenerateVideoTask::STATUS_SUCCESS:
                return 'succeeded';
            case MpGenerateVideoTask::STATUS_FAILED:
                return 'failed';
            default:
                return 'unknown';
        }
    }
    // ==================== 主体管理相关方法 ====================

    /**
     * 创建主体
     *
     * @param array $params
     * @return AIElement
     */
    public function createElement(array $params): AIElement
    {
        // 生成唯一的任务ID
        $taskId = 'element_' . time() . '_' . uniqid();

        // 创建主体记录
        $element = AIElement::create([
            'task_id' => $taskId,
            'external_task_id' => $params['external_task_id'] ?? null,
            'element_name' => $params['element_name'],
            'element_description' => $params['element_description'],
            'reference_type' => $params['reference_type'],
            'element_image_list' => $params['element_image_list'] ?? null,
            'element_video_list' => $params['element_video_list'] ?? null,
            'element_voice_id' => $params['element_voice_id'] ?? null,
            'tag_list' => $params['tag_list'] ?? null,
            'callback_url' => $params['callback_url'] ?? null,
            'task_status' => AIElement::STATUS_SUBMITTED,
        ]);

        // 提交到可灵AI API
        $this->submitElementToKelingApi($element);

        return $element;
    }

    /**
     * 提交主体创建任务到可灵AI API
     *
     * @param AIElement $element
     * @return void
     */
    private function submitElementToKelingApi(AIElement $element): void
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);

        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();

            // 构建API请求参数
            $apiParams = [
                'element_name' => $element->element_name,
                'element_description' => $element->element_description,
                'reference_type' => $element->reference_type,
            ];

            // 添加图片参考
            if ($element->reference_type === AIElement::REFERENCE_TYPE_IMAGE && $element->element_image_list) {
                $apiParams['element_image_list'] = $element->element_image_list;
            }

            // 添加视频参考
            if ($element->reference_type === AIElement::REFERENCE_TYPE_VIDEO && $element->element_video_list) {
                $apiParams['element_video_list'] = $element->element_video_list;
            }

            // 添加音色ID
            if ($element->element_voice_id) {
                $apiParams['element_voice_id'] = $element->element_voice_id;
            }

            // 添加标签
            if ($element->tag_list) {
                $apiParams['tag_list'] = $element->tag_list;
            }

            // 添加回调URL
            if ($element->callback_url) {
                $apiParams['callback_url'] = $element->callback_url;
            }

            // 添加外部任务ID
            if ($element->external_task_id) {
                $apiParams['external_task_id'] = $element->external_task_id;
            }

            dLog('generate')->info('可灵AI创建主体参数: ', $apiParams);

            // 调用可灵AI创建主体API
            $response = $client->post('https://api-beijing.klingai.com/v1/general/advanced-custom-elements', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI创建主体API响应: ', $responseData);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                // API返回错误
                $errorMessage = $responseData['error']['message'] ?? $responseData['message'] ?? 'API Error';
                $element->update([
                    'task_status' => AIElement::STATUS_FAILED,
                    'task_status_msg' => $errorMessage,
                ]);
            } elseif (isset($responseData['data']['task_id'])) {
                // 任务提交成功，更新状态为处理中
                $element->update([
                    'task_id' => $responseData['data']['task_id'], // 使用API返回的任务ID
                    'task_status' => AIElement::STATUS_PROCESSING,
                    'created_at' => isset($responseData['data']['created_at']) ?
                        date('Y-m-d H:i:s', $responseData['data']['created_at'] / 1000) : now(),
                    'updated_at' => isset($responseData['data']['updated_at']) ?
                        date('Y-m-d H:i:s', $responseData['data']['updated_at'] / 1000) : now(),
                ]);
            } else {
                $element->update([
                    'task_status' => AIElement::STATUS_FAILED,
                    'task_status_msg' => '未知的API响应格式',
                ]);
            }
        } catch (\Exception $e) {
            // 记录错误
            $element->update([
                'task_status' => AIElement::STATUS_FAILED,
                'task_status_msg' => 'API请求失败: ' . $e->getMessage(),
            ]);
            dLog('generate')->error('可灵AI创建主体API请求异常: ' . $e->getMessage());
        }
    }

    /**
     * 查询单个主体状态
     *
     * @param string $taskId
     * @param string|null $externalTaskId
     * @return array
     */
    public function queryElementStatus(string $taskId, string $externalTaskId = null): array
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);

        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();

            // 构建查询URL
            $url = 'https://api-beijing.klingai.com/v1/general/advanced-custom-elements/' . $taskId;
            $queryParams = [];

            if ($externalTaskId) {
                $queryParams['external_task_id'] = $externalTaskId;
            }

            if (!empty($queryParams)) {
                $url .= '?' . http_build_query($queryParams);
            }

            $response = $client->get($url, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI查询主体状态响应: ', $responseData);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                return [
                    'success' => false,
                    'message' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API查询失败',
                    'data' => null
                ];
            }

            // 更新本地数据库记录
            if (isset($responseData['data'])) {
                $this->updateLocalElementFromApi($responseData['data']);
            }

            return [
                'success' => true,
                'data' => $responseData['data']
            ];
        } catch (\Exception $e) {
            dLog('generate')->error('可灵AI查询主体状态异常: ' . $e->getMessage());
            return [
                'success' => false,
                'message' => '查询失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 根据API响应更新本地主体记录
     *
     * @param array $apiData
     * @return void
     */
    private function updateLocalElementFromApi(array $apiData): void
    {
        $element = AIElement::where('task_id', $apiData['task_id'])->first();
        if (!$element) {
            return;
        }

        $updateData = [
            'task_status' => $apiData['task_status'],
            'task_status_msg' => $apiData['task_status_msg'] ?? null,
            'final_unit_deduction' => $apiData['final_unit_deduction'] ?? null,
            'updated_at' => isset($apiData['updated_at']) ?
                date('Y-m-d H:i:s', $apiData['updated_at'] / 1000) : now(),
        ];

        // 如果任务成功，更新主体信息
        if ($apiData['task_status'] === AIElement::STATUS_SUCCEED && isset($apiData['task_result']['elements'])) {
            $elementData = $apiData['task_result']['elements'][0];
            $updateData = array_merge($updateData, [
                'element_id' => $elementData['element_id'],
                'element_voice_info' => $elementData['element_voice_info'] ?? null,
                'owned_by' => $elementData['owned_by'] ?? 'custom',
                'status' => $elementData['status'] ?? AIElement::ELEMENT_STATUS_SUCCEED,
            ]);
        }

        $element->update($updateData);
    }

    /**
     * 查询自定义主体列表
     *
     * @param int $pageNum
     * @param int $pageSize
     * @return array
     */
    public function queryCustomElementsList(int $pageNum = 1, int $pageSize = 30): array
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);

        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();

            // 构建查询URL
            $url = 'https://api-beijing.klingai.com/v1/general/advanced-custom-elements';
            $queryParams = [
                'pageNum' => $pageNum,
                'pageSize' => $pageSize,
            ];

            $url .= '?' . http_build_query($queryParams);

            $response = $client->get($url, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI查询自定义主体列表响应: ', $responseData);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                return [
                    'success' => false,
                    'message' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API查询失败',
                    'data' => []
                ];
            }

            // 更新本地数据库记录
            if (isset($responseData['data']) && is_array($responseData['data'])) {
                foreach ($responseData['data'] as $elementData) {
                    $this->updateLocalElementFromApi($elementData);
                }
            }

            return [
                'success' => true,
                'data' => $responseData['data'] ?? []
            ];
        } catch (\Exception $e) {
            dLog('generate')->error('可灵AI查询自定义主体列表异常: ' . $e->getMessage());
            return [
                'success' => false,
                'message' => '查询失败: ' . $e->getMessage(),
                'data' => []
            ];
        }
    }

    /**
     * 查询官方主体列表
     *
     * @param int $pageNum
     * @param int $pageSize
     * @return array
     */
    public function queryOfficialElementsList(int $pageNum = 1, int $pageSize = 30): array
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);

        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();

            // 构建查询URL
            $url = 'https://api-beijing.klingai.com/v1/general/advanced-presets-elements';
            $queryParams = [
                'pageNum' => $pageNum,
                'pageSize' => $pageSize,
            ];

            $url .= '?' . http_build_query($queryParams);

            $response = $client->get($url, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI查询官方主体列表响应: ', $responseData);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                return [
                    'success' => false,
                    'message' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API查询失败',
                    'data' => []
                ];
            }

            return [
                'success' => true,
                'data' => $responseData['data'] ?? []
            ];
        } catch (\Exception $e) {
            dLog('generate')->error('可灵AI查询官方主体列表异常: ' . $e->getMessage());
            return [
                'success' => false,
                'message' => '查询失败: ' . $e->getMessage(),
                'data' => []
            ];
        }
    }

    /**
     * 删除自定义主体
     *
     * @param string $elementId
     * @return array
     */
    public function deleteElement(string $elementId): array
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);

        try {
            // 生成JWT token
            $jwtToken = $this->generateKelingJwtToken();

            // 构建API请求参数
            $apiParams = [
                'element_id' => $elementId,
            ];

            dLog('generate')->info('可灵AI删除主体参数: ', $apiParams);

            // 调用可灵AI删除主体API
            $response = $client->post('https://api-beijing.klingai.com/v1/general/delete-elements', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $jwtToken,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('可灵AI删除主体API响应: ', $responseData);

            if (isset($responseData['error']) || (isset($responseData['code']) && $responseData['code'] !== 0)) {
                // API返回错误
                return [
                    'success' => false,
                    'message' => $responseData['error']['message'] ?? $responseData['message'] ?? 'API Error'
                ];
            } else {
                // 删除成功，更新本地记录状态
                AIElement::where('element_id', $elementId)->update([
                    'status' => AIElement::ELEMENT_STATUS_DELETED,
                    'updated_at' => now(),
                ]);

                return [
                    'success' => true,
                    'message' => '主体删除成功',
                    'data' => $responseData['data'] ?? []
                ];
            }
        } catch (\Exception $e) {
            dLog('generate')->error('可灵AI删除主体API请求异常: ' . $e->getMessage());
            return [
                'success' => false,
                'message' => 'API请求失败: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 获取本地主体列表（包含自定义和官方）
     *
     * @param array $filters
     * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
     */
    public function getLocalElementsList(array $filters = [])
    {
        $query = AIElement::query();

        // 筛选条件
        if (isset($filters['owned_by'])) {
            $query->where('owned_by', $filters['owned_by']);
        }

        if (isset($filters['reference_type'])) {
            $query->where('reference_type', $filters['reference_type']);
        }

        if (isset($filters['status'])) {
            $query->where('status', $filters['status']);
        }

        if (isset($filters['task_status'])) {
            $query->where('task_status', $filters['task_status']);
        }

        // 搜索关键词
        if (isset($filters['keyword']) && !empty($filters['keyword'])) {
            $query->where(function ($q) use ($filters) {
                $q->where('element_name', 'like', '%' . $filters['keyword'] . '%')
                  ->orWhere('element_description', 'like', '%' . $filters['keyword'] . '%');
            });
        }

        return $query->orderBy('created_at', 'desc')
                    ->paginate($filters['page_size'] ?? 20);
    }

    /**
     * 根据task获取segment_id或act_id（兼容act模式）
     * 分镜模式：返回segment_id用于查询
     * 全能模式：返回act_id用于查询（因为segment_id为空）
     */
    private function getSegmentIdFromTask($task)
    {
        $segment_id = getProp($task, 'alias_segment_id');
        
        // 如果有segment_id，直接返回（分镜模式）
        if (!empty($segment_id)) {
            return $segment_id;
        }
        
        // 如果有alias_act_id，返回act_id（全能模式，segment_id为空）
        $act_id = getProp($task, 'alias_act_id');
        if (!empty($act_id)) {
            return $act_id; // 直接返回act_id，不需要查segment_id
        }
        
        return null;
    }

    /**
     * 更新分镜表（兼容act模式）
     * 分镜模式：使用segment_id字段更新
     * 全能模式：使用id字段更新
     */
    private function updateSegmentTable($task, $updateData)
    {
        $segment_id = getProp($task, 'alias_segment_id');
        $act_id = getProp($task, 'alias_act_id');
        
        if (!empty($segment_id)) {
            // 分镜模式：使用segment_id更新
            return DB::table('mp_episode_segments')->where('segment_id', $segment_id)->update($updateData);
        } elseif (!empty($act_id)) {
            // 全能模式（全能模式）：使用id更新
            return DB::table('mp_episode_segments')->where('id', $act_id)->update($updateData);
        }
        
        return false;
    }

    /**
     * 获取audio_duration（兼容act模式）
     * 分镜模式：使用segment_id查询
     * 全能模式：使用id查询
     * @param array $task 任务数据
     * @param string|int $segmentIdOrActId segment_id或act_id
     * @param float|null $video_duration 视频时长（如果传入，全能模式直接返回此值）
     * @return float
     */
    private function getAudioDuration($task, $segmentIdOrActId, $video_duration = null)
    {
        $segment_id = getProp($task, 'alias_segment_id');
        $act_id = getProp($task, 'alias_act_id');
        
        if (!empty($segment_id)) {
            // 分镜模式：使用segment_id查询
            return DB::table('mp_episode_segments')->where('segment_id', $segmentIdOrActId)->value('audio_duration');
        } elseif (!empty($act_id)) {
            // 全能模式：如果传入了video_duration直接返回，否则查询audio_duration
            if ($video_duration !== null && $video_duration > 0) {
                return $video_duration;
            }
            return DB::table('mp_episode_segments')->where('id', $segmentIdOrActId)->value('audio_duration');
        }
        
        return 0;
    }

    /**
     * 添加视频生成对话记录
     * @param array $task 任务数据
     * @param string|int $segmentIdOrActId segment_id（分镜模式）或 act_id（全能模式）
     * @param string $videoUrl 视频URL
     * @return void
     */
    private function addVideoGenerationRecords($task, $segmentIdOrActId, $videoUrl)
    {
        try {
            $segment_id = getProp($task, 'alias_segment_id');
            $act_id = getProp($task, 'alias_act_id');
            $reference_images = getProp($task, 'ref_image_url');
            if (!$reference_images) $reference_images = json_encode([], 256);
            
            if (!empty($segment_id)) {
                // 分镜模式：使用segment_id查询
                $segment = DB::table('mp_episode_segments as a')->leftJoin('mp_animes as b', 'a.anime_id', 'b.id')
                    ->where('a.segment_id', $segmentIdOrActId)
                    ->select('b.user_id as uid', 'a.anime_id', 'a.episode_number', 'a.tail_frame', 'a.segment_id')
                    ->first();
            } elseif (!empty($act_id)) {
                // 全能模式：使用id查询
                $segment = DB::table('mp_episode_segments as a')->leftJoin('mp_animes as b', 'a.anime_id', 'b.id')
                    ->where('a.id', $segmentIdOrActId)
                    ->select('b.user_id as uid', 'a.anime_id', 'a.episode_number', 'a.act_content', 'a.act_show_content', 'a.id as act_id')
                    ->first();
            } else {
                dLog('generate')->warning('无法确定查询模式，任务缺少segment_id和act_id', ['segment_id_or_act_id' => $segmentIdOrActId]);
                return;
            }

            if (!$segment) {
                dLog('generate')->warning('分镜信息不存在，无法添加对话记录', ['segment_id_or_act_id' => $segmentIdOrActId]);
                return;
            }

            $now = date('Y-m-d H:i:s');
            
            // 根据模式确定保存的字段和值
            if (!empty($segment_id)) {
                // 分镜模式：保存segment_id字段
                $recordField = 'segment_id';
                $recordValue = $segmentIdOrActId;
                $userContent = '图片转视频';
                $assistantContent = $segment->tail_frame ?: '';
            } else {
                // 全能模式：保存act_id字段
                $recordField = 'act_id';
                $recordValue = $segmentIdOrActId;
                $userContent = '片段转视频';
                $assistantContent = $segment->act_show_content ? $segment->act_show_content : $segment->act_content;
                if (!$assistantContent) $assistantContent = '';
            }
            
            // 保存对话记录
            $records = [
                [
                    'uid'           => $segment->uid,
                    'anime_id'      => $segment->anime_id,
                    'sequence'      => $segment->episode_number,
                    'role'          => 'user',
                    'content'       => $userContent,
                    $recordField    => $recordValue,
                    'video_url'     => '',
                    'reference_images' => json_encode([], 256),
                    'created_at'    => $now,
                    'updated_at'    => $now
                ],
                [
                    'uid'           => $segment->uid,
                    'anime_id'      => $segment->anime_id,
                    'sequence'      => $segment->episode_number,
                    'role'          => 'assistant',
                    'content'       => $assistantContent,
                    $recordField    => $recordValue,
                    'video_url'     => $videoUrl,
                    'reference_images' => $reference_images,
                    'created_at'    => $now,
                    'updated_at'    => $now
                ]
            ];

            DB::table('mp_anime_records')->insert($records);
            
            dLog('generate')->info('视频生成对话记录添加成功', [
                'segment_id_or_act_id' => $segmentIdOrActId,
                'video_url' => $videoUrl,
                'uid' => $segment->uid,
                'anime_id' => $segment->anime_id
            ]);

        } catch (\Exception $e) {
            dLog('generate')->error('添加视频生成对话记录失败: ' . $e->getMessage(), [
                'segment_id' => $segmentIdOrActId,
                'video_url' => $videoUrl,
                'error' => $e->getMessage()
            ]);
        }
    }

    /**
     * 创建统一API视频生成任务（智帧20等新模型）
     *
     * @param array $params
     * @return MpGenerateVideoTask
     */
    public function createUnifiedApiTask(array $params): MpGenerateVideoTask
    {
        // 生成唯一的任务ID
        $taskId = 'unified_' . time() . '_' . uniqid();

        // 创建任务记录
        $task = MpGenerateVideoTask::create([
            'task_id' => $taskId,
            'alias_segment_id' => $params['alias_segment_id'] ?? '',
            'alias_act_id' => $params['alias_act_id'] ?? '',
            'prompt' => $params['prompt'] ?? '',
            'first_frame_url' => $params['first_frame_url'] ?? '',
            'tail_frame_url' => $params['last_frame_url'] ?? '',
            'ref_image_url' => $params['ref_image_url'] ?? json_encode([], 256),
            'seed' => $params['seed'] ?? -1,
            'frames' => $params['video_duration'] ? ($params['video_duration'] * 24 + 1) : null,
            'video_resolution' => $params['video_resolution'] ?? '720p',
            'status' => MpGenerateVideoTask::STATUS_PENDING,
            'api_type' => 'zzengine',
            'extra_params' => [
                'task_type' => 'video',
                'model_code' => $params['model_code'] ?? 'zhizhen-20',
                'callback_url' => $params['callback_url'] ?? '',
                'video_duration' => $params['video_duration'] ?? 5,
                'video_ratio' => $params['video_ratio'] ?? '9:16',
                'parameters' => $params['parameters'] ?? [],
            ]
        ]);

        // 提交任务到统一API
        $this->submitUnifiedApiTaskToApi($task);

        return $task;
    }

    /**
     * 提交任务到统一API
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function submitUnifiedApiTaskToApi(MpGenerateVideoTask $task): void
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);
        try {
            // 验证环境变量配置
            $apiKey = env('ZHIZHEN_AI_SK');
            $apiUrl = 'https://model-relay.zzengine.net/api/v1/task/submit';
                
            if (empty($apiKey)) {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '统一视频API密钥未配置，请检查环境变量UNIFIED_VIDEO_API_KEY'
                ]);
                return;
            }

            $extraParams = $task->extra_params;
            
            // 构建统一API请求参数
            $apiParams = [
                'task_type' => 'video',
                'model_code' => $extraParams['model_code'] ?? 'zhizhen-20',
                'prompt' => $task->prompt,
                'video_duration' => $extraParams['video_duration'] ?? 5,
                'video_resolution' => $task->video_resolution,
                'video_ratio' => $extraParams['video_ratio'] ?? '9:16',
            ];

            // 添加回调地址
            if (!empty($extraParams['callback_url'])) {
                $apiParams['callback_url'] = $extraParams['callback_url'];
            }

            // 添加parameters参数
            if (!empty($extraParams['parameters'])) {
                $apiParams['parameters'] = $extraParams['parameters'];
            }
            
            dLog('generate')->info('统一API视频生成参数: ', $apiParams);
            logDB('generate', 'info', '统一API视频生成任务提交', ['id' => $task->id, 'params' => $apiParams]);
            
            // 调用统一API
            $response = $client->post($apiUrl, [
                'headers' => [
                    'X-Api-Key' => $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('统一API响应: ', $responseData);
            logDB('generate', 'info', '统一API视频生成API响应', ['id' => $task->id, 'response' => $responseData]);
                
            if (isset($responseData['error']) || !isset($responseData['data']['task_uid'])) {
                // API返回错误
                $errorMsg = $responseData['error']['message'] ?? $responseData['message'] ?? 'API Error';
                logDB('generate', 'error', '统一API视频生成任务提交失败', ['id' => $task->id, 'error' => $errorMsg]);
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => $errorMsg,
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            } elseif (isset($responseData['data']['task_uid'])) {
                // 任务提交成功，更新状态为处理中
                $updateData = [
                    'task_id' => $responseData['data']['task_uid'], // 使用API返回的task_uid
                    'extra_params' => array_merge($task->extra_params, [
                        'task_uid' => $responseData['data']['task_uid'],
                        'estimated_amount' => $responseData['data']['estimated_amount'] ?? 0,
                        'account_uid' => $responseData['data']['account_uid'] ?? '',
                        'key_uid' => $responseData['data']['key_uid'] ?? '',
                        'api_response' => $responseData
                    ])
                ];
                $task->updateStatus(MpGenerateVideoTask::STATUS_PROCESSING, $updateData);
            } else {
                $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                    'error_message' => '未知的API响应格式',
                    'extra_params' => array_merge($task->extra_params, ['api_response' => $responseData])
                ]);
            }
        } catch (\GuzzleHttp\Exception\RequestException $e) {
            $errorMsg = 'API请求失败';
            if ($e->hasResponse()) {
                $errorResponse = json_decode($e->getResponse()->getBody()->getContents(), true);
                $errorMsg .= ': ' . ($errorResponse['message'] ?? $e->getMessage());
                logDB('generate', 'error', '统一API请求失败', ['id' => $task->id, 'error' => $errorResponse]);
            } else {
                $errorMsg .= ': ' . $e->getMessage();
                logDB('generate', 'error', '统一API请求失败', ['id' => $task->id, 'error' => $e->getMessage()]);
            }
            
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => $errorMsg
            ]);
        } catch (\Exception $e) {
            logDB('generate', 'error', '统一API任务提交异常', ['id' => $task->id, 'error' => $e->getMessage()]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 查询统一API任务状态
     *
     * @param MpGenerateVideoTask $task
     * @return array
     */
    public function queryUnifiedApiTaskStatus(MpGenerateVideoTask $task): array
    {
        $client = new Client(['verify' => false, 'timeout' => 1200]);
        try {
            // 获取API任务UID
            $extraParams = $task->extra_params;
            $taskUid = $extraParams['task_uid'] ?? $task->task_id;
                
            if (!$taskUid) {
                return [
                    'status' => 'failed',
                    'error_message' => 'API任务UID不存在',
                    'result_url' => null
                ];
            }

            // 验证环境变量配置
            $apiKey = env('ZHIZHEN_AI_SK');
            $apiUrl = 'https://model-relay.zzengine.net';
            $queryUrl = rtrim($apiUrl, '/') . '/api/v1/task/query';
                
            if (empty($apiKey)) {
                return [
                    'status' => 'failed',
                    'error_message' => '统一视频API密钥未配置',
                    'result_url' => null
                ];
            }

            dLog('generate')->info('查询统一API任务状态: ', ['task_uid' => $taskUid]);
            
            // 调用统一API查询接口（GET请求）
            $response = $client->get($queryUrl, [
                'headers' => [
                    'X-Api-Key' => $apiKey,
                ],
                'query' => [
                    'task_uid' => $taskUid
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);
            dLog('generate')->info('统一API任务状态查询响应: ', $responseData);

            // 检查响应code
            if (!isset($responseData['code']) || $responseData['code'] !== 0) {
                $errorMsg = $responseData['msg'] ?? $responseData['message'] ?? 'API查询失败';
                logDB('generate', 'error', '统一API任务状态查询失败', ['id' => $task->id, 'error' => $errorMsg]);
                return [
                    'status' => 'failed',
                    'error_message' => $errorMsg,
                    'result_url' => null,
                    'result_json' => $responseData ?? []
                ];
            }

            // 解析API响应
            $taskData = $responseData['data']['task'] ?? [];
            if (empty($taskData)) {
                return [
                    'status' => 'failed',
                    'error_message' => '任务数据为空',
                    'result_url' => null,
                    'result_json' => $responseData ?? []
                ];
            }

            // 任务状态映射：0=排队中，1=执行中，2=成功，3=失败
            $taskStatus = $taskData['status'] ?? 3;
            $failReason = $taskData['fail_reason'] ?? '';

            $returnData = [
                'status' => 'processing',
                'error_message' => null,
                'result_url' => null,
                'result_json' => $responseData ?? []
            ];

            // 根据status判断任务状态
            if ($taskStatus === 2) {
                // 任务成功
                $detail = $taskData['detail'] ?? [];
                $result = $detail['result'] ?? [];
                
                // 获取视频URL
                $videoUrl = $result['video'] ?? null;
                if (!$videoUrl && isset($result['videos']) && is_array($result['videos']) && count($result['videos']) > 0) {
                    $videoUrl = $result['videos'][0];
                }
                
                if ($videoUrl) {
                    // 保存视频到TOS并超分
                    try {
                        // 下载视频内容
                        $videoContent = file_get_contents($videoUrl);
                        
                        // 使用upgrade480pTo720p方法进行超分（传入视频内容）
                        dLog('generate')->info('开始对视频进行480p->720p超分', [
                            'original_url' => $videoUrl,
                            'size' => round(strlen($videoContent) / 1024 / 1024, 2) . 'MB'
                        ]);
                        
                        $url = upgrade480pTo720p($videoContent, 'video', true);
                        
                        if ($url) {
                            // 超分成功
                            dLog('generate')->info('视频超分成功', ['enhanced_url' => $url]);
                            $returnData['result_url'] = $url;
                            
                            // 压缩视频
                            $compressed_video_url = compressVideo($url);
                            $returnData['compressed_url'] = $compressed_video_url ?: $url;
                        } else {
                            // 超分失败，使用原视频
                            dLog('generate')->warning('视频超分失败，使用原视频');
                            $video_name = 'ai_generation_' . time() . '_' . uniqid();
                            $video_ext = getVideoExtFromUrl($videoUrl);
                            $video_name = $video_name . $video_ext;
                            $url = uploadStreamByTos('video', $videoContent, $video_name);
                            $returnData['result_url'] = $url;
                            
                            // 压缩视频
                            $compressed_video_url = compressVideo($url);
                            $returnData['compressed_url'] = $compressed_video_url ?: $url;
                        }
                    } catch (\Exception $e) {
                        dLog('generate')->error('保存视频到TOS失败', ['error' => $e->getMessage()]);
                        $returnData['result_url'] = $videoUrl; // 如果保存失败，使用原URL
                    }
                } else {
                    $returnData['status'] = 'failed';
                    $returnData['error_message'] = '视频URL不存在';
                    return $returnData;
                }
                
                // 获取视频时长
                $video_duration = $detail['duration'] ?? 0;
                if ($video_duration > 0) {
                    $returnData['video_duration'] = (int)$video_duration;
                    $returnData['video_time_point_start'] = 0;
                    $returnData['video_time_point_end'] = (int)$video_duration;
                }
                
                // 获取尾帧
                if (isset($result['last_frame_url'])) {
                    $returnData['last_frame_url'] = $result['last_frame_url'];
                }
                
                $returnData['status'] = 'success';
            } elseif ($taskStatus === 3) {
                // 任务失败
                $returnData['status'] = 'failed';
                $returnData['error_message'] = $failReason ?: '任务执行失败';
            } elseif (in_array($taskStatus, [0, 1])) {
                // 0=排队中，1=执行中
                $returnData['status'] = 'processing';
            } else {
                $returnData['status'] = 'failed';
                $returnData['error_message'] = '未知的任务状态: ' . $taskStatus;
            }

            return $returnData;
        } catch (\GuzzleHttp\Exception\RequestException $e) {
            $errorMsg = 'API查询失败';
            if ($e->hasResponse()) {
                $errorResponse = json_decode($e->getResponse()->getBody()->getContents(), true);
                $errorMsg .= ': ' . ($errorResponse['msg'] ?? $errorResponse['message'] ?? $e->getMessage());
            } else {
                $errorMsg .= ': ' . $e->getMessage();
            }
            return [
                'status' => 'processing',
                'error_message' => $errorMsg,
                'result_url' => null
            ];
        } catch (\Exception $e) {
            return [
                'status' => 'processing',
                'error_message' => $e->getMessage(),
                'result_url' => null
            ];
        }
    }

    /**
     * 更新统一API视频任务状态
     *
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function updateUnifiedApiTask($task): void
    {
        $statusInfo = $this->queryUnifiedApiTaskStatus($task);
        if (!isset($statusInfo['status'])) return;

        if ($statusInfo['status'] === 'success') {
            logDB('generate', 'info', '统一API视频生成任务成功', ['id' => $task->id, 'result_url' => $statusInfo['result_url']]);
            
            // // 判断是否为480p视频，如果是则触发超分逻辑
            // if ($task->video_resolution === '480P') {
            //     logDB('video_enhance', 'info', '检测到480p视频生成成功，准备自动触发超分', [
            //         'task_id' => $task->id
            //     ]);
                
            //     // 先更新任务状态为成功
            //     $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                
            //     // 调用超分任务提交方法
            //     $enhanceResult = $this->submitVideoEnhanceTask($task->id);
                
            //     if ($enhanceResult['success']) {
            //         logDB('video_enhance', 'info', '480p视频超分任务已自动提交', [
            //             'original_task_id' => $task->id,
            //             'enhance_task_id' => $enhanceResult['enhance_task_id']
            //         ]);
            //     } else {
            //         logDB('video_enhance', 'warning', '480p视频超分任务提交失败，保持原480p视频', [
            //             'task_id' => $task->id,
            //             'error' => $enhanceResult['message']
            //         ]);
                    
            //         // 超分失败时，仍然更新分镜表为480p视频
            //         $this->update480pVideoToSegment($task, $statusInfo);
            //     }
                
            //     // 480p视频已触发超分，直接返回，不继续后续更新操作
            //     return;
            // }
            
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id && isset($statusInfo['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    // 在事务中更新任务状态
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 构建更新数据
                    $segmentUpdateData = [
                        'origin_video_url' => $statusInfo['result_url'],
                        'video_task_status' => '已完成',
                        'current_type' => 2,
                        'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                        'updated_at' => $now
                    ];
                    
                    // 使用查询任务时已压缩的视频URL，避免重复压缩
                    $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
                    
                    // 只有当video_duration存在且大于0时才更新
                    if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                        $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                        $segmentUpdateData['video_time_point_start'] = 0;
                        
                        // 获取audio_duration（兼容全能模式）
                        $audio_duration = $this->getAudioDuration($task, $segment_id, $statusInfo['video_duration'] ?? null);
                        $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                    }
                    
                    // 更新分镜表（兼容act模式）
                    $this->updateSegmentTable($task, $segmentUpdateData);
                    
                    // 添加视频生成对话记录
                    $this->addVideoGenerationRecords($task, $segment_id, $statusInfo['result_url']);
                    
                    // 如果是全能模式的首帧图，则提取视频第一帧并更新anime表
                    $act_id = getProp($task, 'alias_act_id');
                    if (!empty($act_id) && Redis::sismember('anime_act_first_frame_urls', $act_id)) {
                        $anime_id = DB::table('mp_episode_segments')->where('id', $act_id)->value('anime_id');
                        if ($anime_id) {
                            // 提取视频第一帧
                            $videoUrl = $segmentUpdateData['video_url'];
                            $firstFrameUrl = getVideoFirstFrame($videoUrl, 'anime_first_frames', 'tos');
                            
                            if ($firstFrameUrl) {
                                // 更新anime表
                                DB::table('mp_animes')->where('id', $anime_id)->update([
                                    'first_frame_url' => $firstFrameUrl,
                                    'updated_at' => date('Y-m-d H:i:s')
                                ]);
                                
                                dLog('video_frame')->info('全能模式首帧图更新成功', [
                                    'act_id' => $act_id,
                                    'anime_id' => $anime_id,
                                    'first_frame_url' => $firstFrameUrl
                                ]);
                            }
                        }
                    }
                    
                    DB::commit();
                    // 从Redis中移除
                    Redis::srem('anime_act_first_frame_urls', $act_id);
                    
                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('generate')->error('统一API视频任务处理失败', [
                        'segment_id' => $segment_id,
                        'task_id' => $task->id,
                        'error' => $e->getMessage()
                    ]);
                }
            } else {
                // 没有segment_id的情况下，直接更新任务状态
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
            }
        } elseif ($statusInfo['status'] === 'failed') {
            logDB('generate', 'error', '统一API视频生成任务失败', ['id' => $task->id, 'error' => $statusInfo['error_message']]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => $statusInfo['error_message'],
                'result_json' => $statusInfo['result_json'] ?? []
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
        // 如果仍然是处理中状态，不做任何操作
        
        // 处理：如果任务处理超过48小时，标记为失败
        $processingTime = now()->diffInHours($task->created_at);
        if ($processingTime > 48) {
            logDB('generate', 'warning', '统一API视频生成任务超时', ['id' => $task->id, 'processing_hours' => $processingTime]);
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => '任务处理超时（超过48小时）'
            ]);
            
            // 同步更新分镜表状态为失败（兼容全能模式）
            $segment_id = $this->getSegmentIdFromTask($task);
            if ($segment_id) {
                $this->updateSegmentTable($task, [
                    'video_task_status' => '失败',
                    'updated_at' => date('Y-m-d H:i:s')
                ]);
            }
        }
    }

    /**
     * 更新480p视频到分镜表（超分失败时的降级处理）
     * 
     * @param MpGenerateVideoTask $task
     * @param array $statusInfo
     * @return void
     */
    private function update480pVideoToSegment($task, $statusInfo): void
    {
        $segment_id = $this->getSegmentIdFromTask($task);
        if (!$segment_id || !isset($statusInfo['result_url'])) {
            return;
        }
        
        try {
            DB::beginTransaction();
            
            $now = date('Y-m-d H:i:s');
            
            // 构建更新数据
            $segmentUpdateData = [
                'origin_video_url' => $statusInfo['result_url'],
                'video_task_status' => '已完成',
                'current_type' => 2,
                'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                'updated_at' => $now
            ];
            
            // 使用查询任务时已压缩的视频URL，避免重复压缩
            $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
            
            // 只有当video_duration存在且大于0时才更新
            if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                $segmentUpdateData['video_time_point_start'] = 0;
                
                // 获取audio_duration（兼容全能模式）
                $audio_duration = $this->getAudioDuration($task, $segment_id, $statusInfo['video_duration'] ?? null);
                $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
            }
            
            // 更新分镜表（兼容act模式）
            $this->updateSegmentTable($task, $segmentUpdateData);
            
            // 添加视频生成对话记录
            $this->addVideoGenerationRecords($task, $segment_id, $statusInfo['result_url']);
            
            DB::commit();
            
        } catch (\Exception $e) {
            DB::rollBack();
            dLog('generate')->error('480p视频更新分镜表失败', [
                'segment_id' => $segment_id,
                'task_id' => $task->id,
                'error' => $e->getMessage()
            ]);
        }
    }

    /**
     * 提交视频超分任务（480p -> 720p）
     * 
     * @param int $taskId mp_generate_video_tasks表的任务ID
     * @return array 包含成功状态和新任务ID或错误信息
     */
    public function submitVideoEnhanceTask(int $taskId): array
    {
        try {
            // 查询原任务
            $originalTask = MpGenerateVideoTask::find($taskId);
            if (!$originalTask) {
                return [
                    'success' => false,
                    'message' => '原任务不存在'
                ];
            }

            // 检查任务是否已完成
            if ($originalTask->status !== MpGenerateVideoTask::STATUS_SUCCESS) {
                return [
                    'success' => false,
                    'message' => '只能对已成功完成的任务进行超分处理'
                ];
            }

            // 检查分辨率是否为480p
            if ($originalTask->video_resolution !== '480P') {
                return [
                    'success' => false,
                    'message' => '只支持480P视频超分到720P'
                ];
            }

            // 检查是否有视频URL
            if (empty($originalTask->result_url)) {
                return [
                    'success' => false,
                    'message' => '原任务没有视频URL'
                ];
            }

            // 获取API Key
            $apiKey = env('VOLC_AI_MEDIAKIT_KEY');
            if (empty($apiKey)) {
                return [
                    'success' => false,
                    'message' => '火山引擎 MediaKit API Key 未配置'
                ];
            }

            // 构建请求参数
            $requestParams = [
                'video_url' => $originalTask->result_url,
                'resolution' => '720p',
                'bitrate_level' => 'medium'
            ];

            // 调用超分API
            $client = new Client(['verify' => false, 'timeout' => 120]);
            $response = $client->post('https://mediakit.cn-beijing.volces.com/api/v1/tools/enhance-video-fast', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => $requestParams
            ]);

            $responseData = json_decode($response->getBody(), true);
            
            dLog('generate')->info('视频超分任务提交响应', [
                'original_task_id' => $taskId,
                'response' => $responseData
            ]);

            // 检查API响应
            if (!isset($responseData['success']) || $responseData['success'] !== true) {
                $errorMsg = '超分任务提交失败';
                if (isset($responseData['error'])) {
                    $errorMsg .= ': ' . ($responseData['error']['message'] ?? json_encode($responseData['error']));
                }
                
                logDB('video_enhance', 'error', $errorMsg, [
                    'original_task_id' => $taskId,
                    'response' => $responseData
                ]);

                return [
                    'success' => false,
                    'message' => $errorMsg
                ];
            }

            // 使用事务创建新的超分任务记录并更新原任务
            try {
                DB::beginTransaction();
                
                // 创建新的超分任务记录
                $enhanceTask = MpGenerateVideoTask::create([
                    'task_id' => $responseData['task_id'],
                    'prompt' => $originalTask->prompt,
                    'video_resolution' => '720P', // 目标分辨率
                    'status' => MpGenerateVideoTask::STATUS_PROCESSING,
                    'api_type' => 'video_enhance',
                    'extra_params' => [
                        'original_task_id' => $originalTask->id,
                        'original_video_url' => $originalTask->result_url,
                        'enhance_type' => '480p_to_720p',
                        'request_id' => $responseData['request_id'] ?? '',
                        'api_response' => $responseData
                    ]
                ]);

                // 更新原任务的video_enhance_id字段
                $originalTask->update([
                    'video_enhance_id' => $enhanceTask->id
                ]);

                DB::commit();

                logDB('video_enhance', 'info', '视频超分任务创建成功', [
                    'original_task_id' => $taskId,
                    'enhance_task_id' => $enhanceTask->id,
                    'api_task_id' => $responseData['task_id']
                ]);

                return [
                    'success' => true,
                    'message' => '超分任务提交成功',
                    'enhance_task_id' => $enhanceTask->id,
                    'api_task_id' => $responseData['task_id']
                ];
                
            } catch (\Exception $e) {
                DB::rollBack();
                logDB('video_enhance', 'error', '创建超分任务失败', [
                    'original_task_id' => $taskId,
                    'error' => $e->getMessage()
                ]);
                
                return [
                    'success' => false,
                    'message' => '创建超分任务失败: ' . $e->getMessage()
                ];
            }

        } catch (\GuzzleHttp\Exception\RequestException $e) {
            $errorMsg = 'API请求失败';
            if ($e->hasResponse()) {
                $errorResponse = json_decode($e->getResponse()->getBody()->getContents(), true);
                $errorMsg .= ': ' . ($errorResponse['msg'] ?? $errorResponse['message'] ?? $e->getMessage());
            } else {
                $errorMsg .= ': ' . $e->getMessage();
            }

            logDB('video_enhance', 'error', $errorMsg, ['task_id' => $taskId]);

            return [
                'success' => false,
                'message' => $errorMsg
            ];
        } catch (\Exception $e) {
            logDB('video_enhance', 'error', '超分任务提交异常', [
                'task_id' => $taskId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'message' => '系统错误: ' . $e->getMessage()
            ];
        }
    }

    /**
     * 查询视频超分任务状态
     * 
     * @param MpGenerateVideoTask $task
     * @return array
     */
    public function queryVideoEnhanceTaskStatus(MpGenerateVideoTask $task): array
    {
        try {
            $apiKey = env('VOLC_AI_MEDIAKIT_KEY');
            if (empty($apiKey)) {
                return [
                    'status' => 'failed',
                    'error_message' => 'API Key 未配置'
                ];
            }

            // 调用查询任务信息API
            $client = new Client(['verify' => false, 'timeout' => 120]);
            $response = $client->get('https://mediakit.cn-beijing.volces.com/api/v1/tasks/' . $task->task_id, [
                'headers' => [
                    'Authorization' => 'Bearer ' . $apiKey,
                ]
            ]);

            $responseData = json_decode($response->getBody(), true);

            dLog('generate')->info('视频超分任务状态查询', [
                'task_id' => $task->id,
                'api_task_id' => $task->task_id,
                'response' => $responseData
            ]);

            // 检查响应
            if (!isset($responseData['success']) || $responseData['success'] !== true) {
                return [
                    'status' => 'failed',
                    'error_message' => isset($responseData['error']) ? 
                        ($responseData['error']['message'] ?? '查询失败') : '查询失败'
                ];
            }

            $taskData = $responseData;
            $taskStatus = $taskData['status'] ?? '';

            $returnData = [
                'status' => 'processing',
                'error_message' => null,
                'result_url' => null,
                'result_json' => $responseData
            ];

            // 解析任务状态
            if ($taskStatus === 'completed' && isset($taskData['result']['video_url'])) {
                // 任务成功，保存视频
                $videoUrl = $taskData['result']['video_url'];
                
                // 将视频保存到TOS
                $videoName = 'enhanced_video_' . time() . '_' . uniqid() . '.mp4';
                $savedUrl = uploadStreamByTos('video', file_get_contents($videoUrl), $videoName);
                
                $returnData['status'] = 'success';
                $returnData['result_url'] = $savedUrl;
                
                // 视频时长
                if (isset($taskData['result']['duration'])) {
                    $returnData['video_duration'] = (int)$taskData['result']['duration'];
                }
                
                // 压缩视频（可选）
                $compressedUrl = compressVideo($savedUrl);
                $returnData['compressed_url'] = $compressedUrl ?: $savedUrl;

            } elseif ($taskStatus === 'failed') {
                $returnData['status'] = 'failed';
                $returnData['error_message'] = '视频超分失败';
            } elseif (in_array($taskStatus, ['pending', 'processing', 'queued'])) {
                $returnData['status'] = 'processing';
            }

            return $returnData;

        } catch (\GuzzleHttp\Exception\RequestException $e) {
            $errorMsg = 'API查询失败';
            if ($e->hasResponse()) {
                $errorResponse = json_decode($e->getResponse()->getBody()->getContents(), true);
                $errorMsg .= ': ' . ($errorResponse['msg'] ?? $errorResponse['message'] ?? $e->getMessage());
            } else {
                $errorMsg .= ': ' . $e->getMessage();
            }
            
            return [
                'status' => 'processing',
                'error_message' => $errorMsg
            ];
        } catch (\Exception $e) {
            return [
                'status' => 'processing',
                'error_message' => $e->getMessage()
            ];
        }
    }

    /**
     * 更新视频超分任务状态
     * 
     * @param MpGenerateVideoTask $task
     * @return void
     */
    private function updateVideoEnhanceTask($task): void
    {
        $statusInfo = $this->queryVideoEnhanceTaskStatus($task);
        if (!isset($statusInfo['status'])) return;

        if ($statusInfo['status'] === 'success') {
            logDB('video_enhance', 'info', '视频超分任务成功', [
                'id' => $task->id,
                'result_url' => $statusInfo['result_url']
            ]);

            // 获取原始480p任务
            $extraParams = is_array($task->extra_params) ? $task->extra_params : json_decode($task->extra_params, true);
            $originalTaskId = $extraParams['original_task_id'] ?? null;
            
            if (!$originalTaskId) {
                // 如果没有原始任务ID，只更新超分任务本身
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                return;
            }

            $originalTask = MpGenerateVideoTask::find($originalTaskId);
            if (!$originalTask) {
                logDB('video_enhance', 'warning', '原始480p任务不存在', [
                    'enhance_task_id' => $task->id,
                    'original_task_id' => $originalTaskId
                ]);
                $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                return;
            }

            // 使用与updateUnifiedApiTask完全一致的逻辑
            $segment_id = $this->getSegmentIdFromTask($originalTask);
            if ($segment_id && isset($statusInfo['result_url'])) {
                try {
                    DB::beginTransaction();
                    
                    // 更新超分任务状态
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    // 更新原始480p任务状态
                    $originalTask->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    $now = date('Y-m-d H:i:s');
                    
                    // 构建更新数据（使用超分后的720p视频）
                    $segmentUpdateData = [
                        'origin_video_url' => $statusInfo['result_url'],
                        'video_task_status' => '已完成',
                        'current_type' => 2,
                        'last_frame_url' => $statusInfo['last_frame_url'] ?? '',
                        'updated_at' => $now
                    ];
                    
                    // 使用查询任务时已压缩的视频URL，避免重复压缩
                    $segmentUpdateData['video_url'] = $statusInfo['compressed_url'] ?? $statusInfo['result_url'];
                    
                    // 只有当video_duration存在且大于0时才更新
                    if (isset($statusInfo['video_duration']) && $statusInfo['video_duration'] > 0) {
                        $segmentUpdateData['video_duration'] = $statusInfo['video_duration'];
                        $segmentUpdateData['video_time_point_start'] = 0;
                        
                        // 获取audio_duration（兼容全能模式）
                        $audio_duration = $this->getAudioDuration($originalTask, $segment_id, $statusInfo['video_duration'] ?? null);
                        $segmentUpdateData['video_time_point_end'] = $audio_duration ?? 0;
                    }
                    
                    // 更新分镜表（兼容act模式）
                    $this->updateSegmentTable($originalTask, $segmentUpdateData);
                    
                    // 添加视频生成对话记录
                    $this->addVideoGenerationRecords($originalTask, $segment_id, $statusInfo['result_url']);
                    
                    // 如果是全能模式的首帧图，则提取视频第一帧并更新anime表
                    $act_id = getProp($originalTask, 'alias_act_id');
                    if (!empty($act_id) && Redis::sismember('anime_act_first_frame_urls', $act_id)) {
                        $anime_id = DB::table('mp_episode_segments')->where('id', $act_id)->value('anime_id');
                        if ($anime_id) {
                            // 提取视频第一帧
                            $videoUrl = $segmentUpdateData['video_url'];
                            $firstFrameUrl = getVideoFirstFrame($videoUrl, 'anime_first_frames', 'tos');
                            
                            if ($firstFrameUrl) {
                                // 更新anime表
                                DB::table('mp_animes')->where('id', $anime_id)->update([
                                    'first_frame_url' => $firstFrameUrl,
                                    'updated_at' => date('Y-m-d H:i:s')
                                ]);
                                
                                dLog('video_frame')->info('全能模式首帧图更新成功（超分任务）', [
                                    'act_id' => $act_id,
                                    'anime_id' => $anime_id,
                                    'first_frame_url' => $firstFrameUrl
                                ]);
                            }
                        }
                    }
                    
                    DB::commit();
                    // 从Redis中移除
                    Redis::srem('anime_act_first_frame_urls', $act_id);

                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('video_enhance')->error('超分任务处理失败', [
                        'segment_id' => $segment_id,
                        'enhance_task_id' => $task->id,
                        'original_task_id' => $originalTaskId,
                        'error' => $e->getMessage()
                    ]);
                }
            } else {
                // 没有segment_id的情况下，只更新任务状态
                try {
                    DB::beginTransaction();
                    
                    $task->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    $originalTask->updateStatus(MpGenerateVideoTask::STATUS_SUCCESS, $statusInfo);
                    
                    DB::commit();
                } catch (\Exception $e) {
                    DB::rollBack();
                    dLog('video_enhance')->error('超分任务状态更新失败', [
                        'enhance_task_id' => $task->id,
                        'original_task_id' => $originalTaskId,
                        'error' => $e->getMessage()
                    ]);
                }
            }

        } elseif ($statusInfo['status'] === 'failed') {
            logDB('video_enhance', 'error', '视频超分任务失败', [
                'id' => $task->id,
                'error' => $statusInfo['error_message']
            ]);
            
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => $statusInfo['error_message'],
                'result_json' => $statusInfo['result_json'] ?? []
            ]);
            
            // 不更新原始任务状态，保留480p任务的成功状态
        }

        // 超时检查：48小时
        $processingTime = now()->diffInHours($task->created_at);
        if ($processingTime > 48 && $task->status === MpGenerateVideoTask::STATUS_PROCESSING) {
            logDB('video_enhance', 'warning', '视频超分任务超时', [
                'id' => $task->id,
                'processing_hours' => $processingTime
            ]);
            
            $task->updateStatus(MpGenerateVideoTask::STATUS_FAILED, [
                'error_message' => '任务处理超时（超过48小时）'
            ]);
        }
    }
}