// ❌ 传统写法：代码耦合，难以维护
void uploadImage() {
    parseMarkdown();
    if (needCompress) compressImage();
    if (needRename) renameImage();
    uploadToOss();
    if (needChangeTag) changeTag();
    writeToDocument();
}

public interface IActionHandler {
    String getName();                    // 处理器名称
    boolean isEnabled(EventData data);   // 是否启用
    boolean execute(EventData data);     // 执行逻辑
}

package info.dong4j.idea.plugin.chain;

import info.dong4j.idea.plugin.MikBundle;
import info.dong4j.idea.plugin.action.intention.IntentionActionBase;
import info.dong4j.idea.plugin.entity.EventData;
import info.dong4j.idea.plugin.entity.MarkdownImage;
import info.dong4j.idea.plugin.util.ImageUtils;

import org.jetbrains.annotations.NotNull;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.Map;

import lombok.extern.slf4j.Slf4j;

/**
 * 图片压缩处理类
 * <p>
 * 用于处理 Markdown 图片的压缩操作，将图片的 InputStream 进行压缩处理，并更新为压缩后的输入流。
 * 支持对非 GIF 格式的图片进行压缩，同时记录压缩前后的大小及压缩率。
 * 该类继承自 ActionHandlerAdapter，用于在特定事件触发时执行图片压缩逻辑。
 *
 * @author dong4j
 * @version 0.0.1
 * @date 2021.02.14
 * @since 0.0.1
 */
@Slf4j
public class ImageCompressionHandler extends ActionHandlerAdapter {
    /**
     * 获取名称
     * <p>
     * 返回预定义的名称字符串，用于表示操作进度标题
     *
     * @return 名称字符串
     * @since 0.0.1
     */
    @Override
    public String getName() {
        return MikBundle.message("mik.action.progress.title");
    }

    /**
     * 判断当前状态是否启用压缩功能
     * <p>
     * 根据当前状态判断是否启用压缩功能，返回对应的布尔值
     *
     * @param data 事件数据，用于上下文信息
     * @return 是否启用压缩功能
     * @since 0.0.1
     */
    @Override
    public boolean isEnabled(EventData data) {
        return IntentionActionBase.getState().isCompress();
    }

    /**
     * 处理Markdown图片数据，压缩图片流并更新图片对象
     * <p>
     * 该方法用于处理Markdown图片数据，首先检查图片流是否为空，若为空则从迭代器中移除该图片。
     * 若图片名称以"gif"结尾，则直接返回。否则，使用ImageUtils工具类对图片进行压缩处理，并将压缩后的流设置回图片对象。
     *
     * @param data          事件数据对象
     * @param imageIterator 图片迭代器，用于遍历和移除图片
     * @param markdownImage Markdown图片对象，包含图片名称和输入流
     */
    @Override
    public void invoke(EventData data, Iterator<MarkdownImage> imageIterator, MarkdownImage markdownImage) {
        String imageName = markdownImage.getImageName();
        if (markdownImage.getInputStream() == null) {
            log.trace("inputstream 为 null, remove markdownImage = {}", markdownImage);
            imageIterator.remove();
            return;
        }

        if (imageName.endsWith("gif")) {
            return;
        }

        InputStream inputStream = markdownImage.getInputStream();
        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            ImageUtils.compress(inputStream, outputStream, IntentionActionBase.getState().getCompressBeforeUploadOfPercent());
            markdownImage.setInputStream(new ByteArrayInputStream(outputStream.toByteArray()));
        } catch (Exception e) {
            log.trace("", e);
        }
    }

    /**
     * 构建上传流程的动作管理器
     * <p>
     * 根据传入的事件数据创建一个包含多个处理步骤的动作管理器，用于处理文件上传的完整流程。
     *
     * @param data 事件数据
     * @return 动作管理器实例
     * @since 0.0.1
     */
    public static ActionManager buildUploadChain(EventData data) {
        return new ActionManager(data)
            // 解析 markdown 文件
            .addHandler(new ResolveMarkdownFileHandler())
            // 图片压缩
            .addHandler(new ImageCompressionHandler())
            // 图片重命名
            .addHandler(new ImageRenameHandler())
            // 处理 client
            .addHandler(new OptionClientHandler())
            // 图片上传
            .addHandler(new ImageUploadHandler())
            // 标签转换
            .addHandler(new ImageLabelChangeHandler())
            // 写入标签
            .addHandler(new ReplaceToDocument())
            .addHandler(new FinalChainHandler());
    }

    /**
     * 执行处理链中的各个处理器
     * <p>
     * 遍历处理器链，依次调用每个启用的处理器，并更新进度指示器的状态
     *
     * @param indicator 进度指示器，用于显示处理进度和当前处理的处理器名称
     */
    public void invoke(ProgressIndicator indicator) {
        int totalProcessed = 0;
        this.data.setIndicator(indicator);
        this.data.setSize(this.handlersChain.size());
        int index = 0;
        for (IActionHandler handler : this.handlersChain) {
            this.data.setIndex(index++);
            if (handler.isEnabled(this.data)) {
                log.trace("invoke {}", handler.getName());
                indicator.setText2(handler.getName());
                if (!handler.execute(this.data)) {
                    break;
                }
            }
            indicator.setFraction(++totalProcessed * 1.0 / this.handlersChain.size());
        }
    }

// ✅ 新增水印功能
public class WatermarkHandler extends ActionHandlerAdapter {
    @Override
    public boolean isEnabled(EventData data) {
        return state.isWatermark();
    }
    
    @Override
    public void invoke(...) {
        // 添加水印逻辑
    }
}

// 只需在链中添加
.addHandler(new WatermarkHandler())

@Override
public boolean isEnabled(EventData data) {
    return state.isCompress();  // 用户勾选才执行
}

@Test
void testImageCompression() {
    ImageCompressionHandler handler = new ImageCompressionHandler();
    EventData data = createTestData();
    handler.execute(data);
    // 验证压缩效果
}

    @Override
    public boolean execute(EventData data) {
        ProgressIndicator indicator = data.getIndicator();
        int size = data.getSize();

        // 统计总数，用于进度计算
        int totalCount = data.getWaitingProcessMap().values().stream()
            .mapToInt(List::size)
            .sum();

        // 使用原子变量跟踪进度，确保线程安全
        AtomicInteger processedCount = new AtomicInteger(0);

        // 动态计算线程池大小，最多使用10个线程，但要考虑图片数量
        int threadPoolSize = Math.min(Math.max(totalCount, 2), 10);
        ExecutorService executorService = Executors.newFixedThreadPool(threadPoolSize);

        log.info("开始上传 {} 张图片，使用 {} 个线程", totalCount, threadPoolSize);

        List<CompletableFuture<?>> futures = new ArrayList<>();

        // 收集所有需要处理的图片
        List<ImageUploadTask> uploadTasks = new ArrayList<>();
        for (Map.Entry<Document, List<MarkdownImage>> imageEntry : data.getWaitingProcessMap().entrySet()) {
            for (MarkdownImage markdownImage : imageEntry.getValue()) {
                uploadTasks.add(new ImageUploadTask(markdownImage, imageEntry.getValue()));
            }
        }

        // 为每个图片创建异步任务
        for (ImageUploadTask task : uploadTasks) {
            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
                try {
                    MarkdownImage markdownImage = task.markdownImage;
                    int currentProcessed = processedCount.incrementAndGet();

                    // 更新进度
                    String imageName = markdownImage.getImageName();
                    indicator.setText2(MikBundle.message("mik.action.processing.title", imageName));
                    indicator.setFraction(((currentProcessed * 1.0) + data.getIndex() * size) / (totalCount * size));

                    // 执行上传逻辑
                    uploadImage(data, task.imageIterator, markdownImage);
                } catch (Exception e) {
                    log.error("上传图片时发生异常: {}", task.markdownImage.getImageName(), e);
                }
            }, executorService);

            futures.add(future);
        }

        // 等待所有任务完成
        try {
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[] {})).join();
            log.info("图片上传完成，共处理 {} 张图片", totalCount);
        } finally {
            executorService.shutdown();
        }

        return true;
    }

    /**
     * 上传图片的核心逻辑
     *
     * @param data          事件数据
     * @param imageIterator 图片迭代器
     * @param markdownImage 待上传的图片
     */
    private void uploadImage(EventData data, Iterator<MarkdownImage> imageIterator, MarkdownImage markdownImage) {
        String imageName = markdownImage.getImageName();

        // 已上传过的不处理
        if (ImageLocationEnum.NETWORK.equals(markdownImage.getLocation())) {
            log.debug("图片 {} 已经上传过，跳过", imageName);
            return;
        }

        // 验证图片数据
        if (StringUtils.isBlank(imageName) || markdownImage.getInputStream() == null) {
            log.warn("图片名称或输入流为空，移除该图片: {}", markdownImage);
            imageIterator.remove();
            return;
        }

        String imageUrl = null;
        Exception uploadException = null;

        try {
            log.debug("开始上传图片: {}", imageName);
            imageUrl = data.getClient().upload(markdownImage.getInputStream(), markdownImage.getImageName());
            log.debug("图片上传成功: {} -> {}", imageName, imageUrl);
        } catch (Exception e) {
            uploadException = e;
            log.error("上传图片失败: {}, 错误信息: {}", imageName, e.getMessage(), e);
        }

        // 更新图片信息
        String mark;
        if (StringUtils.isBlank(imageUrl)) {
            mark = "![upload error](" + markdownImage.getPath() + ")";
            markdownImage.setLocation(ImageLocationEnum.LOCAL);
            log.warn("图片 {} 上传失败，保留为本地路径", imageName);
        } else {
            mark = "![](" + imageUrl + ")";
            markdownImage.setPath(imageUrl);
            markdownImage.setLocation(ImageLocationEnum.NETWORK);
        }

        markdownImage.setOriginalLineText(mark);
        markdownImage.setOriginalMark(mark);
        markdownImage.setImageMarkType(ImageMarkEnum.ORIGINAL);
        markdownImage.setFinalMark(mark);
    }