package com.ycl.task;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;


/**
 * 图片压缩任务（增强版：支持PNG尺寸压缩）
 * 功能：处理D:/testImage/目录下所有图片，用压缩逻辑压缩后替换原文件
 * 新增：PNG图片按最大宽度/高度限制进行尺寸压缩
 * @author : zxl
 */
@Slf4j
@RequiredArgsConstructor
@Component("imageCompressTask")
public class ImageCompressTask {

    // 本地图片目录（固定为D盘testImage）
    private static final String BASE_DIRECTORY = "/opt/zgyw/uploadPath/";
    // 你定义的支持图片格式集合（完全保留）
    private static final Set<String> IMAGE_FORMATS = new HashSet<>(Arrays.asList(
            "jpg", "jpeg", "png", "gif", "bmp", "webp", "svg", "tiff"
    ));

    // PNG尺寸压缩配置
    private static final int PNG_MAX_WIDTH = 1920;  // PNG最大宽度
    private static final int PNG_MAX_HEIGHT = 1080; // PNG最大高度
    private static final boolean PNG_SCALE_ENABLED = true; // 是否启用PNG尺寸压缩
    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    /**
     * 获取昨天日期的目录路径
     * @return 完整的目录路径，如：/opt/zgyw/uploadPath/2025-09-21
     */
    private String getYesterdayDirectory() {
        LocalDate yesterday = LocalDate.now().minusDays(1);
        String yesterdayStr = yesterday.format(formatter);
        return BASE_DIRECTORY + yesterdayStr;
    }
    /**
     * 主函数：单函数整合本地目录读写+你的压缩逻辑
     */
    public void processLocalImageDirectory() {
        String imageDirectory = getYesterdayDirectory();
        log.info("====== 开始处理本地图片目录：{} ======", imageDirectory);
        log.info("PNG尺寸压缩配置：最大宽度{}px，最大高度{}px，启用状态：{}",
                PNG_MAX_WIDTH, PNG_MAX_HEIGHT, PNG_SCALE_ENABLED);

        // 1. 检查目录有效性
        File imageDir = new File(imageDirectory);
        if (!imageDir.exists() || !imageDir.isDirectory()) {
            log.error("目录不存在或无效：{}", imageDirectory);
            return;
        }

        // 2. 读取目录下所有文件（排除子目录）
        File[] files = imageDir.listFiles(file -> !file.isDirectory());
        if (files == null || files.length == 0) {
            log.info("目录下无文件可处理");
            return;
        }

        // 3. 遍历处理每个本地文件
        int successCount = 0;
        int failCount = 0;
        int skipCount = 0;

        for (File localFile : files) {
            String fileName = localFile.getName();
            String formatName = getFileExtension(fileName);

            if (!isImageFormat(formatName)) {
                log.debug("跳过非图片文件：{}", fileName);
                skipCount++;
                continue;
            }

            try {
                compressAndReplaceLocalFile(localFile, formatName);
                successCount++;
            } catch (Exception e) {
                log.error("压缩图片 {} 失败", fileName, e);
                failCount++;
            }
        }

        // 输出处理结果
        log.info("====== 图片处理完成 ======");
        log.info("统计：成功{}个 | 失败{}个 | 跳过{}个 | 总计{}个",
                successCount, failCount, skipCount, files.length);
    }

    /**
     * 增强版压缩逻辑：支持PNG尺寸压缩 + JPG质量压缩
     */
    private void compressAndReplaceLocalFile(File localFile, String formatName) throws IOException {
        InputStream inputStream = null;
        ByteArrayOutputStream outputStream = null;
        File tempFile = null;

        try {
            inputStream = new FileInputStream(localFile);
            long originalSize = localFile.length();

            // ====================== 增强的压缩逻辑 ======================
            BufferedImage originalImage = ImageIO.read(inputStream);
            if (originalImage == null) {
                throw new IOException("无法读取图片文件：" + localFile.getName());
            }

            outputStream = new ByteArrayOutputStream();

            // PNG特殊处理：尺寸压缩
            if ("png".equalsIgnoreCase(formatName) && PNG_SCALE_ENABLED) {
                BufferedImage scaledImage = scalePngImage(originalImage);
                if (scaledImage != null) {
                    // 使用PNG格式写入缩放后的图片
                    ImageIO.write(scaledImage, "png", outputStream);
                    log.debug("PNG尺寸压缩完成：{}x{} → {}x{}",
                            originalImage.getWidth(), originalImage.getHeight(),
                            scaledImage.getWidth(), scaledImage.getHeight());
                } else {
                    // 缩放失败，使用原图
                    ImageIO.write(originalImage, "png", outputStream);
                }
            }
            // 其他格式：使用原有的质量压缩逻辑
            else {
                Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(formatName);
                if (!writers.hasNext()) {
                    throw new IllegalArgumentException("不支持的图片格式: " + formatName);
                }

                ImageWriter writer = writers.next();
                ImageWriteParam param = writer.getDefaultWriteParam();

                if (param.canWriteCompressed()) {
                    param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                    param.setCompressionQuality(0.1F);
                }

                writer.setOutput(ImageIO.createImageOutputStream(outputStream));
                writer.write(null, new IIOImage(originalImage, null, null), param);
                writer.dispose();
            }

            inputStream.close();
            inputStream = new ByteArrayInputStream(outputStream.toByteArray());
            // ====================== 压缩逻辑结束 ======================

            // 写入临时文件并替换原文件
            tempFile = File.createTempFile("compressed_", "." + formatName);
            try (OutputStream tempOs = new FileOutputStream(tempFile)) {
                byte[] buffer = new byte[1024];
                int len;
                while ((len = inputStream.read(buffer)) != -1) {
                    tempOs.write(buffer, 0, len);
                }
            }

            long compressedSize = tempFile.length();
            if (compressedSize > 0) {
                if (compressedSize < originalSize) {
                    if (localFile.delete()) {
                        if (tempFile.renameTo(localFile)) {
                            log.info("压缩成功：{}（原大小：{}KB → 压缩后：{}KB，减少：{}%）",
                                    localFile.getName(),
                                    originalSize / 1024,
                                    compressedSize / 1024,
                                    String.format("%.1f", (1 - (double)compressedSize / originalSize) * 100));
                        } else {
                            throw new IOException("替换原文件失败");
                        }
                    } else {
                        throw new IOException("删除原文件失败（可能被占用）");
                    }
                } else {
                    log.warn("压缩无效（体积未减小）：{}（原大小：{}KB，压缩后：{}KB）",
                            localFile.getName(), originalSize / 1024, compressedSize / 1024);
                    // 即使体积未减小也替换，因为可能是PNG尺寸压缩但质量更好的情况
                    if (localFile.delete() && tempFile.renameTo(localFile)) {
                        log.info("图片已优化（质量提升）：{}", localFile.getName());
                    }
                }
            } else {
                throw new IOException("压缩后文件为空");
            }

        } finally {
            // 清理资源
            if (inputStream != null) {
                try { inputStream.close(); } catch (IOException e) { log.error("输入流关闭失败", e); }
            }
            if (outputStream != null) {
                try { outputStream.close(); } catch (IOException e) { log.error("输出流关闭失败", e); }
            }
            if (tempFile != null && tempFile.exists() && !tempFile.delete()) {
                log.warn("临时文件清理失败：{}", tempFile.getAbsolutePath());
            }
        }
    }

    /**
     * PNG尺寸压缩：按比例缩放图片到最大尺寸限制内
     */
    private BufferedImage scalePngImage(BufferedImage originalImage) {
        int originalWidth = originalImage.getWidth();
        int originalHeight = originalImage.getHeight();

        // 检查是否需要缩放
        if (originalWidth <= PNG_MAX_WIDTH && originalHeight <= PNG_MAX_HEIGHT) {
            log.debug("PNG图片尺寸未超限，无需缩放：{}x{}", originalWidth, originalHeight);
            return null;
        }

        // 计算缩放比例
        double widthRatio = (double) PNG_MAX_WIDTH / originalWidth;
        double heightRatio = (double) PNG_MAX_HEIGHT / originalHeight;
        double ratio = Math.min(widthRatio, heightRatio);

        int newWidth = (int) (originalWidth * ratio);
        int newHeight = (int) (originalHeight * ratio);

        // 确保尺寸不为0
        if (newWidth <= 0) newWidth = 1;
        if (newHeight <= 0) newHeight = 1;

        log.debug("PNG缩放比例：{} → 新尺寸：{}x{}", ratio, newWidth, newHeight);

        // 创建缩放后的图片
        BufferedImage scaledImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = scaledImage.createGraphics();

        // 设置渲染参数以获得更好的缩放质量
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        // 绘制缩放后的图片
        g2d.drawImage(originalImage, 0, 0, newWidth, newHeight, null);
        g2d.dispose();

        return scaledImage;
    }

    /**
     * 完全保留你的方法：获取文件扩展名
     */
    private static String getFileExtension(String fileName) {
        if (fileName == null || !fileName.contains(".")) {
            return "jpg";
        }
        return fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
    }

    /**
     * 完全保留你的方法：判断是否为图片格式
     */
    private static boolean isImageFormat(String formatName) {
        if (formatName == null || formatName.isEmpty()) {
            return false;
        }
        return IMAGE_FORMATS.contains(formatName.toLowerCase());
    }
}