mp_audio_manage/app/Services/AIGeneration/AIImageGenerationService.php

<?php

namespace App\Services\AIGeneration;

use App\Models\MpGeneratePicTask;
use App\Models\MpAsset;
use App\Services\VolcEngineService;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\GuzzleException;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;
use App\Consts\BaseConst;

class AIImageGenerationService
{
    private $volcEngineService;
    private $httpClient;

    // 模型常量
    const MODEL_JIMENG_4 = 'jimeng_4.0';
    const MODEL_NANO_BANANA_2 = 'NanoBanana2';
    const MODEL_NANO_BANANA_PRO = 'NanoBananaPro';
    const MODEL_GPT_IMAGE_2 = 'GptImage2';

    public function __construct(VolcEngineService $volcEngineService)
    {
        $this->volcEngineService = $volcEngineService;
        $this->httpClient = new Client([
            'timeout' => 300,
        ]);
    }

    /**
     * 异步创建图片生成任务
     *
     * @param array $params
     * @return MpGeneratePicTask
     */
    public function createImageGenerationTask(array $params): MpGeneratePicTask
    {
        // // 获取模型类型，默认使用即梦AI 4.0
        // $model = $params['model'] ?? self::MODEL_JIMENG_4;

        // 获取模型类型，默认使用即梦seedream5.0-lite
        $model = $params['model'] ?? 'doubao-seedream-5-0-lite-260128';
        
        // 检查是否有正在处理的任务（仅即梦AI需要排队）
        if ($model === self::MODEL_JIMENG_4 && $this->hasProcessingTask()) {
            // 如果有正在处理的任务，创建排队任务
            return $this->createQueuedTask($params);
        }

        // 生成唯一的任务ID
        $taskId = 'img_gen_' . time() . '_' . uniqid();

        // 创建任务记录
        $task = MpGeneratePicTask::create([
            'task_id' => $taskId,
            'alias_segment_id' => $params['alias_segment_id'] ?? 0,
            'prompt' => $params['prompt'] ?? '',
            'width' => $params['width'] ?? 1600,
            'height' => $params['height'] ?? 2848,
            'image_num' => $params['image_num'] ?? 1,
            'scale' => $params['scale'] ?? 50,
            'ref_img_url' => $params['ref_img_urls'] ?? null,
            'mask_img_url' => $params['mask_img_url'] ?? null,
            'extra_params' => $params['extra_params'] ?? null,
            'status' => MpGeneratePicTask::STATUS_PENDING,
            'model' => $model,
        ]);

        // 即梦AI和NanoBanana系列立即提交任务，火山API在定时任务中提交
        if ($model === self::MODEL_JIMENG_4) {
            $this->submitTaskToJimengApi($task);
        } elseif (in_array($model, BaseConst::NANO_BANANA_MODELS)) {
            $this->submitTaskToNanoBananaApi($task);
        }

        return $task;
    }

    /**
     * 检查是否有正在处理的任务
     *
     * @return bool
     */
    private function hasProcessingTask(): bool
    {
        return MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PROCESSING)
            ->exists();
    }

    /**
     * 创建排队任务
     *
     * @param array $params
     * @return MpGeneratePicTask
     */
    private function createQueuedTask(array $params): MpGeneratePicTask
    {
        // 生成唯一的任务ID
        $taskId = 'img_gen_' . time() . '_' . uniqid();
        
        // 获取模型类型
        $model = $params['model'] ?? self::MODEL_JIMENG_4;

        // 创建排队状态的任务记录
        return MpGeneratePicTask::create([
            'task_id' => $taskId,
            'alias_segment_id' => $params['alias_segment_id'] ?? 0,
            'prompt' => $params['prompt'] ?? '',
            'width' => $params['width'] ?? 1600,
            'height' => $params['height'] ?? 2848,
            'image_num' => $params['image_num'] ?? 1,
            'scale' => $params['scale'] ?? 50,
            'ref_img_url' => $params['ref_img_urls'] ?? null,
            'mask_img_url' => $params['mask_img_url'] ?? null,
            'extra_params' => $params['extra_params'] ?? null,
            'status' => MpGeneratePicTask::STATUS_PENDING,
            'model' => $model,
        ]);
    }

    /**
     * 提交任务到即梦AI API
     *
     * @param MpGeneratePicTask $task
     * @return void
     */
    private function submitTaskToJimengApi(MpGeneratePicTask $task): void
    {
        try {
            // 验证环境变量配置
            $accessKey = env('VOLC_AI_AK');
            $secretKey = env('VOLC_AI_SK');
                
            if (empty($accessKey) || empty($secretKey)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '火山引擎访问密钥未配置，请检查环境变量AK和SK'
                ]);
                return;
            }
                
            //构建即梦AI 4.0 API请求参数
            $apiParams = [
                'req_key' => 'jimeng_t2i_v40',
                'prompt' => $task->prompt,
                'scale' => $task->scale / 100, //为0-1范围
            ];
            
            // 添加可选参数
            if ($task->image_num > 1) {
                $apiParams['force_single'] = false;
            } else {
                $apiParams['force_single'] = true;
            }
            
            // 参考图片
            if ($task->ref_img_url) {
                $apiParams['image_urls'] = $task->ref_img_url;
            }
                        
            // if ($task->mask_img_url) {
            //     $apiParams['image_urls'] = $task->mask_img_url;
            // }
            
            // 尺寸参数
            $area = $task->width * $task->height; //计算面积
            if ($area >= 1024*1024 && $area <= 4096*4096) {
                $apiParams['size'] = (int)$area;
            }

            dLog('generate')->info('即梦AI文生图参数: ', $apiParams);
            logDB('generate', 'info', '即梦AI文生图任务提交', ['task_id' => $task->task_id, 'params' => $apiParams]);
            
            //调用即梦AI 4.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 4.0 API提交任务响应: ', $responseData);
            logDB('generate', 'info', '即梦AI 4.0 API提交任务响应', ['task_id' => $task->task_id, 'response' => $responseData]);
                
            if ($responseData['code'] !== 10000) {
                // API返回错误
                logDB('generate', 'error', '即梦AI任务提交失败', ['task_id' => $task->task_id, 'error' => $responseData['message'] ?? 'API Error']);
                $task->updateStatus(MpGeneratePicTask::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 ?? [];
                }
    
                $task->updateStatus(MpGeneratePicTask::STATUS_PROCESSING, $updateData);
            }
        } catch (\Exception $e) {
            // 记录错误
            logDB('generate', 'error', '即梦AI任务提交异常', ['task_id' => $task->task_id, 'error' => $e->getMessage()]);
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 提交任务到GPT-Image2 API
     *
     * @param MpGeneratePicTask $task
     * @return void
     */
    public function submitTaskToGptImage2Api(MpGeneratePicTask $task): void
    {
        try {
            // 验证环境变量配置
            $apiKey = env('GPT_IMAGE2_API_KEY');
                
            if (empty($apiKey)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => 'GPT-Image2 API KEY未配置，请检查环境变量GPT_IMAGE2_API_KEY'
                ]);
                return;
            }
            
            // 更新状态为处理中
            $task->updateStatus(MpGeneratePicTask::STATUS_PROCESSING);
            
            // $api_url = 'https://token.ithinkai.cn/v1/images/generations';    // 备用地址1
            // $api_url = 'https://api.nonelinear.com/v1/images/generations';   // 备用地址2
            $api_url = 'https://ai-api.kkidc.com/v1/images/generations';
            $isEditMode = false;
            
            // 参考图片 - 如果有参考图则使用 /edits 接口
            if ($task->ref_img_url) {
                // $api_url = 'https://token.ithinkai.cn/v1/images/edits';  // 备用地址1
                // $api_url = 'https://api.nonelinear.com/v1/images/generations';  // 备用地址2
                $api_url = 'https://ai-api.kkidc.com/v1/images/edits';
                $isEditMode = true;
            }
            
            dLog('generate')->info('开始调用GPT-Image2 API', ['task_id' => $task->task_id, 'mode' => $isEditMode ? 'edit' : 'generation']);
            logDB('generate', 'info', '开始调用GPT-Image2 API', ['task_id' => $task->task_id, 'mode' => $isEditMode ? 'edit' : 'generation']);
            
            // 创建专用客户端，优化配置
            $gptClient = new Client([
                'timeout' => 1800, // 超时
                'connect_timeout' => 120, // 连接超时10秒
                'http_errors' => false, // 不自动抛出HTTP错误
                'verify' => false, // 禁用SSL验证（如果有证书问题）
                'allow_redirects' => true,
            ]);
            
            // 根据是否有参考图选择不同的请求方式
            if ($isEditMode) {
                // 使用原生 cURL 处理 multipart/form-data 格式
                $imageUrls = is_array($task->ref_img_url) ? $task->ref_img_url : [$task->ref_img_url];
                
                // 限制最多4张参考图
                $imageUrls = array_slice($imageUrls, 0, 4);
                
                dLog('generate')->info('下载参考图片', ['image_urls' => $imageUrls, 'count' => count($imageUrls)]);
                
                // 下载所有参考图片并保存为临时文件
                $tempFiles = [];
                foreach ($imageUrls as $index => $imageUrl) {
                    $imageContent = @file_get_contents($imageUrl);
                    if ($imageContent === false) {
                        dLog('generate')->warning('下载参考图片失败，跳过', ['image_url' => $imageUrl]);
                        continue;
                    }
                    
                    dLog('generate')->info('参考图片下载完成', ['index' => $index, 'size' => strlen($imageContent)]);
                    
                    // 保存为临时文件（cURL 需要真实文件路径）
                    $extension = pathinfo(parse_url($imageUrl, PHP_URL_PATH), PATHINFO_EXTENSION) ?: 'png';
                    $tempFile = tempnam(sys_get_temp_dir(), 'gpt_img_') . '.' . $extension;
                    file_put_contents($tempFile, $imageContent);
                    
                    $tempFiles[] = [
                        'path' => $tempFile,
                        'extension' => $extension
                    ];
                    
                    dLog('generate')->info('临时文件创建成功', ['file' => $tempFile, 'size' => filesize($tempFile)]);
                }
                
                if (empty($tempFiles)) {
                    throw new \Exception('所有参考图片下载失败');
                }
                
                // 构建 POST 字段
                $postFields = [
                    'prompt' => $task->prompt,
                    'model' => 'gpt-image-2',
                    'n' => (string)$task->image_num, // 新接口要求字符串类型
                    'response_format' => 'b64_json', // 新接口必填参数
                ];
                
                // 尺寸参数（必填）
                if ($task->width && $task->height) {
                    $postFields['size'] = $task->width . 'x' . $task->height;
                } else {
                    $postFields['size'] = '1024x1024'; // 默认尺寸
                }
                
                // 添加参考图片文件（支持多图，新接口要求使用 image 字段名）
                foreach ($tempFiles as $index => $tempFile) {
                    $fieldName = 'image'; // 新接口统一使用 image 字段名
                    $postFields[$fieldName] = new \CURLFile(
                        $tempFile['path'], 
                        'image/' . $tempFile['extension'], 
                        'image' . ($index + 1) . '.' . $tempFile['extension']
                    );
                }
                
                dLog('generate')->info('GPT-Image2 API参数(编辑模式-cURL)', [
                    'api_url' => $api_url, 
                    'prompt' => $task->prompt, 
                    'size' => $postFields['size'], 
                    'n' => $postFields['n'],
                    'response_format' => $postFields['response_format'],
                    'image_count' => count($tempFiles)
                ]);
                logDB('generate', 'info', 'GPT-Image2任务提交(编辑模式)', [
                    'task_id' => $task->task_id, 
                    'api_url' => $api_url, 
                    'image_urls' => $imageUrls, 
                    'prompt' => $task->prompt
                ]);
                
                $startTime = microtime(true);
                
                // 使用原生 cURL
                $ch = curl_init();
                curl_setopt_array($ch, [
                    CURLOPT_URL => $api_url,
                    CURLOPT_RETURNTRANSFER => true,
                    CURLOPT_POST => true,
                    CURLOPT_POSTFIELDS => $postFields,
                    CURLOPT_HTTPHEADER => [
                        'Authorization: Bearer ' . $apiKey,
                        'Accept: application/json',
                        'Expect:', // 移除 Expect: 100-continue，避免等待
                    ],
                    CURLOPT_TIMEOUT => 600,
                    CURLOPT_CONNECTTIMEOUT => 30,
                    CURLOPT_SSL_VERIFYPEER => false,
                    CURLOPT_SSL_VERIFYHOST => false,
                    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1, // 强制使用 HTTP/1.1
                ]);
                
                dLog('generate')->info('开始发送cURL请求');
                
                $responseBody = curl_exec($ch);
                $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                $curlError = curl_error($ch);
                $curlErrno = curl_errno($ch);
                curl_close($ch);
                
                // 删除所有临时文件
                foreach ($tempFiles as $tempFile) {
                    @unlink($tempFile['path']);
                }
                
                $elapsed = round(microtime(true) - $startTime, 2);
                dLog('generate')->info('cURL请求完成', ['elapsed' => $elapsed . 's', 'http_code' => $statusCode, 'curl_errno' => $curlErrno]);
                
                if ($curlErrno !== 0) {
                    throw new \Exception('cURL错误: ' . $curlError . ' (错误码: ' . $curlErrno . ')');
                }
                
                if (empty($responseBody)) {
                    throw new \Exception('API返回空响应，HTTP状态码: ' . $statusCode);
                }
            } else {
                // 使用 JSON 格式 (原有的文生图模式)
                $apiParams = [
                    'model' => 'gpt-image-2',
                    'prompt' => $task->prompt,
                    'n' => (int)$task->image_num,
                    'quality' => 'auto', // 新接口必填参数：图像质量等级
                    'response_format' => 'b64_json', // 新接口必填参数：返回格式
                ];
                
                // 尺寸参数
                if ($task->width && $task->height) {
                    $apiParams['size'] = $task->width . 'x' . $task->height;
                } else {
                    $apiParams['size'] = 'auto'; // 新接口必填参数
                }
                
                dLog('generate')->info('GPT-Image2 API参数', $apiParams);
                logDB('generate', 'info', 'GPT-Image2任务提交', ['task_id' => $task->task_id, 'api_url' => $api_url, 'params' => $apiParams]);
                
                $startTime = microtime(true);
                
                // 调用GPT-Image2 API
                $response = $gptClient->post($api_url, [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $apiKey,
                        'Content-Type' => 'application/json',
                    ],
                    'json' => $apiParams,
                ]);
                
                $statusCode = $response->getStatusCode();
                $responseBody = $response->getBody()->getContents();
                
                $elapsed = round(microtime(true) - $startTime, 2);
                dLog('generate')->info('Guzzle请求完成', ['elapsed' => $elapsed . 's', 'http_code' => $statusCode]);
                
                if (empty($responseBody)) {
                    throw new \Exception('API返回空响应，HTTP状态码: ' . $statusCode);
                }
            }
            
            // 解析响应
            dLog('generate')->info('响应数据长度', ['length' => strlen($responseBody)]);
            
            $responseData = json_decode($responseBody, true);
            
            if (json_last_error() !== JSON_ERROR_NONE) {
                dLog('generate')->error('JSON解析失败', ['error' => json_last_error_msg(), 'body' => substr($responseBody, 0, 500)]);
                throw new \Exception('JSON解析失败: ' . json_last_error_msg());
            }
            
            dLog('generate')->info('GPT-Image2 API响应', $responseData);
            logDB('generate', 'info', 'GPT-Image2 API响应', ['task_id' => $task->task_id, 'response' => $responseData]);
                
            if (isset($responseData['error'])) {
                // API返回错误
                logDB('generate', 'error', 'GPT-Image2任务失败', ['task_id' => $task->task_id, 'error' => $responseData['error']['message'] ?? 'API Error']);
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => $responseData['error']['message'] ?? 'API Error',
                    'result_json' => $responseData
                ]);
            } else {
                // 任务提交成功，直接处理结果
                dLog('generate')->info('开始处理GPT-Image2响应结果');
                $this->processGptImage2ApiResponse($task, $responseData);
            }
        } catch (\Exception $e) {
            // 记录错误
            dLog('generate')->error('GPT-Image2 API请求失败: ' . $e->getMessage(), [
                'task_id' => $task->task_id,
                'trace' => $e->getTraceAsString()
            ]);
            logDB('generate', 'error', 'GPT-Image2任务异常', [
                'task_id' => $task->task_id, 
                'error' => $e->getMessage(),
                'file' => $e->getFile(),
                'line' => $e->getLine()
            ]);
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 处理GPT-Image2 API响应结果
     *
     * @param MpGeneratePicTask $task
     * @param array $responseData
     * @return void
     */
    private function processGptImage2ApiResponse(MpGeneratePicTask $task, array $responseData): void
    {
        try {
            if (!isset($responseData['data']) || empty($responseData['data'])) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '未返回图片数据',
                    'result_json' => $responseData
                ]);
                return;
            }

            $result_urls = [];
            foreach ($responseData['data'] as $index => $imageData) {
                // 优先处理 b64_json 格式（新接口返回格式）
                if (isset($imageData['b64_json']) && !empty($imageData['b64_json'])) {
                    $base64Data = $imageData['b64_json'];
                    $imageStream = base64_decode($base64Data);
                    
                    if ($imageStream === false) {
                        dLog('generate')->error('Base64解码失败', ['task_id' => $task->task_id, 'index' => $index]);
                        continue;
                    }
                    
                    $pic_name = 'ai_generation_gpt_' . time() . '_' . uniqid() . '.png';
                    
                    // 压缩PNG图片流
                    $compressedData = $this->compressImageStream($imageStream);
                    $url = uploadStreamByTos('image', $compressedData, $pic_name);
                    
                    $result_urls[] = $url;
                    
                    // 记录优化后的提示词（如果有）
                    if (isset($imageData['revised_prompt'])) {
                        dLog('generate')->info('图片生成优化提示词', [
                            'task_id' => $task->task_id,
                            'index' => $index,
                            'revised_prompt' => $imageData['revised_prompt']
                        ]);
                    }
                } elseif (isset($imageData['url']) && !empty($imageData['url'])) {
                    // 兼容旧的 url 格式（如果接口仍返回）
                    $url = $imageData['url'];
                    $pic_name = 'ai_generation_gpt_' . time() . '_' . uniqid();
                    $pic_ext = getImgExtFromUrl($url);
                    $pic_name = $pic_name . $pic_ext;
                    
                    if ($pic_ext === '.png') {
                        $comporessed_data = compressRemoteImageUrlToSize($url);
                        $url = uploadStreamByTos('image', $comporessed_data, $pic_name);
                    } else {
                        $url = uploadStreamByTos('image', file_get_contents($url), $pic_name);
                    }
                    
                    $result_urls[] = $url;
                }
            }

            if (empty($result_urls)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '所有图片生成失败',
                    'result_json' => $responseData
                ]);
                return;
            }

            // 移除 b64_json 字段以避免存储大量 Base64 数据
            $cleanedResponseData = $responseData;
            if (isset($cleanedResponseData['data'])) {
                foreach ($cleanedResponseData['data'] as &$imageData) {
                    unset($imageData['b64_json']); // 移除 Base64 数据
                }
                unset($imageData); // 解除引用
            }

            // 更新任务状态为成功
            $task->updateStatus(MpGeneratePicTask::STATUS_SUCCESS, [
                'result_url' => $result_urls,
                'result_json' => $cleanedResponseData // 保存清理后的数据
            ]);

            // 同步调整分镜图片状态和结果
            $segment_id = getProp($task, 'alias_segment_id');
            if ($segment_id) {
                DB::table('mp_episode_segments')->where('segment_id', $segment_id)->update([
                    'img_url' => $result_urls[0],
                    'pic_task_status' => '已完成',
                ]);
                
                // 如果是首帧图ID则更新anime表
                if (Redis::sismember('anime_first_frame_urls', $segment_id)) {
                    $anime_id = DB::table('mp_episode_segments')->where('segment_id', $segment_id)->value('anime_id');
                    DB::table('mp_animes')->where('id', $anime_id)->update(['first_frame_url' => $result_urls[0], 'updated_at' => date('Y-m-d H:i:s')]);
                    Redis::srem('anime_first_frame_urls', $segment_id);
                }
            }
        } catch (\Exception $e) {
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => '处理响应失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 提交任务到火山图片生成API
     *
     * @param MpGeneratePicTask $task
     * @return void
     */
    public function submitTaskToVolcApi(MpGeneratePicTask $task): void
    {
        try {
            // 验证环境变量配置
            $apiKey = env('VOLC_AI_API_KEY');
                
            if (empty($apiKey)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '火山引擎API KEY未配置，请检查环境变量VOLC_AI_API_KEY'
                ]);
                return;
            }
            
            // 更新状态为处理中
            $task->updateStatus(MpGeneratePicTask::STATUS_PROCESSING);
                
            // 构建火山图片生成API请求参数
            $apiParams = [
                'model' => isset(BaseConst::MODELS_MAP[$task->model]) ? BaseConst::MODELS_MAP[$task->model] : $task->model,
                'prompt' => $task->prompt,
                'watermark' => false,
            ];
            
            // 尺寸参数
            if ($task->width && $task->height) {
                $apiParams['size'] = $task->width . 'x' . $task->height;
            }
            
            // 参考图片
            if ($task->ref_img_url) {
                if (is_array($task->ref_img_url)) {
                    // $apiParams['image'] = count($task->ref_img_url) === 1 ? $task->ref_img_url[0] : $task->ref_img_url;
                    $apiParams['image'] = $task->ref_img_url;
                } else {
                    $apiParams['image'] = $task->ref_img_url;
                }
            }

            // 生成多图或者单图
            if ((int)$task->image_num === 1) {
                $apiParams['sequential_image_generation'] = 'disabled';
            }else if ($task->image_num > 1) {
                $apiParams['sequential_image_generation'] = 'auto';
                $apiParams['sequential_image_generation_options']['max_images'] = $task->image_num;
            }

            dLog('generate')->info('火山图片生成API参数: ', $apiParams);
            logDB('generate', 'info', '火山图片生成任务提交', ['task_id' => $task->task_id, 'params' => $apiParams]);
            
            // 调用火山图片生成API
            $response = $this->httpClient->post('https://ark.cn-beijing.volces.com/api/v3/images/generations', [
                'headers' => [
                    'Authorization' => 'Bearer ' . $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => $apiParams,
            ]);
    
            $responseData = json_decode($response->getBody()->getContents(), true);
            dLog('generate')->info('火山图片生成API响应: ', $responseData);
            logDB('generate', 'info', '火山图片生成API响应', ['task_id' => $task->task_id, 'response' => $responseData]);
                
            if (isset($responseData['error'])) {
                // API返回错误
                logDB('generate', 'error', '火山图片生成任务失败', ['task_id' => $task->task_id, 'error' => $responseData['error']['message'] ?? 'API Error']);
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => $responseData['error']['message'] ?? 'API Error',
                    'result_json' => $responseData
                ]);
            } else {
                // 任务提交成功，直接处理结果
                $this->processVolcApiResponse($task, $responseData);
            }
        } catch (\Exception $e) {
            // 记录错误
            dLog('generate')->error('火山API请求失败: ' . $e->getMessage());
            logDB('generate', 'error', '火山图片生成任务异常', ['task_id' => $task->task_id, 'error' => $e->getMessage()]);
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 处理火山API响应结果
     *
     * @param MpGeneratePicTask $task
     * @param array $responseData
     * @return void
     */
    private function processVolcApiResponse(MpGeneratePicTask $task, array $responseData): void
    {
        try {
            if (!isset($responseData['data']) || empty($responseData['data'])) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '未返回图片数据',
                    'result_json' => $responseData
                ]);
                return;
            }

            $result_urls = [];
            foreach ($responseData['data'] as $imageData) {
                if (isset($imageData['error'])) {
                    // 单张图片生成失败
                    dLog('generate')->warning('单张图片生成失败: ', $imageData['error']);
                    continue;
                }

                if (isset($imageData['url'])) {
                    $url = $imageData['url'];
                    $pic_name = 'ai_generation_' . time() . '_' . uniqid();
                    $pic_ext = getImgExtFromUrl($url);
                    $pic_name = $pic_name . $pic_ext;
                    
                    if ($pic_ext === '.png') {
                        $comporessed_data = compressRemoteImageUrlToSize($url);
                        $url = uploadStreamByTos('image', $comporessed_data, $pic_name);
                    } else {
                        // 将图片另存到tos
                        $url = uploadStreamByTos('image', file_get_contents($url), $pic_name);
                    }
                    
                    $result_urls[] = $url;
                }
            }

            if (empty($result_urls)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '所有图片生成失败',
                    'result_json' => $responseData
                ]);
                return;
            }

            // 更新任务状态为成功
            $task->updateStatus(MpGeneratePicTask::STATUS_SUCCESS, [
                'result_url' => $result_urls,
                'result_json' => $responseData
            ]);

            // 同步调整分镜图片状态和结果
            $segment_id = getProp($task, 'alias_segment_id');
            if ($segment_id) {
                DB::table('mp_episode_segments')->where('segment_id', $segment_id)->update([
                    'img_url' => $result_urls[0],
                    'pic_task_status' => '已完成',
                ]);
                
                // 如果是首帧图ID则更新anime表
                if (Redis::sismember('anime_first_frame_urls', $segment_id)) {
                    $anime_id = DB::table('mp_episode_segments')->where('segment_id', $segment_id)->value('anime_id');
                    DB::table('mp_animes')->where('id', $anime_id)->update(['first_frame_url' => $result_urls[0], 'updated_at' => date('Y-m-d H:i:s')]);
                    Redis::srem('anime_first_frame_urls', $segment_id);
                }
            }
        } catch (\Exception $e) {
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => '处理响应失败: ' . $e->getMessage()
            ]);
        }
    }

    public function getTaskList($data)
    {
        $task_id = getProp($data, 'task_id');
        $status = getProp($data, 'status');

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

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

    /**
     * 查询任务状态
     *
     * @param MpGeneratePicTask $task
     * @return array
     */
    public function queryTaskStatus(MpGeneratePicTask $task): array
    {
        // 根据模型类型调用不同的查询方法
        if ($task->model === self::MODEL_JIMENG_4) {
            return $this->queryJimengTaskStatus($task);
        } elseif (in_array($task->model, BaseConst::NANO_BANANA_MODELS)) {
            return $this->queryNanoBananaTaskStatus($task);
        } else {
            // 火山API是同步返回结果，不需要查询
            return [
                'status' => $task->status === MpGeneratePicTask::STATUS_SUCCESS ? 'success' : 'failed',
                'error_message' => $task->error_message,
                'result_url' => $task->result_url,
                'result_json' => $task->result_json ?? []
            ];
        }
    }

    /**
     * 查询即梦AI任务状态
     *
     * @param MpGeneratePicTask $task
     * @return array
     */
    private function queryJimengTaskStatus(MpGeneratePicTask $task): array
    {
        try {
            // 获取API任务ID
            $apiTaskId = $task->task_id ?? null;
                
            if (!$apiTaskId) {
                return [
                    'status' => 'failed',
                    'error_message' => 'API任务ID不存在',
                    'result_url' => null
                ];
            }
    
            //构建查询参数
            $apiParams = [
                'req_key' => 'jimeng_t2i_v40',
                'task_id' => $apiTaskId,
                'req_json' => '{"return_url":true}' // 返回URL格式
            ];
    
            //调用即梦AI 4.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 4.0 API查询任务状态响应: ', $responseData);
            logDB('generate', 'info', '即梦AI任务状态查询', ['task_id' => $apiTaskId, 'response' => $responseData]);
    
            if ($responseData['code'] !== 10000) {
                // API返回错误
                logDB('generate', 'error', '即梦AI任务状态查询失败', ['task_id' => $apiTaskId, '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['image_urls']) && count($result['image_urls']) > 0) {
                $result_urls = [];
                foreach ($result['image_urls'] as $url) {
                    $pic_name = 'ai_generation_' . time() . '_' . uniqid();
                    $pic_ext = getImgExtFromUrl($url);
                    $pic_name = $pic_name . $pic_ext;
                    
                    if ($pic_ext === '.png') {
                        $comporessed_data = compressRemoteImageUrlToSize($url);
                        $url = uploadStreamByTos('image', $comporessed_data, $pic_name);
                    }else {
                        // 将图片另存到tos
                        $url = uploadStreamByTos('image', file_get_contents($url), $pic_name);
                    }
                    
                    $result_urls[] = $url;
                }
                $returnData['result_url'] = $result_urls;
                $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
            ];
        }
    }

    /**
     * 提交任务到NanoBanana API
     *
     * @param MpGeneratePicTask $task
     * @return void
     */
    private function submitTaskToNanoBananaApi(MpGeneratePicTask $task): void
    {
        try {
            // 验证环境变量配置
            $apiKey = env('NANO_BANANA_API_KEY');
                
            if (empty($apiKey)) {
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => 'NanoBanana API KEY未配置，请检查环境变量NANO_BANANA_API_KEY'
                ]);
                return;
            }
            
            // 根据模型选择API地址
            switch ($task->model) {
                case self::MODEL_NANO_BANANA_2:
                    $apiUrl = 'https://api.wuyinkeji.com/api/async/image_nanoBanana2';
                    break;
                case self::MODEL_NANO_BANANA_PRO:
                    $apiUrl = 'https://api.wuyinkeji.com/api/async/image_nanoBanana_pro';
                    break;
                case self::MODEL_GPT_IMAGE_2:
                    $apiUrl = 'https://api.wuyinkeji.com/api/async/image_gpt';
                    break;
                default:
                    $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                        'error_message' => '不支持的模型类型: ' . $task->model
                    ]);
                    logDB('generate', 'error', '模型类型错误', ['task_id' => $task->task_id, 'model' => $task->model]);
                    return;
            }
            
            // 构建API请求参数
            $apiParams = [
                'key' => $apiKey,
                'prompt' => $task->prompt,
            ];

            if ($task->model == self::MODEL_GPT_IMAGE_2) {
                // 该模型下,size需设置为9:16类似的数值,请根据如下比例反推
                $apiParams['size'] = $this->getRatioFromSize($task->width, $task->height);
            }else {
                // 尺寸参数（根据宽高判断）
                $area = $task->width * $task->height;
                if ($area >= 1024*1024 && $area < 2048*2048) {
                    $apiParams['size'] = '1k';
                } elseif ($area >= 2048*2048) {
                    $apiParams['size'] = '2k';
                } else {
                    $apiParams['size'] = '1k'; // 默认1k
                }
                
                // 画面比例
                if ($task->width && $task->height) {
                    $ratio = $task->width . ':' . $task->height;
                    // 简化比例
                    $gcd = $this->gcd($task->width, $task->height);
                    $ratio = ($task->width / $gcd) . ':' . ($task->height / $gcd);
                    $apiParams['aspectRatio'] = $ratio;
                }
            }
            
            // 参考图片
            if ($task->ref_img_url) {
                $apiParams['urls'] = is_array($task->ref_img_url) ? $task->ref_img_url : [$task->ref_img_url];
            }

            dLog('generate')->info('NanoBanana API参数: ', $apiParams);
            logDB('generate', 'info', 'NanoBanana任务提交', ['task_id' => $task->task_id, 'model' => $task->model, 'params' => $apiParams]);
            
            // 调用NanoBanana API
            $response = $this->httpClient->post($apiUrl, [
                'query' => ['key' => $apiKey],
                'json' => $apiParams,
            ]);
    
            $responseData = json_decode($response->getBody()->getContents(), true);
            dLog('generate')->info('NanoBanana API响应: ', $responseData);
            logDB('generate', 'info', 'NanoBanana API响应', ['task_id' => $task->task_id, 'response' => $responseData]);
                
            if ($responseData['code'] !== 200) {
                // API返回错误
                logDB('generate', 'error', 'NanoBanana任务提交失败', ['task_id' => $task->task_id, 'error' => $responseData['msg'] ?? 'API Error']);
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => $responseData['msg'] ?? 'API Error',
                    'extra_params' => $responseData
                ]);
            } else {
                // 任务提交成功，更新状态为处理中
                $updateData = [];
                // 存储API返回的任务ID
                if (isset($responseData['data']['id'])) {
                    $updateData['task_id'] = $responseData['data']['id'];
                    $updateData['extra_params'] = $responseData;
                }
    
                $task->updateStatus(MpGeneratePicTask::STATUS_PROCESSING, $updateData);
            }
        } catch (\Exception $e) {
            // 记录错误
            logDB('generate', 'error', 'NanoBanana任务提交异常', ['task_id' => $task->task_id, 'error' => $e->getMessage()]);
            $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                'error_message' => 'API请求失败: ' . $e->getMessage()
            ]);
        }
    }

    /**
     * 查询NanoBanana任务状态
     *
     * @param MpGeneratePicTask $task
     * @return array
     */
    private function queryNanoBananaTaskStatus(MpGeneratePicTask $task): array
    {
        try {
            // 获取API任务ID
            $apiTaskId = $task->task_id ?? null;
            $apiKey = env('NANO_BANANA_API_KEY');
                
            if (!$apiTaskId) {
                return [
                    'status' => 'failed',
                    'error_message' => 'API任务ID不存在',
                    'result_url' => null
                ];
            }
            
            if (empty($apiKey)) {
                return [
                    'status' => 'failed',
                    'error_message' => 'NanoBanana API KEY未配置',
                    'result_url' => null
                ];
            }
    
            // 调用统一查询接口
            $response = $this->httpClient->get('https://api.wuyinkeji.com/api/async/detail', [
                'query' => [
                    'key' => $apiKey,
                    'id' => $apiTaskId
                ]
            ]);
    
            $responseData = json_decode($response->getBody()->getContents(), true);
            dLog('generate')->info('NanoBanana任务状态查询响应: ', $responseData);
            logDB('generate', 'info', 'NanoBanana任务状态查询', ['task_id' => $apiTaskId, 'response' => $responseData]);
    
            if ($responseData['code'] !== 200) {
                // API返回错误
                logDB('generate', 'error', 'NanoBanana任务状态查询失败', ['task_id' => $apiTaskId, 'error' => $responseData['msg'] ?? 'API Error']);
                return [
                    'status' => 'failed',
                    'error_message' => $responseData['msg'] ?? 'API Error',
                    'result_url' => null,
                    'result_json' => $responseData
                ];
            }
    
            // 解析API响应
            $data = $responseData['data'] ?? [];
            $taskStatus = $data['status'] ?? 0;
    
            $returnData = [
                'status' => 'processing',
                'error_message' => null,
                'result_url' => null,
                'result_json' => $responseData
            ];
    
            // status: 2表示成功
            if ($taskStatus === 2 && isset($data['result']) && !empty($data['result'])) {
                $result_urls = [];
                foreach ($data['result'] as $url) {
                    $pic_name = 'ai_generation_nanobanana_' . time() . '_' . uniqid();
                    $pic_ext = getImgExtFromUrl($url);
                    $pic_name = $pic_name . $pic_ext;
                    
                    if ($pic_ext === '.png') {
                        $comporessed_data = compressRemoteImageUrlToSize($url);
                        $url = uploadStreamByTos('image', $comporessed_data, $pic_name);
                    } else {
                        // 将图片另存到tos
                        $url = uploadStreamByTos('image', file_get_contents($url), $pic_name);
                    }
                    
                    $result_urls[] = $url;
                }
                $returnData['result_url'] = $result_urls;
                $returnData['status'] = 'success';
            } elseif ($taskStatus === 3) {
                // status: 3表示失败
                $returnData['status'] = 'failed';
                $returnData['error_message'] = $data['message'] ?? '任务执行失败';
            }
            // status: 0或1表示处理中，保持processing状态
    
            return $returnData;
        } catch (\Exception $e) {
            return [
                'status' => 'failed',
                'error_message' => $e->getMessage(),
                'result_url' => null
            ];
        }
    }

    /**
     * 计算最大公约数（用于简化比例）
     *
     * @param int $a
     * @param int $b
     * @return int
     */
    private function gcd(int $a, int $b): int
    {
        while ($b != 0) {
            $temp = $b;
            $b = $a % $b;
            $a = $temp;
        }
        return $a;
    }

    /**
     * 创建素材
     *
     * @param array $params
     * @return array
     */
    public function createAsset(array $params): array
    {
        try {
            // 验证必填参数
            if (empty($params['url'])) {
                return [
                    'code' => 1,
                    'msg' => '素材URL不能为空',
                    'data' => null
                ];
            }

            // 先获取表中是否已有该url
            $asset = DB::table('mp_assets')->where('url', $params['url'])->first();
            if ($asset) {
                return [
                    'code' => 0,
                    'msg' => '创建成功',
                    'data' => [
                        'id' => $asset->id,
                        'asset_id' => $asset->asset_id,
                        'group_id' => $asset->group_id,
                        'group_name' => $asset->group_name,
                    ]
                ];
            }

            // 获取API配置
            $apiKey = env('ZHIZHEN_AI_SK');
            $apiUrl = 'https://model-relay.zzengine.net';
            
            if (empty($apiKey)) {
                return [
                    'code' => 1002,
                    'msg' => '智真AI API KEY未配置，请检查环境变量ZHIZHEN_AI_SK',
                    'data' => null
                ];
            }

            // 构建请求参数
            $requestData = [
                'url' => $params['url'],
                'asset_type' => $params['asset_type'] ?? MpAsset::TYPE_IMAGE,
            ];

            // 可选参数
            if (!empty($params['name'])) {
                $requestData['name'] = $params['name'];
            }
            if (!empty($params['group_id'])) {
                $requestData['group_id'] = $params['group_id'];
            }

            dLog('generate')->info('智真AI创建素材请求参数: ', $requestData);

            // 调用智真AI API
            $response = $this->httpClient->post($apiUrl . '/api/v1/asset/create', [
                'headers' => [
                    'X-Api-Key' => $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => $requestData,
            ]);

            $responseData = json_decode($response->getBody()->getContents(), true);
            dLog('generate')->info('智真AI创建素材响应: ', $responseData);
            logDB('generate', 'info', '智真AI创建素材', ['params' => $requestData, 'response' => $responseData]);

            if ($responseData['code'] !== 0) {
                return [
                    'code' => $responseData['code'],
                    'msg' => $responseData['msg'] ?? '创建素材失败',
                    'data' => null
                ];
            }

            // 保存素材记录到数据库
            $assetData = $responseData['data'] ?? [];
            $asset = MpAsset::create([
                'asset_id' => $assetData['asset_id'] ?? '',
                'group_id' => $assetData['group_id'] ?? null,
                'group_name' => $assetData['group_name'] ?? null,
                'name' => $params['name'] ?? null,
                'url' => $params['url'],
                'asset_type' => $params['asset_type'] ?? MpAsset::TYPE_IMAGE,
                'status' => MpAsset::STATUS_PROCESSING,
                'extra_params' => $responseData,
            ]);

            return [
                'code' => 0,
                'msg' => '创建成功',
                'data' => [
                    'id' => $asset->id,
                    'asset_id' => $asset->asset_id,
                    'group_id' => $asset->group_id,
                    'group_name' => $asset->group_name,
                ]
            ];

        } catch (\Exception $e) {
            dLog('generate')->error('创建素材异常: ' . $e->getMessage());
            logDB('generate', 'error', '创建素材异常', ['params' => $params, 'error' => $e->getMessage()]);
            
            return [
                'code' => 20003,
                'msg' => '创建素材失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 查询素材
     *
     * @param string $assetId
     * @return array
     */
    public function getAsset(string $assetId): array
    {
        try {
            // 验证参数
            if (empty($assetId)) {
                return [
                    'code' => 20003,
                    'msg' => '素材ID不能为空',
                    'data' => null
                ];
            }

            // 先获取表中是否已有该url
            $assetInfo = DB::table('mp_assets')->where('asset_id', $assetId)->first();
            if ($assetInfo) {
                $assetInfo = (array)$assetInfo;
                $status = getProp($assetInfo, 'status');
                if (in_array($status, ['Active', 'Failed'])) {
                    $assetInfo['id'] = $assetInfo['asset_id'];
                    return [
                        'code' => 0,
                        'msg' => '查询成功',
                        'data' => [
                            'asset' => $assetInfo
                        ]
                    ];
                }
            }

            // 获取API配置
            $apiKey = env('ZHIZHEN_AI_SK');
            $apiUrl = 'https://model-relay.zzengine.net';
            
            if (empty($apiKey)) {
                return [
                    'code' => 1002,
                    'msg' => '智真AI API KEY未配置，请检查环境变量ZHIZHEN_AI_SK',
                    'data' => null
                ];
            }

            dLog('generate')->info('智真AI查询素材: ' . $assetId);

            // 调用智真AI API
            $response = $this->httpClient->post($apiUrl . '/api/v1/asset/get', [
                'headers' => [
                    'X-Api-Key' => $apiKey,
                    'Content-Type' => 'application/json',
                ],
                'json' => [
                    'asset_id' => $assetId,
                ],
            ]);

            $responseData = json_decode($response->getBody()->getContents(), true);
            dLog('generate')->info('智真AI查询素材响应: ', $responseData);
            logDB('generate', 'info', '智真AI查询素材', ['asset_id' => $assetId, 'response' => $responseData]);

            if ($responseData['code'] !== 0) {
                return [
                    'code' => $responseData['code'],
                    'msg' => $responseData['msg'] ?? '查询素材失败',
                    'data' => null
                ];
            }

            $assetInfo = $responseData['data']['asset'] ?? [];

            // 更新本地数据库记录
            $localAsset = MpAsset::where('asset_id', $assetId)->first();
            if ($localAsset) {
                $localAsset->update([
                    'status' => $assetInfo['status'] ?? MpAsset::STATUS_PROCESSING,
                    'cover_url' => $assetInfo['url'] ?? null,
                    'extra_params' => $responseData,
                ]);
            }

            return [
                'code' => 0,
                'msg' => '查询成功',
                'data' => [
                    'asset' => $assetInfo
                ]
            ];

        } catch (\Exception $e) {
            dLog('generate')->error('查询素材异常: ' . $e->getMessage());
            logDB('generate', 'error', '查询素材异常', ['asset_id' => $assetId, 'error' => $e->getMessage()]);
            
            return [
                'code' => 20003,
                'msg' => '查询素材失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 更新所有待处理任务的状态
     *
     * @return void
     */
    public function updatePendingTasks(): void
    {
        dLog('generate')->info('更新图片状态ing');
        
        // 1. 处理火山API的pending任务（批量提交到队列）
        $volcPendingTasks = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PENDING)
            ->whereIn('model', BaseConst::VOLC_PIC_MODELS)
            ->orderBy('created_at', 'asc')
            ->limit(50) // 每次最多处理50个任务，避免超时
            ->get();

        foreach ($volcPendingTasks as $task) {
            dLog('generate')->info('开始分发火山API任务到队列: ' . $task->task_id);
            
            // 分发到队列
            \App\Jobs\ProcessVolcImageGenerationJob::dispatch($task->id)->onConnection('redis');
        }
        
        // 2. 处理GPT-Image2的pending任务（批量提交到队列）
        $gptImage2PendingTasks = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PENDING)
            ->whereIn('model', BaseConst::GPT_IMAGE2_MODELS)
            ->orderBy('created_at', 'asc')
            ->limit(50) // 每次最多处理50个任务，避免超时
            ->get();

        foreach ($gptImage2PendingTasks as $task) {
            dLog('generate')->info('开始分发GPT-Image2任务到队列: ' . $task->task_id);
            
            // 分发到队列
            \App\Jobs\ProcessGptImage2GenerationJob::dispatch($task->id)->onConnection('redis');
        }
        
        // 3. 获取所有处理中的任务（即梦AI和NanoBanana系列需要查询状态）
        $processingTasks = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PROCESSING)
            ->whereIn('model', array_merge([self::MODEL_JIMENG_4], BaseConst::NANO_BANANA_MODELS))
            ->get();

        foreach ($processingTasks as $task) {
            $statusInfo = $this->queryTaskStatus($task);

            if ($statusInfo['status'] === 'success') {
                logDB('generate', 'info', '即梦AI图片生成任务成功', ['task_id' => $task->task_id, 'result_url' => $statusInfo['result_url']]);
                $task->updateStatus(MpGeneratePicTask::STATUS_SUCCESS, [
                    'result_url'    => $statusInfo['result_url'],
                    'result_json'   => $statusInfo['result_json'] ?? []
                ]);

                // 同步调整分镜图片状态和结果
                $segment_id = getProp($task, 'alias_segment_id');
                if ($segment_id) {
                    DB::table('mp_episode_segments')->where('segment_id', getProp($task, 'alias_segment_id'))->update([
                        'img_url'   => $statusInfo['result_url'][0],
                        'pic_task_status'   => '已完成',
                    ]);
                    
                    // 如果是首帧图ID则更新anime表
                    if (Redis::sismember('anime_first_frame_urls', $segment_id)) {
                        $anime_id = DB::table('mp_episode_segments')->where('segment_id', $segment_id)->value('anime_id');
                        DB::table('mp_animes')->where('id', $anime_id)->update(['first_frame_url'=>$statusInfo['result_url'][0], 'updated_at'=>date('Y-m-d H:i:s')]);
                        Redis::srem('anime_first_frame_urls', $segment_id);
                    }
                }
            } elseif ($statusInfo['status'] === 'failed') {
                logDB('generate', 'error', '即梦AI图片生成任务失败', ['task_id' => $task->task_id, 'error' => $statusInfo['error_message']]);
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => $statusInfo['error_message'],
                    'result_json'   => $statusInfo['result_json'] ?? []
                ]);

                if (getProp($task, 'alias_segment_id')) {
                    DB::table('mp_episode_segments')->where('segment_id', getProp($task, 'alias_segment_id'))->update([
                        'pic_task_status'   => '失败',
                    ]);
                }
            }
            // 如果仍然是处理中状态，不做任何操作
            
            //处理：如果任务处理超过12小时，标记为失败
            $processingTime = now()->diffInHours($task->created_at);
            if ($processingTime > 12) {
                logDB('generate', 'warning', '即梦AI图片生成任务超时', ['task_id' => $task->task_id, 'processing_hours' => $processingTime]);
                $task->updateStatus(MpGeneratePicTask::STATUS_FAILED, [
                    'error_message' => '任务处理超时（超过12小时）'
                ]);
            }
        }

        // 4. 检查是否有任务完成，如果有则处理下一个排队任务（仅即梦AI）
        $this->processNextQueuedTask();
    }

    /**
     * 处理下一个排队的任务
     *
     * @return void
     */
    public function processNextQueuedTask(): void
    {
        // 检查是否还有正在处理的任务（仅即梦AI）
        if ($this->hasProcessingTask()) {
            return; // 如果还有处理中的任务，不处理新任务
        }

        // 获取最早的待处理任务（仅即梦AI）
        $nextTask = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PENDING)
            ->where('model', self::MODEL_JIMENG_4)
            ->orderBy('created_at', 'asc')
            ->first();

        if ($nextTask) {
            dLog('generate')->info('开始处理排队任务: ' . $nextTask->task_id);
            logDB('generate', 'info', '开始处理即梦AI排队任务', ['task_id' => $nextTask->task_id]);
            $this->submitTaskToJimengApi($nextTask);
        }
    }

    /**
     * 获取任务队列状态
     *
     * @return array
     */
    public function getQueueStatus(): array
    {
        $processingCount = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PROCESSING)->count();
        $pendingCount = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PENDING)->count();
        
        return [
            'processing_count' => $processingCount,
            'pending_count' => $pendingCount,
            'can_submit_new_task' => $processingCount === 0
        ];
    }

    /**
     * 处理智真AI的参考图片转素材
     *
     * @param array $referenceImages 参考图片URL数组
     * @param string &$fullPrompt 完整提示词（引用传递，用于删除失败图片的标记）
     * @return array 返回素材ID数组
     */
    public function processReferenceImagesToAssets(array $referenceImages, string &$fullPrompt): array
    {
        $assetIds = [];
        $failedIndexes = []; // 记录失败的图片序号
        
        foreach ($referenceImages as $index => $imageUrl) {
            $imageIndex = $index + 1; // 图片序号从1开始
            
            try {
                dLog('generate')->info("开始处理参考图片 {$imageIndex}: {$imageUrl}");
                
                // 1. 创建素材
                $createResult = $this->createAsset([
                    'url' => $imageUrl,
                    'asset_type' => MpAsset::TYPE_IMAGE,
                    'name' => "参考图片_{$imageIndex}_" . time(),
                ]);
                
                if ($createResult['code'] !== 0) {
                    dLog('generate')->warning("图片 {$imageIndex} 创建素材失败: " . $createResult['msg']);
                    logDB('generate', 'warning', '创建素材失败', [
                        'image_url' => $imageUrl,
                        'index' => $imageIndex,
                        'error' => $createResult['msg']
                    ]);
                    $failedIndexes[] = $imageIndex;
                    continue;
                }
                
                $assetId = $createResult['data']['asset_id'];
                dLog('generate')->info("图片 {$imageIndex} 素材创建成功，asset_id: {$assetId}，开始轮询查询状态");
                
                // 2. 轮询查询素材状态（每3秒查询一次，最多查询100次即5分钟）
                $maxAttempts = 100;
                $attempt = 0;
                $assetStatus = null;
                
                while ($attempt < $maxAttempts) {
                    sleep(3); // 等待3秒
                    $attempt++;
                    
                    $getResult = $this->getAsset($assetId);
                    
                    if ($getResult['code'] !== 0) {
                        dLog('generate')->warning("图片 {$imageIndex} 查询素材状态失败: " . $getResult['msg']);
                        continue;
                    }
                    
                    $assetStatus = $getResult['data']['asset']['status'] ?? null;
                    dLog('generate')->info("图片 {$imageIndex} 素材状态查询第 {$attempt} 次，状态: {$assetStatus}");
                    
                    if ($assetStatus === 'Active') {
                        // 素材可用
                        $assetIds[] = $assetId;
                        dLog('generate')->info("图片 {$imageIndex} 素材处理成功，asset_id: {$assetId}");
                        logDB('generate', 'info', '素材转换成功', [
                            'image_url' => $imageUrl,
                            'index' => $imageIndex,
                            'asset_id' => $assetId
                        ]);
                        break;
                    } elseif ($assetStatus === 'Failed') {
                        // 素材处理失败
                        dLog('generate')->warning("图片 {$imageIndex} 素材处理失败");
                        logDB('generate', 'warning', '素材处理失败', [
                            'image_url' => $imageUrl,
                            'index' => $imageIndex,
                            'asset_id' => $assetId
                        ]);
                        $failedIndexes[] = $imageIndex;
                        break;
                    }
                    // 其他状态（Processing等）继续等待
                }
                
                // 如果超时还未成功
                if ($attempt >= $maxAttempts && $assetStatus !== 'Active') {
                    dLog('generate')->warning("图片 {$imageIndex} 素材处理超时");
                    logDB('generate', 'warning', '素材处理超时', [
                        'image_url' => $imageUrl,
                        'index' => $imageIndex,
                        'asset_id' => $assetId,
                        'last_status' => $assetStatus
                    ]);
                    $failedIndexes[] = $imageIndex;
                }
                
            } catch (\Exception $e) {
                dLog('generate')->error("图片 {$imageIndex} 处理异常: " . $e->getMessage());
                logDB('generate', 'error', '素材转换异常', [
                    'image_url' => $imageUrl,
                    'index' => $imageIndex,
                    'error' => $e->getMessage()
                ]);
                $failedIndexes[] = $imageIndex;
            }
        }
        
        // 处理失败的图片：从 fullPrompt 中删除对应的标记并调整序号
        if (!empty($failedIndexes)) {
            dLog('generate')->info('开始处理失败图片的提示词调整，失败序号: ' . implode(',', $failedIndexes));
            
            // 按序号从大到小排序，避免删除时影响后续序号
            rsort($failedIndexes);
            
            foreach ($failedIndexes as $failedIndex) {
                // 删除失败图片的标记，例如 <图片1>、<图片2> 等
                $pattern = "/<图片{$failedIndex}>/u";
                $fullPrompt = preg_replace($pattern, '', $fullPrompt);
                dLog('generate')->info("已从提示词中删除 <图片{$failedIndex}>");
            }
            
            // 重新调整剩余图片的序号
            // 例如：如果图片2失败，图片3、图片4需要改为图片2、图片3
            $needAdjust = false;
            foreach ($failedIndexes as $failedIndex) {
                $needAdjust = true;
                // 将所有大于失败序号的图片标记序号减1
                for ($i = $failedIndex + 1; $i <= count($referenceImages); $i++) {
                    $oldPattern = "/<图片{$i}>/u";
                    $newTag = "<图片" . ($i - 1) . ">";
                    $fullPrompt = preg_replace($oldPattern, $newTag, $fullPrompt);
                }
            }
            
            if ($needAdjust) {
                dLog('generate')->info('提示词图片序号调整完成');
                logDB('generate', 'info', '提示词调整', [
                    'failed_indexes' => $failedIndexes,
                    'adjusted_prompt' => $fullPrompt
                ]);
            }
        }
        
        dLog('generate')->info('参考图片转素材完成，成功数量: ' . count($assetIds) . '，失败数量: ' . count($failedIndexes));

        // 格式化为可直接在API接口中使用的数组
        foreach($assetIds as &$assetId) {
            $assetId = "asset://{$assetId}";
        }
        
        return $assetIds;
    }

    /**
     * 根据宽高反推图片比例
     * @param int $width 宽度
     * @param int $height 高度
     * @return string 比例字符串，如 "9:16"，匹配不到则返回 "auto"
     */
    private function getRatioFromSize($width, $height)
    {
        if (!$width || !$height) {
            return 'auto';
        }

        // 遍历所有预定义的比例，查找匹配的
        foreach (BaseConst::IMAGE_RATIOS as $ratio => $size) {
            if ($size['width'] == $width && $size['height'] == $height) {
                return $ratio;
            }
        }

        // 没有精确匹配，尝试通过计算比例匹配
        $gcd = $this->gcd($width, $height);
        $simplifiedRatio = ($width / $gcd) . ':' . ($height / $gcd);

        // 检查简化后的比例是否在预定义列表中
        if (isset(BaseConst::IMAGE_RATIOS[$simplifiedRatio])) {
            return $simplifiedRatio;
        }

        return 'auto';
    }

    /**
     * 压缩图片流（针对PNG格式）
     *
     * @param string $imageStream 图片二进制数据
     * @param int $maxBytes 最大字节数（默认3MB）
     * @return string|null 压缩后的图片二进制数据，失败时返回原数据
     */
    private function compressImageStream(string $imageStream, int $maxBytes = 3 * 1024 * 1024): ?string
    {
        try {
            // 检查图片类型
            $imgInfo = @getimagesizefromstring($imageStream);
            if (!$imgInfo) {
                dLog('generate')->warning('无法识别图片类型，返回原始数据');
                return $imageStream;
            }

            $mime = $imgInfo['mime'] ?? '';
            
            // 只处理PNG，JPEG不做有损压缩
            if ($mime === 'image/jpeg') {
                return $imageStream;
            }

            // 如果已经小于最大限制，直接返回
            if (strlen($imageStream) <= $maxBytes) {
                return $imageStream;
            }

            // 载入图像对象
            $srcImg = @imagecreatefromstring($imageStream);
            if (!$srcImg) {
                dLog('generate')->warning('无法创建图像资源，返回原始数据');
                return $imageStream;
            }

            $origW = imagesx($srcImg);
            $origH = imagesy($srcImg);

            // 逐步降低质量直到满足大小要求
            $quality = 9; // PNG压缩等级 0-9
            $scaleFactor = 1.0;
            $maxAttempts = 10;
            $attempt = 0;
            $compressedData = null;

            while ($attempt < $maxAttempts) {
                $attempt++;

                // 如果需要缩放
                if ($scaleFactor < 1.0) {
                    $newW = (int)($origW * $scaleFactor);
                    $newH = (int)($origH * $scaleFactor);
                    $resizedImg = imagecreatetruecolor($newW, $newH);
                    
                    // 保持透明度
                    imagealphablending($resizedImg, false);
                    imagesavealpha($resizedImg, true);
                    
                    imagecopyresampled($resizedImg, $srcImg, 0, 0, 0, 0, $newW, $newH, $origW, $origH);
                    $targetImg = $resizedImg;
                } else {
                    $targetImg = $srcImg;
                }

                // 输出到内存
                ob_start();
                imagepng($targetImg, null, $quality);
                $compressedData = ob_get_clean();

                if ($scaleFactor < 1.0) {
                    imagedestroy($targetImg);
                }

                // 检查大小
                $size = strlen($compressedData);
                dLog('generate')->info('图片压缩尝试', [
                    'attempt' => $attempt,
                    'quality' => $quality,
                    'scale' => $scaleFactor,
                    'size' => $size,
                    'target' => $maxBytes
                ]);

                if ($size <= $maxBytes) {
                    break;
                }

                // 调整参数
                if ($quality > 0) {
                    $quality--;
                } else {
                    $scaleFactor *= 0.9; // 每次缩小10%
                }
            }

            imagedestroy($srcImg);
            
            return $compressedData ?: $imageStream;

        } catch (\Exception $e) {
            dLog('generate')->error('图片压缩失败', ['error' => $e->getMessage()]);
            return $imageStream;
        }
    }
}