package com.ycwl.basic.image.pipeline.stages;

import com.ycwl.basic.image.enhancer.adapter.BceImageEnhancer;
import com.ycwl.basic.image.enhancer.entity.BceEnhancerConfig;
import com.ycwl.basic.image.pipeline.core.PhotoProcessContext;
import com.ycwl.basic.image.pipeline.enums.ImageSource;
import com.ycwl.basic.pipeline.annotation.StageConfig;
import com.ycwl.basic.pipeline.core.AbstractPipelineStage;
import com.ycwl.basic.pipeline.core.StageResult;
import com.ycwl.basic.pipeline.enums.StageOptionalMode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 图像增强Stage
 * 使用百度云图像增强API提升图片清晰度和质量
 *
 * 支持两种增强模式:
 * 1. 图像清晰度增强 (BceImageEnhancer)
 * 2. 图像超分辨率 (BceImageSR)
 */
@Slf4j
@StageConfig(
    stageId = "image_enhance",
    optionalMode = StageOptionalMode.SUPPORT,
    description = "图像增强处理",
    defaultEnabled = false  // 默认不启用，需要外部配置开启
)
public class ImageEnhanceStage extends AbstractPipelineStage<PhotoProcessContext> {

    private BceEnhancerConfig enhancerConfig;

    /**
     * 构造函数 - 使用默认配置
     */
    public ImageEnhanceStage() {
        this(buildConfigFromEnvironment());
    }

    /**
     * 构造函数 - 使用自定义配置
     *
     * @param enhancerConfig 图像增强配置
     */
    public ImageEnhanceStage(BceEnhancerConfig enhancerConfig) {
        this.enhancerConfig = enhancerConfig;
    }

    @Override
    public String getName() {
        return "ImageEnhanceStage";
    }

    @Override
    protected boolean shouldExecuteByBusinessLogic(PhotoProcessContext context) {
        // 仅对照片源为IPC的图片进行增强
        return context.getSource() == ImageSource.IPC;
    }

    @Override
    protected StageResult<PhotoProcessContext> doExecute(PhotoProcessContext context) {
        // 检查配置是否完整
        if (!isConfigValid()) {
            log.warn("图像增强配置不完整，跳过增强处理。请在ImageEnhanceStage中配置百度云API凭证");
            return StageResult.skipped("配置不完整，跳过增强");
        }

        File currentFile = context.getCurrentFile();
        if (currentFile == null || !currentFile.exists()) {
            return StageResult.skipped("当前文件不存在");
        }

        try {
            log.debug("开始图像增强: {}", currentFile.getName());

            // 创建百度云图像增强客户端
            BceImageEnhancer enhancer = new BceImageEnhancer();
            enhancer.setConfig(enhancerConfig);

            // 调用图像增强API
            // 注意：百度云API需要传入图片URL，这里使用本地文件的绝对路径
            String imageUrl = currentFile.getAbsolutePath();
            MultipartFile enhancedImage = enhancer.enhance(imageUrl);

            if (enhancedImage == null || enhancedImage.isEmpty()) {
                log.warn("图像增强返回空结果，可能是API调用失败");
                return StageResult.degraded("增强失败，使用原图");
            }

            // 保存增强后的图片到临时文件
            File enhancedFile = context.getTempFileManager()
                    .createTempFile("enhanced", ".jpg");

            saveMultipartFileToFile(enhancedImage, enhancedFile);

            if (!enhancedFile.exists() || enhancedFile.length() == 0) {
                return StageResult.degraded("增强结果保存失败，使用原图");
            }

            // 更新处理后的文件
            context.updateProcessedFile(enhancedFile);

            long originalSize = currentFile.length();
            long enhancedSize = enhancedFile.length();
            double sizeRatio = (double) enhancedSize / originalSize;

            log.info("图像增强完成: 原始{}KB -> 增强后{}KB (比例: {})",
                    originalSize / 1024,
                    enhancedSize / 1024,
                    String.format("%.2f", sizeRatio));

            return StageResult.success(String.format("已增强 (%dKB -> %dKB)",
                    originalSize / 1024,
                    enhancedSize / 1024));

        } catch (Exception e) {
            log.error("图像增强失败: {}", e.getMessage(), e);

            // 增强失败时返回降级状态，继续使用原图
            return StageResult.degraded("增强失败: " + e.getMessage());
        }
    }

    /**
     * 检查配置是否有效
     */
    private boolean isConfigValid() {
        if (enhancerConfig == null) {
            return false;
        }

        String appId = enhancerConfig.getAppId();
        String apiKey = enhancerConfig.getApiKey();
        String secretKey = enhancerConfig.getSecretKey();

        // 检查字段是否为 null 或空
        if (appId == null || appId.isBlank() ||
                apiKey == null || apiKey.isBlank() ||
                secretKey == null || secretKey.isBlank()) {
            return false;
        }

        // 检查是否包含 TODO 占位符
        if (appId.contains("TODO") || apiKey.contains("TODO") || secretKey.contains("TODO")) {
            return false;
        }

        return true;
    }

    private static BceEnhancerConfig buildConfigFromEnvironment() {
        BceEnhancerConfig config = new BceEnhancerConfig();
        config.setAppId(System.getenv("BCE_IMAGE_APP_ID"));
        config.setApiKey(System.getenv("BCE_IMAGE_API_KEY"));
        config.setSecretKey(System.getenv("BCE_IMAGE_SECRET_KEY"));
        config.setQps(1.0f);
        return config;
    }

    /**
     * 保存MultipartFile到本地文件
     */
    private void saveMultipartFileToFile(MultipartFile multipartFile, File targetFile) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(targetFile)) {
            fos.write(multipartFile.getBytes());
            fos.flush();
        }
    }

    /**
     * 获取当前配置（用于调试）
     */
    public BceEnhancerConfig getEnhancerConfig() {
        return enhancerConfig;
    }

    /**
     * 设置配置（用于动态配置）
     */
    public void setEnhancerConfig(BceEnhancerConfig enhancerConfig) {
        this.enhancerConfig = enhancerConfig;
    }
}
