package com.ruoyi.common.utils.image;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;

/**
 * 图片压缩工具类
 * 专为OCR识别优化，在保证文字清晰度的前提下压缩图片大小
 * 
 * @author ruoyi
 * @date 2025-01-20
 */
public class ImageCompressUtil {
    
    private static final Logger log = LoggerFactory.getLogger(ImageCompressUtil.class);
    
    /**
     * 默认最大文件大小（10MB）
     */
    public static final long DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
    
    /**
     * OCR最佳识别分辨率（最小边像素）
     */
    public static final int OCR_OPTIMAL_MIN_SIZE = 1500;
    
    /**
     * 高质量压缩质量参数（0.90 = 90%质量）
     */
    public static final float HIGH_QUALITY = 0.90f;
    
    /**
     * 中等质量压缩质量参数（0.80 = 80%质量）
     */
    public static final float MEDIUM_QUALITY = 0.80f;
    
    /**
     * 低质量压缩质量参数（0.75 = 75%质量）
     */
    public static final float LOW_QUALITY = 0.75f;
    
    /**
     * 智能压缩图片（针对OCR优化）
     * 使用默认3MB限制
     * 
     * @param file 上传的图片文件
     * @return 压缩后的临时文件
     * @throws IOException IO异常
     */
    public static File compressForOCR(MultipartFile file) throws IOException {
        return compressForOCR(file, DEFAULT_MAX_FILE_SIZE);
    }
    
    /**
     * 智能压缩图片（针对OCR优化）
     * 保证识别准确率的同时压缩到指定大小以下
     * 
     * @param file 上传的图片文件
     * @param maxSize 最大文件大小（字节）
     * @return 压缩后的临时文件
     * @throws IOException IO异常
     */
    public static File compressForOCR(MultipartFile file, long maxSize) throws IOException {
        long fileSize = file.getSize();
        
        // 如果文件小于限制，直接保存
        if (fileSize <= maxSize) {
            log.debug("图片大小 {} KB 未超过限制 {} KB，无需压缩", 
                fileSize / 1024.0, maxSize / 1024.0);
            return saveToTempFile(file);
        }
        
        log.info("图片大小 {} MB 超过限制 {} MB，开始智能压缩...", 
            fileSize / 1024.0 / 1024.0, maxSize / 1024.0 / 1024.0);
        
        // 读取原始图片
        BufferedImage originalImage = ImageIO.read(file.getInputStream());
        if (originalImage == null) {
            throw new IOException("无法读取图片文件，可能格式不支持");
        }
        
        int originalWidth = originalImage.getWidth();
        int originalHeight = originalImage.getHeight();
        log.info("原始图片尺寸: {}x{}", originalWidth, originalHeight);
        
        // 策略1：先尝试高质量JPEG压缩（不改变尺寸）
        File compressedFile = compressWithQuality(originalImage, file.getOriginalFilename(), HIGH_QUALITY);
        
        if (compressedFile.length() <= maxSize) {
            log.info("压缩成功（高质量压缩），文件大小: {} MB", 
                compressedFile.length() / 1024.0 / 1024.0);
            return compressedFile;
        }
        
        // 策略2：如果还是太大，适度缩小尺寸（保证OCR识别）
        double scaleFactor = calculateScaleFactor(originalWidth, originalHeight, maxSize, compressedFile.length());
        
        if (scaleFactor < 1.0) {
            int newWidth = (int) (originalWidth * scaleFactor);
            int newHeight = (int) (originalHeight * scaleFactor);
            log.info("调整图片尺寸至: {}x{} (缩放比例: {}%)", 
                newWidth, newHeight, (int)(scaleFactor * 100));
            
            BufferedImage resizedImage = resizeImageHighQuality(originalImage, newWidth, newHeight);
            compressedFile.delete(); // 删除之前的临时文件
            compressedFile = compressWithQuality(resizedImage, file.getOriginalFilename(), HIGH_QUALITY);
        }
        
        // 策略3：如果还是太大，降低压缩质量（最后手段）
        if (compressedFile.length() > maxSize) {
            log.warn("尺寸调整后仍超限，降低压缩质量");
            BufferedImage finalImage;
            if (scaleFactor < 1.0) {
                int newWidth = (int) (originalWidth * scaleFactor);
                int newHeight = (int) (originalHeight * scaleFactor);
                finalImage = resizeImageHighQuality(originalImage, newWidth, newHeight);
            } else {
                finalImage = originalImage;
            }
            
            compressedFile.delete(); // 删除之前的临时文件
            
            // 尝试中等质量
            compressedFile = compressWithQuality(finalImage, file.getOriginalFilename(), MEDIUM_QUALITY);
            
            // 如果还不行，使用低质量
            if (compressedFile.length() > maxSize) {
                log.warn("使用低质量压缩（75%）");
                compressedFile.delete();
                compressedFile = compressWithQuality(finalImage, file.getOriginalFilename(), LOW_QUALITY);
            }
        }
        
        long finalSize = compressedFile.length();
        double compressionRatio = (1 - (double)finalSize / fileSize) * 100;
        log.info("最终压缩完成，文件大小: {} MB (压缩率: {}%)", 
            finalSize / 1024.0 / 1024.0, (int)compressionRatio);
        
        if (finalSize > maxSize) {
            log.warn("警告：压缩后文件大小 {} MB 仍超过限制 {} MB", 
                finalSize / 1024.0 / 1024.0, maxSize / 1024.0 / 1024.0);
        }
        
        return compressedFile;
    }
    
    /**
     * 使用指定质量压缩图片为JPEG格式
     * 
     * @param image 图片对象
     * @param originalFilename 原始文件名
     * @param quality 压缩质量（0.0-1.0）
     * @return 压缩后的文件
     * @throws IOException IO异常
     */
    public static File compressWithQuality(BufferedImage image, String originalFilename, float quality) throws IOException {
        if (quality < 0.0f || quality > 1.0f) {
            throw new IllegalArgumentException("压缩质量必须在0.0到1.0之间");
        }
        
        // 转换为RGB格式（JPEG不支持透明度）
        BufferedImage rgbImage = convertToRGB(image);
        
        // 创建临时文件
        String tempDir = System.getProperty("java.io.tmpdir");
        String filename = System.currentTimeMillis() + "_compressed_" + 
            getJpegFilename(originalFilename);
        File outputFile = new File(tempDir, filename);
        
        // 使用ImageWriter进行高质量压缩
        Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
        if (!writers.hasNext()) {
            throw new IOException("系统不支持JPEG编码");
        }
        
        ImageWriter writer = writers.next();
        ImageWriteParam param = writer.getDefaultWriteParam();
        
        // 设置压缩模式和质量
        param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        param.setCompressionQuality(quality);
        
        try (ImageOutputStream ios = ImageIO.createImageOutputStream(outputFile)) {
            writer.setOutput(ios);
            writer.write(null, new IIOImage(rgbImage, null, null), param);
        } finally {
            writer.dispose();
        }
        
        log.debug("压缩完成，质量: {}%, 文件大小: {} KB", 
            (int)(quality * 100), outputFile.length() / 1024.0);
        
        return outputFile;
    }
    
    /**
     * 高质量图片缩放（专为OCR优化）
     * 使用双三次插值算法保证文字清晰度
     * 
     * @param originalImage 原始图片
     * @param targetWidth 目标宽度
     * @param targetHeight 目标高度
     * @return 缩放后的图片
     */
    public static BufferedImage resizeImageHighQuality(BufferedImage originalImage, int targetWidth, int targetHeight) {
        if (targetWidth <= 0 || targetHeight <= 0) {
            throw new IllegalArgumentException("目标宽度和高度必须大于0");
        }
        
        BufferedImage resizedImage = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = resizedImage.createGraphics();
        
        try {
            // 设置高质量渲染参数（关键！）
            g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
            
            g2d.drawImage(originalImage, 0, 0, targetWidth, targetHeight, null);
        } finally {
            g2d.dispose();
        }
        
        return resizedImage;
    }
    
    /**
     * 通用图片压缩（按目标宽高）
     * 
     * @param file 上传的图片文件
     * @param targetWidth 目标宽度
     * @param targetHeight 目标高度
     * @param quality 压缩质量（0.0-1.0）
     * @return 压缩后的文件
     * @throws IOException IO异常
     */
    public static File compress(MultipartFile file, int targetWidth, int targetHeight, float quality) throws IOException {
        BufferedImage originalImage = ImageIO.read(file.getInputStream());
        if (originalImage == null) {
            throw new IOException("无法读取图片文件");
        }
        
        BufferedImage resizedImage = resizeImageHighQuality(originalImage, targetWidth, targetHeight);
        return compressWithQuality(resizedImage, file.getOriginalFilename(), quality);
    }
    
    /**
     * 按比例压缩图片
     * 
     * @param file 上传的图片文件
     * @param scale 缩放比例（0.0-1.0）
     * @param quality 压缩质量（0.0-1.0）
     * @return 压缩后的文件
     * @throws IOException IO异常
     */
    public static File compressByScale(MultipartFile file, double scale, float quality) throws IOException {
        if (scale <= 0.0 || scale > 1.0) {
            throw new IllegalArgumentException("缩放比例必须在0.0到1.0之间");
        }
        
        BufferedImage originalImage = ImageIO.read(file.getInputStream());
        if (originalImage == null) {
            throw new IOException("无法读取图片文件");
        }
        
        int newWidth = (int) (originalImage.getWidth() * scale);
        int newHeight = (int) (originalImage.getHeight() * scale);
        
        BufferedImage resizedImage = resizeImageHighQuality(originalImage, newWidth, newHeight);
        return compressWithQuality(resizedImage, file.getOriginalFilename(), quality);
    }
    
    /**
     * 计算最佳缩放比例
     * 
     * @param width 原始宽度
     * @param height 原始高度
     * @param targetSize 目标文件大小
     * @param currentSize 当前文件大小
     * @return 缩放比例
     */
    private static double calculateScaleFactor(int width, int height, long targetSize, long currentSize) {
        int minDimension = Math.min(width, height);
        double scaleFactor = 1.0;
        
        // 基于文件大小估算缩放比例
        double sizeRatio = Math.sqrt((double) targetSize / currentSize);
        
        // 保护最小尺寸（保证OCR识别）
        if (minDimension > 2000) {
            // 大图片，可以适度缩小
            scaleFactor = Math.min(sizeRatio, 2000.0 / minDimension);
        } else if (minDimension > OCR_OPTIMAL_MIN_SIZE) {
            // 中等图片，轻微缩小
            scaleFactor = Math.min(sizeRatio, (double) OCR_OPTIMAL_MIN_SIZE / minDimension);
        } else {
            // 小图片，尽量不缩小
            scaleFactor = Math.min(sizeRatio, 0.95);
        }
        
        return scaleFactor;
    }
    
    /**
     * 将图片转换为RGB格式
     * 
     * @param image 原始图片
     * @return RGB格式图片
     */
    private static BufferedImage convertToRGB(BufferedImage image) {
        if (image.getType() == BufferedImage.TYPE_INT_RGB) {
            return image;
        }
        
        BufferedImage rgbImage = new BufferedImage(
            image.getWidth(), 
            image.getHeight(), 
            BufferedImage.TYPE_INT_RGB
        );
        Graphics2D g = rgbImage.createGraphics();
        try {
            g.drawImage(image, 0, 0, null);
        } finally {
            g.dispose();
        }
        
        return rgbImage;
    }
    
    /**
     * 将文件名转换为JPEG格式
     * 
     * @param originalFilename 原始文件名
     * @return JPEG文件名
     */
    private static String getJpegFilename(String originalFilename) {
        if (originalFilename == null || originalFilename.isEmpty()) {
            return "image.jpg";
        }
        
        return originalFilename.replaceAll("\\.(png|PNG|gif|GIF|bmp|BMP|webp|WEBP)$", ".jpg");
    }
    
    /**
     * 保存MultipartFile到临时文件
     * 
     * @param file 上传的文件
     * @return 临时文件
     * @throws IOException IO异常
     */
    private static File saveToTempFile(MultipartFile file) throws IOException {
        String tempDir = System.getProperty("java.io.tmpdir");
        String originalFilename = file.getOriginalFilename();
        File tempFile = new File(tempDir, System.currentTimeMillis() + "_" + originalFilename);
        file.transferTo(tempFile);
        return tempFile;
    }
}