package com.phlx.anchorcollect.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.os.Environment;
import android.util.Base64;
import android.util.Log;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * 作者 : lei
 * 时间 : 2018/12/27 11 : 31
 */
public class BaseImageUtils {
    //把bitmap转换成String
    public static String bitmapToString(String filePath, Context context) {
        Bitmap bm = decodeBitmap(filePath, context);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.JPEG, 80, baos);
        byte[] b = baos.toByteArray();
        Log.d("d", "压缩后的大小=" + b.length);
        return Base64.encodeToString(b, Base64.DEFAULT);
    }

    /**
     * 2      * 加载本地大图片
     * 3      *
     * 4      * @param localPath
     * 5      * @param context
     * 6      * @return
     * 7
     */
    public static Bitmap decodeBitmap(String localPath, Context context) {
        BitmapFactory.Options opts = new BitmapFactory.Options();
        // 置为true,仅仅返回图片的分辨率
        opts.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(localPath, opts);
        // 得到原图的分辨率;
        int srcHeight = opts.outHeight;
        int srcWidth = opts.outWidth;
        // 得到设备的分辨率
        int screenHeight = context.getResources().getDisplayMetrics().heightPixels;
        int screenWidth = context.getResources().getDisplayMetrics().widthPixels;
        // 通过比较得到合适的比例值;
        // 屏幕的 宽320 高 480 ,图片的宽3000 ,高是2262  3000/320=9  2262/480=5,,使用大的比例值
        int scale = 1;
        int sx = srcWidth / screenWidth;
        int sy = srcHeight / screenHeight;
        if (sx >= sy && sx > 1) {
            scale = sx;
        }
        if (sy >= sx && sy > 1) {
            scale = sy;
        }
        // 根据比例值,缩放图片,并加载到内存中;
        // 置为false,让BitmapFactory.decodeFile()返回一个图片对象
        opts.inJustDecodeBounds = false;
        // 可以把图片缩放为原图的1/scale * 1/scale
        opts.inSampleSize = scale;
        // 得到缩放后的bitmap
        //        Bitmap bm = BitmapFactory.decodeFile(Environment.getExternalStorageDirectory()
        // + "/lp.jpg", opts);
        return BitmapFactory.decodeFile(localPath, opts);
    }


    //base64字符串转化成图片
    public static boolean saveBaseImage(String base64, String path) {
        try {
            byte[] b = Base64.decode(base64, Base64.DEFAULT);

            //生成jpeg图片
            OutputStream out = new FileOutputStream(path);
            out.write(b);
            out.flush();
            out.close();
            return true;
        } catch (Exception e) {
            Log.e("saveBaseImage", e.toString());
            return false;
        }
    }


    /**
     * 将bitmap对象保存成图片到sd卡中
     */
    public static void saveBitmapToSDCard(Bitmap bitmap, String path) {
        File folder = new File(Environment.getExternalStorageDirectory()
                .getAbsolutePath() +
                "/collect/picture");
        if (!folder.exists()) {
            folder.mkdirs();
        }

        File file = new File(path);

        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 50, ((OutputStream) fileOutputStream));
            //设置PNG的话，透明区域不会变成黑色

            fileOutputStream.close();
            System.out.println("----------save success-------------------");
            recycle(bitmap);
        } catch (Exception v0) {
            v0.printStackTrace();
        }

    }


    /**
     * 回收Bitmap
     *
     * @param thumbBmp 需要被回收的bitmap
     */
    public static void recycle(Bitmap thumbBmp) {
        if (thumbBmp != null && !thumbBmp.isRecycled()) {
            thumbBmp.recycle();
        }
    }

    /**
     * 获取图片的旋转角度
     *
     * @param path 图片绝对路径
     * @return 图片的旋转角度
     */
    public static int getBitmapDegree(String path) {
        int degree = 0;
        try {
            // 从指定路径下读取图片，并获取其EXIF信息
            ExifInterface exifInterface = new ExifInterface(path);
            // 获取图片的旋转信息
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    /**
     * 将图片按照指定的角度进行旋转
     *
     * @param bitmap 需要旋转的图片
     * @param degree 指定的旋转角度
     * @return 旋转后的图片
     */
    public static Bitmap rotateBitmapByDegree(Bitmap bitmap, int degree) {
        // 根据旋转角度，生成旋转矩阵
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);
        // 将原始图片按照旋转矩阵进行旋转，并得到新的图片
        Bitmap newBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        if (bitmap != null && !bitmap.isRecycled()) {
            bitmap.recycle();
        }
        return newBitmap;
    }

}
