import lombok.extern.slf4j.Slf4j;

 import org.w3c.dom.Element;

 import javax.imageio.IIOImage;

 import javax.imageio.ImageIO;

 import javax.imageio.ImageTypeSpecifier;

 import javax.imageio.ImageWriter;

 import javax.imageio.metadata.IIOMetadata;

 import javax.imageio.plugins.jpeg.JPEGImageWriteParam;

 import javax.imageio.stream.ImageOutputStream;

 import java.awt.*;

 import java.awt.image.BufferedImage;

 import java.io.*;

 import java.net.HttpURLConnection;

 import java.net.URL;

 /**

  * @Author: Mr. Chang

  */

 @Slf4j

 public class ImageZipUtils {

     /**

      * 采用指定宽度、高度或压缩比例 的方式对图片进行压缩

      *

      * @param imgsrc     源图片地址

      * @param imgdist    目标图片地址

      * @param widthdist  压缩后图片宽度（当rate==null时，必传）

      * @param heightdist 压缩后图片高度（当rate==null时，必传）

      * @param rate       压缩比例

      */

     public static void reduceImg(String imgsrc, String imgdist, int widthdist,

                                  int heightdist, Float rate) {

         try {

             File srcfile = new File(imgsrc);

             // 检查文件是否存在

             if (!srcfile.exists()) {

                 return;

             }

             // 如果rate不为空说明是按比例压缩

             if (rate != null && rate > 0) {

                 // 获取文件高度和宽度

                 int[] results = getImgWidth(srcfile);

                 if (results == null || results[0] == 0 || results[1] == 0) {

                     return;

                 } else {

                     widthdist = (int) (results[0] * rate);

                     heightdist = (int) (results[1] * rate);

                 }

             }

             // 开始读取文件并进行压缩

             Image src = javax.imageio.ImageIO.read(srcfile);

             BufferedImage tag = new BufferedImage((int) widthdist,

                     (int) heightdist, BufferedImage.TYPE_INT_RGB);

             tag.getGraphics().drawImage(

                     src.getScaledInstance(widthdist, heightdist,

                             Image.SCALE_SMOOTH), 0, 0, null);

             FileOutputStream out = new FileOutputStream(imgdist);

 //            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

 //            encoder.encode(tag);

 //            out.close();

             float per = (float) 0.85;

             saveAsJPEG(100, tag, per, out);

         } catch (IOException ex) {

             ex.printStackTrace();

         }

     }

     /**

      * 以JPEG编码保存图片

      *

      * @param dpi             分辨率

      * @param image_to_save   要处理的图像图片

      * @param JPEGcompression 压缩比

      * @param fos             文件输出流

      * @throws IOException

      */

     public static void saveAsJPEG(Integer dpi, BufferedImage image_to_save, float JPEGcompression, FileOutputStream fos) throws IOException {

         // Image writer

         ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpg").next();

         ImageOutputStream ios = ImageIO.createImageOutputStream(fos);

         imageWriter.setOutput(ios);

         //and metadata

         IIOMetadata imageMetaData = imageWriter.getDefaultImageMetadata(new ImageTypeSpecifier(image_to_save), null);

         if (dpi != null && !dpi.equals("")) {

             //new metadata

             Element tree = (Element) imageMetaData.getAsTree("javax_imageio_jpeg_image_1.0");

             Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);

             jfif.setAttribute("Xdensity", Integer.toString(dpi));

             jfif.setAttribute("Ydensity", Integer.toString(dpi));

         }

         if (JPEGcompression >= 0 && JPEGcompression <= 1f) {

             // new Compression

             JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();

             jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);

             jpegParams.setCompressionQuality(JPEGcompression);

         }

         //new Write and clean up

         imageWriter.write(imageMetaData, new IIOImage(image_to_save, null, null), null);

         ios.close();

         imageWriter.dispose();

     }

     /**

      * 获取图片宽度

      *

      * @param file 图片文件

      * @return 宽度

      */

     public static int[] getImgWidth(File file) {

         InputStream is = null;

         BufferedImage src = null;

         int result[] = {0, 0};

         try {

             is = new FileInputStream(file);

             src = javax.imageio.ImageIO.read(is);

             result[0] = src.getWidth(null); // 得到源图宽

             result[1] = src.getHeight(null); // 得到源图高

             is.close();

         } catch (Exception e) {

             e.printStackTrace();

         }

         return result;

     }

     public static byte[] readInputStream(InputStream inStream) throws Exception {

         ByteArrayOutputStream outStream = new ByteArrayOutputStream();

         //创建一个Buffer字符串

         byte[] buffer = new byte[1024];

         //每次读取的字符串长度，如果为-1，代表全部读取完毕

         int len = 0;

         //使用一个输入流从buffer里把数据读取出来

         while ((len = inStream.read(buffer)) != -1) {

             //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度

             outStream.write(buffer, 0, len);

         }

         //关闭输入流

         inStream.close();

         //把outStream里的数据写入内存

         return outStream.toByteArray();

     }

     /**

      * 保存自拍照片

      * @param userId

      * @param photo_url

      * @param suffixFromUrl

      * @param path

      * @throws Exception

      */

     public static void saveZipImage(Integer userId, String photo_url, String suffixFromUrl, String path) throws Exception {

         //new一个URL对象

         URL url = new URL(photo_url);

         //打开链接

         HttpURLConnection conn = (HttpURLConnection) url.openConnection();

         //设置请求方式为"GET"

         conn.setRequestMethod("GET");

         //超时响应时间为5秒

         conn.setConnectTimeout(5 * 1000);

         //通过输入流获取图片数据

         InputStream inStream = conn.getInputStream();

         //得到图片的二进制数据，以二进制封装得到数据，具有通用性

         byte[] data = readInputStream(inStream);

         //new一个文件对象用来保存图片，默认保存当前工程根目录

         File imageFile = new File(path + userId + suffixFromUrl);

         //创建输出流

         FileOutputStream outStream = new FileOutputStream(imageFile);

         //写入数据

         outStream.write(data);

         //关闭输出流

         outStream.close();

     }

     /**

      * 开始压缩图片

      * @param userId

      * @param suffix

      * @param path

      * @return

      */

     public static String imageZipStart(Integer userId, String suffix, String path) {

         /**

          * d://3.jpg 源图片

          * d://31.jpg 目标图片

          * 压缩宽度和高度都是1000

          *

          */

         String original = path + userId + suffix;

         String target = path + userId + "target" + suffix;

         File srcfile = new File(original);

         log.info(userId + "用户自拍照压缩前自拍照大小:" + srcfile.length());

         reduceImg(original, target, 888, 888, null);

         File distfile = new File(target);

         log.info("用户自拍照压缩后自拍照大小:" + distfile.length());

         return target;

     }

     /**

      * 删除文件

      */

     public static void delFile(String fileName) {

         File deFile = new File(fileName);

         if (deFile.exists()) {

             deFile.delete();

         }

     }

 }