<?php

namespace App\Services\AIGeneration;

use App\Facade\Site;
use App\Consts\BaseConst;
use App\Models\MpGeneratePicTask;
use App\Models\MpAsset;
use App\Services\PointsService;
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;

class AIImageGenerationService
{
    private $volcEngineService;
    private $httpClient;
    /** @var PointsService */
    private $pointsService;

    // 模型常量
    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';

    // 队列派发去重相关常量
    /** 派发锁在 Redis 中的 key 前缀 */
    const DISPATCH_LOCK_PREFIX = 'ai_pic_dispatch:';
    /** 派发锁使用的 Redis 连接，与队列保持一致 */
    const DISPATCH_LOCK_CONNECTION = 'default';
    /** 派发锁有效期（秒）：worker 长时间未消费时的兜底重派时间 */
    const DISPATCH_LOCK_TTL = 600;
    /** 每轮最多派发的任务数，避免一次性推送过多任务 */
    const DISPATCH_BATCH_LIMIT = 50;
    /** 每轮扫描的候选任务数，需大于 DISPATCH_BATCH_LIMIT，避免已入队的任务挡住后面的任务 */
    const DISPATCH_CANDIDATE_LIMIT = 500;
    /** 派发锁分组：火山API */
    const DISPATCH_GROUP_VOLC = 'volc_pics';
    /** 派发锁分组：GPT-Image2 */
    const DISPATCH_GROUP_GPT_IMAGE2 = 'gpt_image2_pics';

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

    /**
     * 构建图片任务计费信息
     *
     * @param array $params
     * @param string $model
     * @return array
     */
    private function buildImageChargeInfo(array $params, string $model): array
    {
        $uid = 0;
        try {
            $uid = (int)Site::getUid();
        } catch (\Throwable $e) {
            // 非请求上下文（如命令行）下可能无法获取用户ID，置为0
        }

        $width = (int)getProp($params, 'width', 1600);
        $height = (int)getProp($params, 'height', 2848);

        return [
            'user_id' => $uid,
            'model' => $model,
            'width' => $width,
            'height' => $height,
            'resolution' => $this->pointsService->normalizeImageResolutionKey($width, $height),
            'image_num' => (int)getProp($params, 'image_num', 1),
            'source' => !empty($params['alias_segment_id']) ? 'segment' : (!empty($params['alias_act_id']) ? 'act' : ''),
            'alias_segment_id' => $params['alias_segment_id'] ?? '',
            'created_at' => date('Y-m-d H:i:s'),
        ];
    }

    /**
     * 图片生成余额预检
     *
     * 有用户上下文时校验本次生成所需积分（单价 × 生成张数），不足直接抛错；
     * 后台命令/队列等无用户上下文的场景跳过预检。
     *
     * @param array $chargeInfo
     * @return void
     */
    private function preCheckImageBalance(array $chargeInfo): void
    {
        $uid = (int)($chargeInfo['user_id'] ?? 0);
        if (!$uid) {
            return;
        }

        $imageNum = (int)($chargeInfo['image_num'] ?? 1);
        if ($imageNum <= 0) {
            $imageNum = 1;
        }

        $needPoints = $this->pointsService->getImageChargePoints($chargeInfo) * $imageNum;
        if ($needPoints <= 0) {
            return;
        }

        $this->pointsService->checkUserPointsEnough($needPoints, $uid);
    }

    /**
     * 图片生成成功统一处理（事务保证原子性）
     *
     * 在同一事务内完成：任务状态更新 + 积分计费 + 分镜表同步；
     * 任一步失败整体回滚，任务保持原状态，由后续定时任务/超时重置重试。
     *
     * @param MpGeneratePicTask $task
     * @param array $resultUrls
     * @param array $resultJson
     * @return void
     */
    private function handleImageTaskSuccess(MpGeneratePicTask $task, array $resultUrls, array $resultJson): void
    {
        try {
            DB::beginTransaction();

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

            // 记录计费明细并扣减用户积分（真实失败则抛错回滚，避免“成功但未计费”）
            $chargeResult = $this->pointsService->recordImageTaskCharge($task);
            if (empty($chargeResult['charged'])
                && !in_array((string)($chargeResult['reason'] ?? ''), ['already_charged', 'no_charge_info'], true)) {
                throw new \Exception('图片计费失败: ' . (string)($chargeResult['reason'] ?? 'unknown'));
            }

            // 同步调整分镜图片状态和结果
            $segmentId = getProp($task, 'alias_segment_id');
            if ($segmentId) {
                $updateSegmentResult = DB::table('mp_episode_segments')->where('segment_id', $segmentId)->update([
                    'img_url' => $resultUrls[0],
                    'pic_task_status' => '已完成',
                ]);
                // 本应更新却未更新到（分镜被删除等），抛错触发整体回滚重试
                if ($updateSegmentResult === false || $updateSegmentResult === 0) {
                    throw new \Exception('更新分镜图片状态失败: 未找到对应的分镜记录');
                }

                // 如果是首帧图ID则更新anime表
                if (Redis::sismember('anime_first_frame_urls', $segmentId)) {
                    $animeId = DB::table('mp_episode_segments')->where('segment_id', $segmentId)->value('anime_id');
                    DB::table('mp_animes')->where('id', $animeId)->update(['first_frame_url' => $resultUrls[0], 'updated_at' => date('Y-m-d H:i:s')]);
                    Redis::srem('anime_first_frame_urls', $segmentId);
                }
            }

            DB::commit();

        } catch (\Exception $e) {
            DB::rollBack();
            dLog('generate')->error('图片任务成功处理失败，已回滚: ' . $e->getMessage(), ['task_id' => $task->id]);
            logDB('generate', 'error', '图片任务成功处理失败，已回滚', [
                'task_id' => $task->id,
                'error' => $e->getMessage(),
            ]);
        }
    }

    /**
     * 异步创建图片生成任务
     *
     * @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'] ?? 'gpt-image-2';

        // 构建计费信息并余额预检（不足直接报错）
        $chargeInfo = $this->buildImageChargeInfo($params, $model);
        $this->preCheckImageBalance($chargeInfo);
        
        // 检查是否有正在处理的任务（仅即梦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,
            'charge_info' => $chargeInfo,
        ]);

        // 即梦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;

        // 构建计费信息并余额预检（不足直接报错）
        $chargeInfo = $this->buildImageChargeInfo($params, $model);
        $this->preCheckImageBalance($chargeInfo);

        // 创建排队状态的任务记录
        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,
            'charge_info' => $chargeInfo,
        ]);
    }

    /**
     * 提交任务到即梦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());
            }
            
            // 移除 b64_json 字段用于日志记录，避免生成超大日志
            $logResponseData = $this->removeB64JsonFromResponse($responseData);
            dLog('generate')->info('GPT-Image2 API响应', $logResponseData);
            logDB('generate', 'info', 'GPT-Image2 API响应', ['task_id' => $task->task_id, 'response' => $logResponseData]);
                
            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' => $logResponseData
                ]);
            } 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); // 解除引用
            }

            // 图片生成成功统一处理（事务：状态更新 + 计费 + 分镜同步）
            $this->handleImageTaskSuccess($task, $result_urls, $cleanedResponseData);
        } 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;
                }
            }

            // 生成多图或者单图
            $imageNum = (int)$task->image_num;
            if ($imageNum === 1) {
                $apiParams['sequential_image_generation'] = 'disabled';
            }else if ($imageNum > 1) {
                // 组图模式下由模型决定实际生成张数，这里在提示词末尾明确要求生成对应数量，并将组图上限设置为目标张数
                $apiParams['prompt'] = rtrim((string)$task->prompt) . "\n生成{$imageNum}张图片";
                $apiParams['sequential_image_generation'] = 'auto';
                $apiParams['sequential_image_generation_options']['max_images'] = $imageNum;
            }

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

            // 图片生成成功统一处理（事务：状态更新 + 计费 + 分镜同步）
            $this->handleImageTaskSuccess($task, $result_urls, $responseData);
        } 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（仅限智帧AI来源的素材）
            $asset = DB::table('mp_assets')->where('url', $params['url'])->where('source_type', 'zhizhen')->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,
                'source_type' => 'zhizhen',
                '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
                ];
            }

            // 先获取表中是否已有该素材（仅限智帧AI来源的素材）
            $assetInfo = DB::table('mp_assets')->where('asset_id', $assetId)->where('source_type', 'zhizhen')->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(self::DISPATCH_CANDIDATE_LIMIT) // 候选窗口需大于每轮派发上限，避免已入队的任务挡住后面的任务
            ->get();

        $volcDispatched = 0;
        foreach ($volcPendingTasks as $task) {
            if ($volcDispatched >= self::DISPATCH_BATCH_LIMIT) {
                break;
            }

            // 同一任务已在队列中或正在执行时跳过，避免重复入队
            if (!$this->dispatchTaskOnce(self::DISPATCH_GROUP_VOLC, (int)$task->id, \App\Jobs\ProcessVolcImageGenerationJob::class)) {
                continue;
            }

            dLog('generate')->info('开始分发火山API任务到队列: ' . $task->task_id);
            $volcDispatched++;
        }
        
        // 2. 处理GPT-Image2的pending任务（批量提交到队列）
        $gptImage2PendingTasks = MpGeneratePicTask::where('status', MpGeneratePicTask::STATUS_PENDING)
            ->whereIn('model', BaseConst::GPT_IMAGE2_MODELS)
            ->orderBy('created_at', 'asc')
            ->limit(self::DISPATCH_CANDIDATE_LIMIT) // 候选窗口需大于每轮派发上限，避免已入队的任务挡住后面的任务
            ->get();

        $gptImage2Dispatched = 0;
        foreach ($gptImage2PendingTasks as $task) {
            if ($gptImage2Dispatched >= self::DISPATCH_BATCH_LIMIT) {
                break;
            }

            // 同一任务已在队列中或正在执行时跳过，避免重复入队
            if (!$this->dispatchTaskOnce(self::DISPATCH_GROUP_GPT_IMAGE2, (int)$task->id, \App\Jobs\ProcessGptImage2GenerationJob::class)) {
                continue;
            }

            dLog('generate')->info('开始分发GPT-Image2任务到队列: ' . $task->task_id);
            $gptImage2Dispatched++;
        }
        
        // 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']]);

                // 图片生成成功统一处理（事务：状态更新 + 计费 + 分镜同步）
                $this->handleImageTaskSuccess($task, $statusInfo['result_url'], $statusInfo['result_json'] ?? []);
            } 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();
    }

    /**
     * 派发单个任务到队列（带派发去重）
     *
     * 同一任务在「已入队等待执行」或「正在执行」期间不会重复入队，
     * 避免每轮扫描（约3秒一次）把同一条任务重复推送进队列。
     *
     * @param string $group    派发分组，用于区分同一任务ID在不同业务下的锁
     * @param int    $taskId   图片任务ID
     * @param string $jobClass 队列任务类
     * @return bool 本次是否成功入队；false 表示已有同任务的 job 在队列中或执行中
     */
    private function dispatchTaskOnce(string $group, int $taskId, string $jobClass): bool
    {
        if (!self::acquireTaskDispatchLock($group, $taskId)) {
            return false;
        }

        try {
            $jobClass::dispatch($taskId)->onConnection('redis');
        } catch (\Throwable $e) {
            // 入队失败必须释放锁，否则该任务在锁过期前无法再次派发
            self::releaseTaskDispatchLock($group, $taskId);
            throw $e;
        }

        return true;
    }

    /**
     * 获取任务派发锁
     *
     * 在队列所在的 Redis 连接上执行原生 `SET key value EX ttl NX` 原子命令，
     * 不依赖 Lua 脚本（部分 Redis 会禁用 EVAL）也不需要额外的缓存 store 配置。
     *
     * @param string $group
     * @param int    $taskId
     * @return bool true 表示获取成功（可以入队）
     */
    public static function acquireTaskDispatchLock(string $group, int $taskId): bool
    {
        try {
            $result = Redis::connection(self::DISPATCH_LOCK_CONNECTION)->set(
                self::buildTaskDispatchLockKey($group, $taskId),
                1,
                'EX',
                self::DISPATCH_LOCK_TTL,
                'NX'
            );

            // NX 未命中时：predis 返回 null，phpredis 返回 false
            return $result !== null && $result !== false;
        } catch (\Throwable $e) {
            // 锁不可用时降级为不去重（与旧逻辑一致），避免任务因此完全无法派发
            dLog('generate')->warning('获取图片任务派发锁失败，本次不拦截重复派发', [
                'group'   => $group,
                'task_id' => $taskId,
                'error'   => $e->getMessage(),
            ]);

            return true;
        }
    }

    /**
     * 释放任务派发锁
     *
     * 在任务执行结束、任务已由其它流程处理、任务最终失败时调用；
     * 未释放的锁会在 DISPATCH_LOCK_TTL 后自动过期，保证任务仍能被重新派发。
     *
     * @param string $group
     * @param int    $taskId
     * @return void
     */
    public static function releaseTaskDispatchLock(string $group, int $taskId): void
    {
        try {
            Redis::connection(self::DISPATCH_LOCK_CONNECTION)->del(
                self::buildTaskDispatchLockKey($group, $taskId)
            );
        } catch (\Throwable $e) {
            // 释放失败不影响主流程，锁会由 TTL 自动过期
            dLog('generate')->warning('释放图片任务派发锁失败', [
                'group'   => $group,
                'task_id' => $taskId,
                'error'   => $e->getMessage(),
            ]);
        }
    }

    /**
     * 构建任务派发锁 key
     *
     * @param string $group
     * @param int    $taskId
     * @return string
     */
    public static function buildTaskDispatchLockKey(string $group, int $taskId): string
    {
        return self::DISPATCH_LOCK_PREFIX . $group . ':' . $taskId;
    }

    /**
     * 处理下一个排队的任务
     *
     * @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
    {
        return $this->processReferenceAssetsToZhizhenAssets($referenceImages, MpAsset::TYPE_IMAGE, '图片', '图片', $fullPrompt);
    }

    /**
     * 处理智帧AI的参考视频转素材
     *
     * @param array $referenceVideos 参考视频URL数组
     * @param string &$fullPrompt 完整提示词（引用传递，用于删除失败视频的标记）
     * @return array 返回素材ID数组
     */
    public function processReferenceVideosToAssets(array $referenceVideos, string &$fullPrompt): array
    {
        return $this->processReferenceAssetsToZhizhenAssets($referenceVideos, MpAsset::TYPE_VIDEO, '视频', '视频', $fullPrompt);
    }

    /**
     * 处理智帧AI的参考音频转素材
     *
     * @param array $referenceAudios 参考音频URL数组
     * @param string &$fullPrompt 完整提示词（引用传递，用于删除失败音频的标记）
     * @return array 返回素材ID数组
     */
    public function processReferenceAudiosToAssets(array $referenceAudios, string &$fullPrompt): array
    {
        return $this->processReferenceAssetsToZhizhenAssets($referenceAudios, MpAsset::TYPE_AUDIO, '音频', '音频', $fullPrompt);
    }

    /**
     * 处理智帧AI的参考素材转素材（图片/视频/音频通用方法）
     *
     * @param array $urls 参考素材URL数组
     * @param string $assetType 素材类型（Image/Video/Audio）
     * @param string $label 素材中文名（图片/视频/音频），用于日志与素材命名
     * @param string $tagName 提示词标记名（图片/视频/音频），用于 <{tagName}N> 标记的清理
     * @param string &$fullPrompt 完整提示词（引用传递，用于删除失败素材的标记）
     * @return array 返回素材ID数组（asset://格式）
     */
    private function processReferenceAssetsToZhizhenAssets(array $urls, string $assetType, string $label, string $tagName, string &$fullPrompt): array
    {
        $assetIds = [];
        $failedIndexes = []; // 记录失败的素材序号
        
        foreach ($urls as $index => $url) {
            $mediaIndex = $index + 1; // 素材序号从1开始
            
            try {
                dLog('generate')->info("开始处理参考{$label} {$mediaIndex}: {$url}");
                
                // 1. 创建素材
                $createResult = $this->createAsset([
                    'url' => $url,
                    'asset_type' => $assetType,
                    'name' => "参考{$label}_{$mediaIndex}_" . time(),
                ]);
                
                if ($createResult['code'] !== 0) {
                    dLog('generate')->warning("{$label} {$mediaIndex} 创建素材失败: " . $createResult['msg']);
                    logDB('generate', 'warning', '创建素材失败', [
                        'url' => $url,
                        'asset_type' => $assetType,
                        'index' => $mediaIndex,
                        'error' => $createResult['msg']
                    ]);
                    $failedIndexes[] = $mediaIndex;
                    continue;
                }
                
                $assetId = $createResult['data']['asset_id'];
                dLog('generate')->info("{$label} {$mediaIndex} 素材创建成功，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("{$label} {$mediaIndex} 查询素材状态失败: " . $getResult['msg']);
                        continue;
                    }
                    
                    $assetStatus = $getResult['data']['asset']['status'] ?? null;
                    dLog('generate')->info("{$label} {$mediaIndex} 素材状态查询第 {$attempt} 次，状态: {$assetStatus}");
                    
                    if ($assetStatus === 'Active') {
                        // 素材可用
                        $assetIds[] = $assetId;
                        dLog('generate')->info("{$label} {$mediaIndex} 素材处理成功，asset_id: {$assetId}");
                        logDB('generate', 'info', '素材转换成功', [
                            'url' => $url,
                            'asset_type' => $assetType,
                            'index' => $mediaIndex,
                            'asset_id' => $assetId
                        ]);
                        break;
                    } elseif ($assetStatus === 'Failed') {
                        // 素材处理失败
                        dLog('generate')->warning("{$label} {$mediaIndex} 素材处理失败");
                        logDB('generate', 'warning', '素材处理失败', [
                            'url' => $url,
                            'asset_type' => $assetType,
                            'index' => $mediaIndex,
                            'asset_id' => $assetId
                        ]);
                        $failedIndexes[] = $mediaIndex;
                        break;
                    }
                    // 其他状态（Processing等）继续等待
                }
                
                // 如果超时还未成功
                if ($attempt >= $maxAttempts && $assetStatus !== 'Active') {
                    dLog('generate')->warning("{$label} {$mediaIndex} 素材处理超时");
                    logDB('generate', 'warning', '素材处理超时', [
                        'url' => $url,
                        'asset_type' => $assetType,
                        'index' => $mediaIndex,
                        'asset_id' => $assetId,
                        'last_status' => $assetStatus
                    ]);
                    $failedIndexes[] = $mediaIndex;
                }
                
            } catch (\Exception $e) {
                dLog('generate')->error("{$label} {$mediaIndex} 处理异常: " . $e->getMessage());
                logDB('generate', 'error', '素材转换异常', [
                    'url' => $url,
                    'asset_type' => $assetType,
                    'index' => $mediaIndex,
                    'error' => $e->getMessage()
                ]);
                $failedIndexes[] = $mediaIndex;
            }
        }
        
        // 处理失败的素材：从 fullPrompt 中删除对应的标记并调整序号
        if (!empty($failedIndexes)) {
            dLog('generate')->info("开始处理失败{$label}的提示词调整，失败序号: " . implode(',', $failedIndexes));
            
            // 按序号从大到小排序，避免删除时影响后续序号
            rsort($failedIndexes);
            
            foreach ($failedIndexes as $failedIndex) {
                // 删除失败素材的标记，例如 <图片1>、<视频2>、<音频3> 等
                $pattern = "/<{$tagName}{$failedIndex}>/u";
                $fullPrompt = preg_replace($pattern, '', $fullPrompt);
                dLog('generate')->info("已从提示词中删除 <{$tagName}{$failedIndex}>");
            }
            
            // 重新调整剩余素材的序号
            // 例如：如果素材2失败，素材3、素材4需要改为素材2、素材3
            $needAdjust = false;
            foreach ($failedIndexes as $failedIndex) {
                $needAdjust = true;
                // 将所有大于失败序号的素材标记序号减1
                for ($i = $failedIndex + 1; $i <= count($urls); $i++) {
                    $oldPattern = "/<{$tagName}{$i}>/u";
                    $newTag = "<{$tagName}" . ($i - 1) . ">";
                    $fullPrompt = preg_replace($oldPattern, $newTag, $fullPrompt);
                }
            }
            
            if ($needAdjust) {
                dLog('generate')->info("提示词{$label}序号调整完成");
                logDB('generate', 'info', '提示词调整', [
                    'failed_indexes' => $failedIndexes,
                    'adjusted_prompt' => $fullPrompt
                ]);
            }
        }
        
        dLog('generate')->info("参考{$label}转素材完成，成功数量: " . count($assetIds) . '，失败数量: ' . count($failedIndexes));

        // 格式化为可直接在API接口中使用的数组
        foreach ($assetIds as &$assetId) {
            $assetId = "asset://{$assetId}";
        }
        unset($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;
        }
    }

    /**
     * 从响应数据中移除 b64_json 字段
     * 避免在日志和数据库中存储大量 Base64 数据
     *
     * @param array $responseData
     * @return array
     */
    private function removeB64JsonFromResponse(array $responseData): array
    {
        $cleanedData = $responseData;
        
        if (isset($cleanedData['data']) && is_array($cleanedData['data'])) {
            foreach ($cleanedData['data'] as &$imageData) {
                if (isset($imageData['b64_json'])) {
                    // 移除 b64_json 字段，可选择性保留数据长度信息
                    $b64Length = strlen($imageData['b64_json']);
                    unset($imageData['b64_json']);
                    $imageData['b64_json_removed'] = true;
                    $imageData['b64_json_length'] = $b64Length;
                }
            }
            unset($imageData); // 解除引用
        }
        
        return $cleanedData;
    }
}