package com.bs.ct.utils;


import org.bytedeco.ffmpeg.global.avcodec;
import org.bytedeco.ffmpeg.global.avutil;
import org.bytedeco.javacv.FFmpegFrameRecorder;
import org.bytedeco.javacv.FrameRecorder;
import org.bytedeco.javacv.Java2DFrameConverter;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.imageio.ImageIO;

/**
 * @author oucq
 * @version Aug 3, 2016 6:13:55 PM
 *
 *          该类实现了图片的合并功能，可以选择水平合并或者垂直合并，还可以合并成九宫格、四宫格等类型。
 */
public class OperateImageUtils {

    /**
     * @param fileUrl
     *            文件绝对路径或相对路径
     * @return 读取到的缓存图像
     * @throws IOException
     *             路径错误或者不存在该文件时抛出IO异常
     */
    public static BufferedImage getBufferedImage(String fileUrl) throws IOException {
        File f = new File(fileUrl);
        return ImageIO.read(f);
    }

    /**
     * @param savedImg
     *            待保存的图像
     * @param saveDir
     *            保存的目录
     * @param fileName
     *            保存的文件名，必须带后缀，比如 "beauty.jpg"
     * @param format
     *            文件格式：jpg、png或者bmp
     * @return
     */
    public static boolean saveImage(BufferedImage savedImg, String saveDir, String fileName, String format) {
        boolean flag = false;

        // 先检查保存的图片格式是否正确
        String[] legalFormats = { "jpg", "JPG", "png", "PNG", "bmp", "BMP" };
        int i = 0;
        for (i = 0; i < legalFormats.length; i++) {
            if (format.equals(legalFormats[i])) {
                break;
            }
        }
        if (i == legalFormats.length) { // 图片格式不支持
            System.out.println("不是保存所支持的图片格式!");
            return false;
        }

        // 再检查文件后缀和保存的格式是否一致
        String postfix = fileName.substring(fileName.lastIndexOf('.') + 1);
        if (!postfix.equalsIgnoreCase(format)) {
            System.out.println("待保存文件后缀和保存的格式不一致!");
            return false;
        }

        String fileUrl = "";
        if (saveDir.endsWith("/") || saveDir.endsWith("\\")) {
            fileUrl = saveDir + fileName;
        } else {
            fileUrl = saveDir + "/" + fileName;
        }
        File file = new File(fileUrl);
        try {
            flag = ImageIO.write(savedImg, format, file);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 待合并的两张图必须满足这样的前提，如果水平方向合并，则高度必须相等；如果是垂直方向合并，宽度必须相等。
     * mergeImage方法不做判断，自己判断。
     *
     * @param img1
     *            待合并的第一张图
     * @param img2
     *            带合并的第二张图
     * @param isHorizontal
     *            为true时表示水平方向合并，为false时表示垂直方向合并
     * @return 返回合并后的BufferedImage对象
     * @throws IOException
     */
    public static BufferedImage mergeImage(boolean isHorizontal, BufferedImage img1, BufferedImage img2)
            throws IOException {
        int w1 = img1.getWidth();
        int h1 = img1.getHeight();
        int w2 = img2.getWidth();
        int h2 = img2.getHeight();

        // 从图片中读取RGB
        int[] ImageArrayOne = new int[w1 * h1];
        ImageArrayOne = img1.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 逐行扫描图像中各个像素的RGB到数组中
        int[] ImageArrayTwo = new int[w2 * h2];
        ImageArrayTwo = img2.getRGB(0, 0, w2, h2, ImageArrayTwo, 0, w2);

        // 生成新图片
        BufferedImage DestImage = null;
        if (isHorizontal) { // 水平方向合并
            DestImage = new BufferedImage(w1 + w2, h1, BufferedImage.TYPE_INT_RGB);
            DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
            DestImage.setRGB(w1, 0, w2, h2, ImageArrayTwo, 0, w2);
        } else { // 垂直方向合并
            DestImage = new BufferedImage(w1, h1 + h2, BufferedImage.TYPE_INT_RGB);
            DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
            DestImage.setRGB(0, h1, w2, h2, ImageArrayTwo, 0, w2); // 设置下半部分的RGB
        }

        return DestImage;
    }

    /**
     * 合并任数量的图片成一张图片
     *
     * @param isHorizontal true代表水平合并，false代表垂直合并
     * @param imgs         欲合并的图片数组
     * @return
     * @throws IOException
     */
    public static BufferedImage mergeImage(boolean isHorizontal, BufferedImage... imgs) throws IOException {
        // 生成新图片
        BufferedImage DestImage = null;

        // 计算新图片的长和高
        int allw = 0, allh = 0, allwMax = 0, allhMax = 0;
        for (BufferedImage img : imgs) {
            allw += img.getWidth();
            allh += img.getHeight();
            if (img.getWidth() > allwMax) {
                allwMax = img.getWidth();
            }
            if (img.getHeight() > allhMax) {
                allhMax = img.getHeight();
            }
        }
        // 创建新图片
        if (isHorizontal) {
            DestImage = new BufferedImage(allw, allhMax, BufferedImage.TYPE_INT_RGB);
        } else {
            DestImage = new BufferedImage(allwMax, allh, BufferedImage.TYPE_INT_RGB);
        }

        // 合并所有子图片到新图片
        int wx = 0, wy = 0;
        for (int i = 0; i < imgs.length; i++) {
            BufferedImage img = imgs[i];
            int w1 = img.getWidth();
            int h1 = img.getHeight();
            // 从图片中读取RGB
            int[] ImageArrayOne = new int[w1 * h1];
            ImageArrayOne = img.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 逐行扫描图像中各个像素的RGB到数组中
            if (isHorizontal) { // 水平方向合并
                DestImage.setRGB(wx, 0, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
            } else { // 垂直方向合并
                DestImage.setRGB(0, wy, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
            }
            wx += w1;
            wy += h1;
        }
        return DestImage;
    }

    /**
     * 合并图片成指定行数和列数的网格
     *
     * @param rows 行数
     * @param cols 列数
     * @param imgs 欲合并的图片数组
     * @return 合并后的BufferedImage对象
     * @throws IOException
     */
    public static BufferedImage mergeImageToGrid(int rows, int cols, BufferedImage... imgs) throws IOException {
        if (imgs.length < rows * cols) {
            throw new IllegalArgumentException("图片数量不足，无法组成指定的网格");
        }

        // 计算新图片的宽度和高度
        int maxWidth = 0;
        int maxHeight = 0;
        for (BufferedImage img : imgs) {
            maxWidth = Math.max(maxWidth, img.getWidth());
            maxHeight = Math.max(maxHeight, img.getHeight());
        }
        int newWidth = maxWidth * cols;
        int newHeight = maxHeight * rows;

        // 创建新图片
        BufferedImage destImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);

        // 合并图片到新图片
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int index = i * cols + j;
                BufferedImage img = imgs[index];
                int x = j * maxWidth;
                int y = i * maxHeight;
                int[] imageArray = new int[img.getWidth() * img.getHeight()];
                imageArray = img.getRGB(0, 0, img.getWidth(), img.getHeight(), imageArray, 0, img.getWidth());
                destImage.setRGB(x, y, img.getWidth(), img.getHeight(), imageArray, 0, img.getWidth());
            }
        }

        return destImage;
    }

    public static void createMp4(String saveDir, String fileName, Map<Integer, File> imgMap, int width, int height) throws FrameRecorder.Exception {
        String mp4SavePath = "";
        if (saveDir.endsWith("/") || saveDir.endsWith("\\")) {
            mp4SavePath = saveDir + fileName;
        } else {
            mp4SavePath = saveDir + "/" + fileName;
        }
        // 调整宽度和高度为偶数
        width = width % 2 == 0 ? width : width + 1;
        height = height % 2 == 0 ? height : height + 1;

        // 视频宽高最好是按照常见的视频的宽高  16：9  或者 9：16
        FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(mp4SavePath, width, height);
        // 设置视频编码层模式
        recorder.setVideoCodec(avcodec.AV_CODEC_ID_H264);
        // 设置视频为25帧每秒
        recorder.setFrameRate(25);
        // 设置视频图像数据格式
        recorder.setPixelFormat(avutil.AV_PIX_FMT_YUV420P);

        recorder.setFormat("mp4");
        try {
            recorder.start();
            Java2DFrameConverter converter = new Java2DFrameConverter();
            // 录制一个22秒的视频,22秒为自定义的一个视频时间长度,图片少则在22秒内,多则到22秒停止
            for (int i = 0; i < 22; i++) {
                if (imgMap.containsKey(i)) {
                    BufferedImage read = ImageIO.read(imgMap.get(i));
                    // 调整图片尺寸为偶数
                    read = resizeToEven(read);
                    // 转换图像颜色模式为 TYPE_3BYTE_BGR
                    BufferedImage bgrImage = new BufferedImage(read.getWidth(), read.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
                    java.awt.Graphics g = bgrImage.getGraphics();
                    g.drawImage(read, 0, 0, null);
                    g.dispose();

                    // 一秒是25帧 所以要记录25次
                    for (int j = 0; j < 25; j++) {
                        recorder.record(converter.getFrame(bgrImage));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 最后一定要结束并释放资源
            recorder.stop();
            recorder.release();
        }
    }

    public static BufferedImage resizeToEven(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        width = width % 2 == 0 ? width : width + 1;
        height = height % 2 == 0 ? height : height + 1;
        java.awt.Image tmp = image.getScaledInstance(width, height, java.awt.Image.SCALE_SMOOTH);
        BufferedImage resized = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        java.awt.Graphics2D g2d = resized.createGraphics();
        g2d.drawImage(tmp, 0, 0, null);
        g2d.dispose();
        return resized;
    }


    public static void main(String[] args) {
        try {
            // 读取待合并的文件
            BufferedImage[] imgs = new BufferedImage[9];
            Map<Integer, File> imgMap = new HashMap<>();
            for (int i = 0; i < 9; i++) {
                imgs[i] = getBufferedImage("D:\\edge下载\\下载\\1_2019年-2024年数据\\" + (i + 1) + ".jpg");
                imgMap.put(i, new File("D:\\edge下载\\下载\\1_2019年-2024年数据\\" + (i + 1) + ".jpg"));
            }

            // 合并成九宫格
            BufferedImage destImg = mergeImageToGrid(3, 3, imgs);
            saveImage(destImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "nineGrid.jpg", "jpg");
            System.out.println("九宫格合并完毕!");

            // 合并成四宫格
            BufferedImage[] fourImgs = new BufferedImage[4];
            System.arraycopy(imgs, 0, fourImgs, 0, 4);
            destImg = mergeImageToGrid(2, 2, fourImgs);
            saveImage(destImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "fourGrid.jpg", "jpg");
            System.out.println("四宫格合并完毕!");

            // 测试水平合并
            BufferedImage horizontalMergedImg = mergeImage(true, imgs[0], imgs[1]);
            saveImage(horizontalMergedImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "horizontalMerge.jpg", "jpg");
            System.out.println("水平合并完毕!");

            // 测试垂直合并
            BufferedImage verticalMergedImg = mergeImage(false, imgs[0], imgs[1]);
            saveImage(verticalMergedImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "verticalMerge.jpg", "jpg");
            System.out.println("垂直合并完毕!");

            // 测试多张图片水平合并
            BufferedImage multiHorizontalMergedImg = mergeImage(true, imgs[0], imgs[1], imgs[2]);
            saveImage(multiHorizontalMergedImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "multiHorizontalMerge.jpg", "jpg");
            System.out.println("多张图片水平合并完毕!");

            // 测试多张图片垂直合并
            BufferedImage multiVerticalMergedImg = mergeImage(false, imgs[0], imgs[1], imgs[2]);
            saveImage(multiVerticalMergedImg, "D:\\edge下载\\下载\\1_2019年-2024年数据\\", "multiVerticalMerge.jpg", "jpg");
            System.out.println("多张图片垂直合并完毕!");

            // 测试图片转视频
            int width = imgs[0].getWidth();
            int height = imgs[0].getHeight();
            String mp4SavePath = "\\output.mp4";
            createMp4("D:\\edge下载\\下载\\1_2019年-2024年数据", mp4SavePath, imgMap, width, height);
            System.out.println("MP4视频生成完毕!");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}