package com.example.demo.service;

import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.databind.ObjectMapper;

import kong.unirest.HttpResponse;
import kong.unirest.Unirest;
import kong.unirest.UnirestException;

/**
 * 真实AI服务类
 * 调用外部AI API进行视频生成
 */
@Service
public class RealAIService {

    private static final Logger logger = LoggerFactory.getLogger(RealAIService.class);

    @Value("${ai.api.base-url:http://116.62.4.26:8081}")
    private String aiApiBaseUrl;

    @Value("${ai.api.key:ak_5f13ec469e6047d5b8155c3cc91350e2}")
    private String aiApiKey;

    @Value("${ai.image.api.base-url:https://ai.comfly.chat}")
    private String aiImageApiBaseUrl;

    @Value("${ai.image.api.key:ak_5f13ec469e6047d5b8155c3cc91350e2}")
    private String aiImageApiKey;


    private final ObjectMapper objectMapper;

    public RealAIService() {
        this.objectMapper = new ObjectMapper();
        // 设置Unirest超时
        Unirest.config().connectTimeout(0).socketTimeout(0);
    }

    /**
     * 提交图生视频任务
     */
    public Map<String, Object> submitImageToVideoTask(String prompt, String imageBase64, 
                                                     String aspectRatio, String duration, 
                                                     boolean hdMode) {
        try {
            // 根据参数选择可用的模型
            String modelName = selectAvailableImageToVideoModel(aspectRatio, duration, hdMode);
            
            // 将Base64图片转换为字节数组
            String base64Data = imageBase64;
            if (imageBase64.contains(",")) {
                base64Data = imageBase64.substring(imageBase64.indexOf(",") + 1);
            }
            // 验证base64数据格式
            try {
                Base64.getDecoder().decode(base64Data);
                logger.debug("Base64数据格式验证通过");
            } catch (IllegalArgumentException e) {
                logger.error("Base64数据格式错误: {}", e.getMessage());
                throw new RuntimeException("图片数据格式错误");
            }
            
            // 根据分辨率选择size参数（用于日志记录）
            String size = convertAspectRatioToSize(aspectRatio, hdMode);
            logger.debug("选择的尺寸参数: {}", size);
            
            String url = aiApiBaseUrl + "/user/ai/tasks/submit";
            String requestBody = String.format("{\"modelName\":\"%s\",\"prompt\":\"%s\",\"aspectRatio\":\"%s\",\"imageToVideo\":true,\"imageBase64\":\"%s\"}", 
                modelName, prompt, aspectRatio, imageBase64);
            
            logger.info("图生视频请求体: {}", requestBody);
            
            HttpResponse<String> response = Unirest.post(url)
                .header("Authorization", "Bearer " + aiApiKey)
                .header("Content-Type", "application/json")
                .body(requestBody)
                .asString();

            if (response.getStatus() == 200 && response.getBody() != null) {
                @SuppressWarnings("unchecked")
                Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                Integer code = (Integer) responseBody.get("code");
                
                if (code != null && code == 200) {
                    logger.info("图生视频任务提交成功: {}", responseBody);
                    return responseBody;
                } else {
                    logger.error("图生视频任务提交失败: {}", responseBody);
                    throw new RuntimeException("任务提交失败: " + responseBody.get("message"));
                }
            } else {
                logger.error("图生视频任务提交失败，HTTP状态: {}", response.getStatus());
                throw new RuntimeException("任务提交失败，HTTP状态: " + response.getStatus());
            }

        } catch (UnirestException e) {
            logger.error("提交图生视频任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        } catch (Exception e) {
            logger.error("提交图生视频任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        }
    }

    /**
     * 提交文生视频任务
     */
    public Map<String, Object> submitTextToVideoTask(String prompt, String aspectRatio, 
                                                    String duration, boolean hdMode) {
        try {
            // 根据参数选择可用的模型
            String modelName = selectAvailableTextToVideoModel(aspectRatio, duration, hdMode);
            
            // 根据分辨率选择size参数
            String size = convertAspectRatioToSize(aspectRatio, hdMode);

            // 添加调试日志
            logger.info("提交文生视频任务请求: model={}, prompt={}, size={}, seconds={}", 
                       modelName, prompt, size, duration);
            logger.info("选择的模型: {}", modelName);
            logger.info("API端点: {}", aiApiBaseUrl + "/user/ai/tasks/submit");
            logger.info("使用API密钥: {}", aiApiKey.substring(0, Math.min(10, aiApiKey.length())) + "...");

            String url = aiApiBaseUrl + "/user/ai/tasks/submit";
            String requestBody = String.format("{\"modelName\":\"%s\",\"prompt\":\"%s\",\"aspectRatio\":\"%s\",\"imageToVideo\":false}", 
                modelName, prompt, aspectRatio);
            
            logger.info("请求体: {}", requestBody);
            
            HttpResponse<String> response = Unirest.post(url)
                .header("Authorization", "Bearer " + aiApiKey)
                .header("Content-Type", "application/json")
                .body(requestBody)
                .asString();

            // 添加响应调试日志
            logger.info("API响应状态: {}", response.getStatus());
            logger.info("API响应内容: {}", response.getBody());

            if (response.getStatus() == 200 && response.getBody() != null) {
                @SuppressWarnings("unchecked")
                Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                Integer code = (Integer) responseBody.get("code");
                
                if (code != null && code == 200) {
                    logger.info("文生视频任务提交成功: {}", responseBody);
                    return responseBody;
                } else {
                    logger.error("文生视频任务提交失败: {}", responseBody);
                    throw new RuntimeException("任务提交失败: " + responseBody.get("message"));
                }
            } else {
                logger.error("文生视频任务提交失败，HTTP状态: {}", response.getStatus());
                throw new RuntimeException("任务提交失败，HTTP状态: " + response.getStatus());
            }

        } catch (UnirestException e) {
            logger.error("提交文生视频任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        } catch (Exception e) {
            logger.error("提交文生视频任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        }
    }

    /**
     * 查询任务状态
     */
    public Map<String, Object> getTaskStatus(String taskId) {
        try {
            String url = aiApiBaseUrl + "/user/ai/tasks/" + taskId;
            HttpResponse<String> response = Unirest.get(url)
                .header("Authorization", "Bearer " + aiApiKey)
                .asString();

            if (response.getStatus() == 200 && response.getBody() != null) {
                @SuppressWarnings("unchecked")
                Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                Integer code = (Integer) responseBody.get("code");
                
                if (code != null && code == 200) {
                    return responseBody;
                } else {
                    logger.error("查询任务状态失败: {}", responseBody);
                    throw new RuntimeException("查询任务状态失败: " + responseBody.get("message"));
                }
            } else {
                logger.error("查询任务状态失败，HTTP状态: {}", response.getStatus());
                throw new RuntimeException("查询任务状态失败，HTTP状态: " + response.getStatus());
            }

        } catch (UnirestException e) {
            logger.error("查询任务状态异常: {}", taskId, e);
            throw new RuntimeException("查询任务状态失败: " + e.getMessage());
        } catch (Exception e) {
            logger.error("查询任务状态异常: {}", taskId, e);
            throw new RuntimeException("查询任务状态失败: " + e.getMessage());
        }
    }

    /**
     * 根据参数选择可用的图生视频模型
     */
    private String selectAvailableImageToVideoModel(String aspectRatio, String duration, boolean hdMode) {
        try {
            // 首先尝试获取可用模型列表
            Map<String, Object> modelsResponse = getAvailableModels();
            if (modelsResponse != null && modelsResponse.get("data") instanceof List) {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> taskTypes = (List<Map<String, Object>>) modelsResponse.get("data");
                
                // 查找图生视频任务类型
                for (@SuppressWarnings("unchecked") Map<String, Object> taskType : taskTypes) {
                    if ("image_to_video".equals(taskType.get("taskType"))) {
                        @SuppressWarnings("unchecked")
                        List<Map<String, Object>> models = (List<Map<String, Object>>) taskType.get("models");
                        
                        // 根据参数匹配模型
                        for (Map<String, Object> model : models) {
                            Map<String, Object> config = (Map<String, Object>) model.get("extendedConfig");
                            if (config != null) {
                                String modelAspectRatio = (String) config.get("aspectRatio");
                                String modelDuration = (String) config.get("duration");
                                String modelSize = (String) config.get("size");
                                Boolean isEnabled = (Boolean) model.get("isEnabled");
                                
                                // 检查是否匹配参数
                                if (isEnabled != null && isEnabled && 
                                    aspectRatio.equals(modelAspectRatio) && 
                                    duration.equals(modelDuration) &&
                                    (hdMode ? "large".equals(modelSize) : "small".equals(modelSize))) {
                                    
                                    String modelName = (String) model.get("modelName");
                                    logger.info("选择图生视频模型: {} (aspectRatio: {}, duration: {}, size: {})", 
                                               modelName, modelAspectRatio, modelDuration, modelSize);
                                    return modelName;
                                }
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.warn("获取可用图生视频模型失败，使用默认模型选择逻辑", e);
        }
        
        // 如果获取模型列表失败，使用默认逻辑
        return selectImageToVideoModel(aspectRatio, duration, hdMode);
    }

    /**
     * 根据参数选择图生视频模型（默认逻辑）
     */
    private String selectImageToVideoModel(String aspectRatio, String duration, boolean hdMode) {
        String size = hdMode ? "large" : "small";
        String orientation = "9:16".equals(aspectRatio) || "3:4".equals(aspectRatio) ? "portrait" : "landscape";
        
        // 根据API返回的模型列表，只支持10s和15s
        String actualDuration = "5".equals(duration) ? "10" : duration;
        
        return String.format("sc_sora2_img_%s_%ss_%s", orientation, actualDuration, size);
    }

    /**
     * 获取可用的模型列表
     */
    public Map<String, Object> getAvailableModels() {
        try {
            String url = aiApiBaseUrl + "/user/ai/models";
            logger.info("正在调用外部API获取模型列表: {}", url);
            logger.info("使用API密钥: {}", aiApiKey.substring(0, Math.min(10, aiApiKey.length())) + "...");
            
            HttpResponse<String> response = Unirest.get(url)
                .header("Authorization", "Bearer " + aiApiKey)
                .asString();

            logger.info("API响应状态: {}", response.getStatus());
            logger.info("API响应内容: {}", response.getBody());

            if (response.getStatus() == 200 && response.getBody() != null) {
                @SuppressWarnings("unchecked")
                Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                Integer code = (Integer) responseBody.get("code");
                if (code != null && code == 200) {
                    logger.info("成功获取模型列表");
                    return responseBody;
                } else {
                    logger.error("API返回错误代码: {}, 响应: {}", code, responseBody);
                }
            } else {
                logger.error("API调用失败，HTTP状态: {}, 响应: {}", response.getStatus(), response.getBody());
            }
            return null;
        } catch (UnirestException e) {
            logger.error("获取模型列表失败", e);
            return null;
        } catch (Exception e) {
            logger.error("获取模型列表失败", e);
            return null;
        }
    }

    /**
     * 根据参数选择可用的文生视频模型
     */
    private String selectAvailableTextToVideoModel(String aspectRatio, String duration, boolean hdMode) {
        try {
            // 首先尝试获取可用模型列表
            Map<String, Object> modelsResponse = getAvailableModels();
            if (modelsResponse != null && modelsResponse.get("data") instanceof List) {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> taskTypes = (List<Map<String, Object>>) modelsResponse.get("data");
                
                // 查找文生视频任务类型
                for (@SuppressWarnings("unchecked") Map<String, Object> taskType : taskTypes) {
                    if ("text_to_video".equals(taskType.get("taskType"))) {
                        @SuppressWarnings("unchecked")
                        List<Map<String, Object>> models = (List<Map<String, Object>>) taskType.get("models");
                        
                        // 根据参数匹配模型
                        for (Map<String, Object> model : models) {
                            Map<String, Object> config = (Map<String, Object>) model.get("extendedConfig");
                            if (config != null) {
                                String modelAspectRatio = (String) config.get("aspectRatio");
                                String modelDuration = (String) config.get("duration");
                                String modelSize = (String) config.get("size");
                                Boolean isEnabled = (Boolean) model.get("isEnabled");
                                
                                // 检查是否匹配参数
                                if (isEnabled != null && isEnabled && 
                                    aspectRatio.equals(modelAspectRatio) && 
                                    duration.equals(modelDuration) &&
                                    (hdMode ? "large".equals(modelSize) : "small".equals(modelSize))) {
                                    
                                    String modelName = (String) model.get("modelName");
                                    logger.info("选择模型: {} (aspectRatio: {}, duration: {}, size: {})", 
                                               modelName, modelAspectRatio, modelDuration, modelSize);
                                    return modelName;
                                }
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.warn("获取可用模型失败，使用默认模型选择逻辑", e);
        }
        
        // 如果获取模型列表失败，使用默认逻辑
        return selectTextToVideoModel(aspectRatio, duration, hdMode);
    }

    /**
     * 根据参数选择文生视频模型（默认逻辑）
     */
    private String selectTextToVideoModel(String aspectRatio, String duration, boolean hdMode) {
        String size = hdMode ? "large" : "small";
        String orientation = "9:16".equals(aspectRatio) || "3:4".equals(aspectRatio) ? "portrait" : "landscape";
        
        // 根据API返回的模型列表，只支持10s和15s
        String actualDuration = "5".equals(duration) ? "10" : duration;
        
        return String.format("sc_sora2_text_%s_%ss_%s", orientation, actualDuration, size);
    }

    /**
     * 将图片文件转换为Base64
     */
    public String convertImageToBase64(byte[] imageBytes, String contentType) {
        try {
            String base64 = java.util.Base64.getEncoder().encodeToString(imageBytes);
            return "data:" + contentType + ";base64," + base64;
        } catch (Exception e) {
            logger.error("图片转Base64失败", e);
            throw new RuntimeException("图片转换失败: " + e.getMessage());
        }
    }

    /**
     * 提交文生图任务（分镜视频使用）
     * 调用Comfly API的文生图接口，参考Comfly项目的Comfly_qwen_image节点实现
     * 支持分镜图生成，可以生成多张图片用于拼接成分镜图网格
     * 
     * @param prompt 提示词
     * @param aspectRatio 宽高比
     * @param numImages 生成图片数量，默认6张用于分镜图
     * @return API响应，包含多张图片的URL
     */
    public Map<String, Object> submitTextToImageTask(String prompt, String aspectRatio, int numImages) {
        try {
            logger.info("提交文生图任务: prompt={}, aspectRatio={}, numImages={}", prompt, aspectRatio, numImages);
            
            // 限制生成图片数量在1-12之间，参考Comfly项目的限制
            if (numImages < 1) {
                numImages = 1;
            } else if (numImages > 12) {
                numImages = 12;
            }
            
            // 根据aspectRatio转换尺寸，参考Comfly项目的尺寸映射
            String size = convertAspectRatioToImageSize(aspectRatio);
            
            // 使用文生图的API端点（Comfly API）
            String url = aiImageApiBaseUrl + "/v1/images/generations";
            
            // 构建请求体，参考Comfly_qwen_image节点的参数设置
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("prompt", prompt);
            requestBody.put("size", size);
            requestBody.put("model", "qwen-image");
            requestBody.put("n", numImages);  // 支持生成多张图片
            requestBody.put("response_format", "url");
            // 添加guidance_scale参数以提高图片质量（参考Comfly项目）
            requestBody.put("guidance_scale", 2.5);
            
            String requestBodyJson = objectMapper.writeValueAsString(requestBody);
            
            logger.info("文生图请求URL: {}", url);
            logger.info("文生图请求体: {}", requestBodyJson);
            logger.info("使用的API密钥: {}", aiImageApiKey.substring(0, Math.min(10, aiImageApiKey.length())) + "...");
            
            HttpResponse<String> response = Unirest.post(url)
                .header("Authorization", "Bearer " + aiImageApiKey)
                .header("Content-Type", "application/json")
                .body(requestBodyJson)
                .asString();

            logger.info("文生图API响应状态: {}", response.getStatus());
            logger.info("文生图API响应内容: {}", response.getBody());

            if (response.getStatus() == 200 && response.getBody() != null) {
                @SuppressWarnings("unchecked")
                Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                
                // 检查是否有data字段
                if (responseBody.get("data") != null) {
                    logger.info("文生图任务提交成功: {}", responseBody);
                    return responseBody;
                } else {
                    logger.error("文生图任务提交失败: {}", responseBody);
                    throw new RuntimeException("任务提交失败: " + responseBody.get("message"));
                }
            } else {
                logger.error("文生图任务提交失败，HTTP状态: {}", response.getStatus());
                throw new RuntimeException("任务提交失败，HTTP状态: " + response.getStatus());
            }

        } catch (UnirestException e) {
            logger.error("提交文生图任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        } catch (Exception e) {
            logger.error("提交文生图任务异常", e);
            throw new RuntimeException("提交任务失败: " + e.getMessage());
        }
    }

    /**
     * 将宽高比转换为图片尺寸
     * 参考Comfly项目的尺寸映射，支持分镜图生成的各种常用尺寸
     */
    private String convertAspectRatioToImageSize(String aspectRatio) {
        return switch (aspectRatio) {
            case "16:9" -> "1024x576";   // 横屏，适合宽屏分镜
            case "9:16" -> "576x1024";   // 竖屏，适合手机视频分镜
            case "4:3" -> "1024x768";    // 标准横屏
            case "3:4" -> "768x1024";    // 标准竖屏
            case "1:1" -> "1024x1024";   // 正方形
            default -> "1024x768";       // 默认标准横屏
        };
    }

    /**
     * 将宽高比转换为Sora2 API的size参数
     */
    private String convertAspectRatioToSize(String aspectRatio, boolean hdMode) {
        return switch (aspectRatio) {
            case "16:9" -> hdMode ? "1792x1024" : "1280x720";  // 1080P横屏 : 720P横屏
            case "9:16" -> hdMode ? "1024x1792" : "720x1280";  // 1080P竖屏 : 720P竖屏
            case "1:1" -> hdMode ? "1024x1024" : "720x720";   // 正方形
            default -> "720x1280";  // 默认竖屏
        };
    }

    /**
     * 优化提示词
     * 使用AI模型将用户输入的简单描述优化为详细、专业的提示词
     * 
     * @param prompt 原始提示词
     * @param type 优化类型：text-to-video, image-to-video, storyboard
     * @return 优化后的提示词，失败时返回原始提示词
     */
    public String optimizePrompt(String prompt, String type) {
        // 参数验证
        if (prompt == null || prompt.trim().isEmpty()) {
            logger.warn("提示词为空，无法优化");
            return prompt;
        }
        
        // 长度限制（防止过长提示词）
        if (prompt.length() > 1000) {
            logger.warn("提示词过长（{}字符），截取前1000字符", prompt.length());
            prompt = prompt.substring(0, 1000);
        }
        
        try {
            logger.info("开始优化提示词: prompt={}, type={}, length={}", 
                prompt.length() > 50 ? prompt.substring(0, 50) + "..." : prompt, 
                type, 
                prompt.length());
            
            // 根据类型生成不同的优化指令
            String systemPrompt = getOptimizationPrompt(type);
            
            // 构建请求体，使用ChatGPT API格式
            String url = aiApiBaseUrl + "/v1/chat/completions";
            
            Map<String, Object> requestBody = new HashMap<>();
            requestBody.put("model", "gpt-4o-mini"); // 使用GPT-4o-mini进行优化
            
            List<Map<String, String>> messages = new java.util.ArrayList<>();
            Map<String, String> systemMessage = new HashMap<>();
            systemMessage.put("role", "system");
            systemMessage.put("content", systemPrompt);
            messages.add(systemMessage);
            
            Map<String, String> userMessage = new HashMap<>();
            userMessage.put("role", "user");
            userMessage.put("content", "请优化以下提示词，保持原始意图：\n" + prompt);
            messages.add(userMessage);
            
            requestBody.put("messages", messages);
            requestBody.put("temperature", 0.7);
            requestBody.put("max_tokens", 800); // 增加token限制，允许更详细的优化
            
            String requestBodyJson = objectMapper.writeValueAsString(requestBody);
            
            logger.debug("提示词优化请求URL: {}", url);
            
            // 设置超时时间（30秒）
            HttpResponse<String> response = Unirest.post(url)
                .header("Authorization", "Bearer " + aiApiKey)
                .header("Content-Type", "application/json")
                .socketTimeout(30000)
                .connectTimeout(10000)
                .body(requestBodyJson)
                .asString();

            int statusCode = response.getStatus();
            logger.info("提示词优化API响应状态: {}", statusCode);
            
            if (statusCode == 200 && response.getBody() != null) {
                try {
                    @SuppressWarnings("unchecked")
                    Map<String, Object> responseBody = objectMapper.readValue(response.getBody(), Map.class);
                    
                    // 检查API错误响应
                    if (responseBody.containsKey("error")) {
                        @SuppressWarnings("unchecked")
                        Map<String, Object> error = (Map<String, Object>) responseBody.get("error");
                        String errorMessage = (String) error.get("message");
                        logger.error("API返回错误: {}", errorMessage);
                        return prompt; // 返回原始提示词
                    }
                    
                    @SuppressWarnings("unchecked")
                    List<Map<String, Object>> choices = (List<Map<String, Object>>) responseBody.get("choices");
                    if (choices != null && !choices.isEmpty()) {
                        @SuppressWarnings("unchecked")
                        Map<String, Object> choice = choices.get(0);
                        
                        // 检查finish_reason
                        String finishReason = (String) choice.get("finish_reason");
                        if ("length".equals(finishReason)) {
                            logger.warn("优化结果被截断，可能需要增加max_tokens");
                        }
                        
                        @SuppressWarnings("unchecked")
                        Map<String, Object> message = (Map<String, Object>) choice.get("message");
                        if (message != null) {
                            String optimizedPrompt = (String) message.get("content");
                            if (optimizedPrompt != null && !optimizedPrompt.trim().isEmpty()) {
                                optimizedPrompt = optimizedPrompt.trim();
                                // 移除可能的前后缀标记
                                optimizedPrompt = optimizedPrompt.replaceAll("^\"+|\"+$", "");
                                logger.info("提示词优化成功: 原始长度={}, 优化后长度={}", 
                                    prompt.length(), optimizedPrompt.length());
                                return optimizedPrompt;
                            }
                        }
                    }
                    
                    logger.warn("API响应格式异常，无法解析优化结果");
                } catch (Exception parseException) {
                    logger.error("解析API响应失败", parseException);
                }
            } else {
                logger.error("提示词优化API请求失败，HTTP状态: {}, 响应: {}", 
                    statusCode, 
                    response.getBody() != null && response.getBody().length() < 200 ? response.getBody() : "响应过长");
            }
            
            // 所有失败情况都返回原始提示词
            return prompt;
            
        } catch (com.fasterxml.jackson.core.JsonProcessingException e) {
            logger.error("提示词优化JSON处理失败", e);
            return prompt;
        } catch (kong.unirest.UnirestException e) {
            // Unirest异常可能包含超时或连接错误
            Throwable cause = e.getCause();
            if (cause instanceof java.net.SocketTimeoutException) {
                logger.error("提示词优化超时", e);
            } else if (cause instanceof java.net.ConnectException) {
                logger.error("提示词优化连接失败", e);
            } else {
                logger.error("提示词优化网络异常", e);
            }
            return prompt;
        } catch (Exception e) {
            logger.error("提示词优化异常", e);
            return prompt;
        }
    }

    /**
     * 根据类型获取优化提示词的系统指令
     * 使用文本块（Text Blocks）优化可读性
     */
    private String getOptimizationPrompt(String type) {
        return switch (type) {
            case "text-to-video" -> """
                你是一个专业的视频生成提示词优化专家。你的任务是将用户提供的简单描述优化为详细、专业、适合AI视频生成的英文提示词。
                
                优化要求：
                1. 将中文描述翻译成流畅的英文，确保语义准确
                2. 添加详细的视觉细节描述（场景环境、人物特征、动作细节、光线效果、色彩风格、构图方式等）
                3. 使用专业的电影术语和视觉词汇（如：cinematic, wide shot, close-up等）
                4. 确保提示词清晰、具体、有画面感，能够准确指导AI生成
                5. 保持原始意图不变，只优化表达方式和补充细节
                6. 如果原始提示词已经是英文，直接优化，保持语言一致
                7. 输出优化后的提示词，不要添加额外说明、引号或其他格式标记
                8. 优化后的提示词应该直接可用，长度控制在合理范围内
                """;
            case "image-to-video" -> """
                你是一个专业的视频生成提示词优化专家。你的任务是将用户提供的简单描述优化为详细、专业、适合AI图生视频的英文提示词。
                
                优化要求：
                1. 将中文描述翻译成流畅的英文，确保语义准确
                2. 重点关注动画效果、镜头运动、动作描述（如：zoom in, pan, fade等）
                3. 添加时间维度和动态效果描述（持续时间、运动方向、速度变化等）
                4. 确保提示词能准确表达图片到视频的转换需求，描述动画和运动的细节
                5. 使用专业的视频制作术语（如：smooth transition, dynamic movement等）
                6. 如果原始提示词已经是英文，直接优化，保持语言一致
                7. 输出优化后的提示词，不要添加额外说明、引号或其他格式标记
                8. 优化后的提示词应该直接可用，长度控制在合理范围内
                """;
            case "storyboard" -> """
                你是一个专业的分镜图提示词优化专家。你的任务是将用户提供的简单描述优化为详细、专业、适合生成故事板分镜图的英文提示词。
                
                优化要求：
                1. 将中文描述翻译成流畅的英文，确保语义准确
                2. 关注镜头构图、画面布局、视觉元素（如：composition, framing, visual hierarchy等）
                3. 适合生成专业分镜图风格，强调构图和画面元素，包含清晰的场景描述和视觉细节
                4. 确保提示词清晰描述每个镜头的关键视觉元素和构图方式
                5. 使用专业的电影分镜术语（如：establishing shot, medium shot, close-up, wide shot, over-the-shoulder等）
                6. 添加画面细节描述：场景环境、人物/物体的位置、光线、氛围等
                7. 如果原始提示词已经是英文，直接优化，保持语言一致
                8. 输出优化后的提示词，不要添加额外说明、引号或其他格式标记
                9. 优化后的提示词应该直接可用，长度控制在合理范围内（200-500词）
                10. 参考格式："(scene description), (shot type), (composition details), (visual elements), (lighting and atmosphere), professional storyboard style, cinematic framing"
                """;
            default -> """
                你是一个专业的提示词优化专家。请将用户提供的简单描述优化为详细、专业的英文提示词。
                
                优化要求：
                1. 将中文描述翻译成流畅的英文，如果已经是英文则直接优化
                2. 添加必要的视觉细节和描述，使提示词更加具体和专业
                3. 保持原始意图不变，只优化表达方式
                4. 输出优化后的提示词，不要添加额外说明、引号或其他格式标记
                5. 优化后的提示词应该直接可用，长度控制在合理范围内
                """;
        };
    }
}
