package com.mogo.utils;

import android.annotation.SuppressLint;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.media.ExifInterface;
import android.media.MediaMetadataRetriever;
import android.net.Uri;
import android.opengl.GLES10;
import android.os.Build;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;

/**
 * @author wangzhiyuan
 * @since 2017/8/30
 */

public class BitmapHelper {
    private static final String TAG = "BitmapHelper";

    static int ONE_KB = 1024;
    static int ONE_MB = ONE_KB * 1024;

    static int SIZE_DEFAULT = 2048;
    static int SIZE_LIMIT = 2048;

    /**
     * 根据原图添加圆角
     *
     * @param source
     * @return
     */
    public static Bitmap createRoundCornerImage( Bitmap source, float corner ) {
        final Paint paint = new Paint();
        paint.setAntiAlias( true );
        Bitmap target = Bitmap.createBitmap( source.getWidth(), source.getHeight(), Bitmap.Config.ARGB_8888 );
        Canvas canvas = new Canvas( target );
        RectF rect = new RectF( 0, 0, source.getWidth(), source.getHeight() );
        canvas.drawRoundRect( rect, corner, corner, paint );
        paint.setXfermode( new PorterDuffXfermode( PorterDuff.Mode.SRC_IN ) );
        canvas.drawBitmap( source, 0, 0, paint );
        return target;
    }

    public static byte[] bitmapToBytes( Bitmap bitmap ) {
        if ( bitmap == null ) {
            return null;
        }

        ByteArrayOutputStream bos = null;
        byte[] result = null;

        try {
            bos = new ByteArrayOutputStream();
            bitmap.compress( Bitmap.CompressFormat.JPEG, 100, bos );
            result = bos.toByteArray();
        } catch ( Exception e ) {
            e.printStackTrace();
            result = null;
        } finally {
            IOUtils.closeSilently( bos );
        }

        return result;
    }

    /**
     * Use quality compression to compress bitmap's size to be smaller than a max size, and convert it to bytes thereafter.
     * Note that this method will not report compressing ratio related data.
     *
     * @param bitmap  data source
     * @param maxSize unit in kb
     * @return bytes after compressing bitmap to a size smaller than a specific max size.
     */
    public static byte[] bitmapToBytes( Bitmap bitmap, int maxSize ) {
        final long start = System.currentTimeMillis();

        if ( bitmap == null ) {
            return null;
        }

        final int maxSizeOfBytes = maxSize * ONE_KB;
        ByteArrayOutputStream bos = null;
        byte[] result = null;

        try {
            bos = new ByteArrayOutputStream();
            int quality = 100;
            int fullSize = 0;

            do {
                bos.reset();
                bitmap.compress( Bitmap.CompressFormat.JPEG, quality, bos );
                if ( quality == 100 ) {
                    fullSize = bos.size();
                }
                Log.i( TAG, "quality<---->size, " + quality + "<---->" + bos.size() / 1024 );
            }
            while ( bos.size() > maxSizeOfBytes && ( quality -= ( fullSize > ONE_MB ) ? 10 : 5 ) >= 0 );

            result = bos.toByteArray();

            final long end = System.currentTimeMillis();
            Log.i( TAG,
                    "bitmap to bytes costs " + ( end - start ) + "ms, \n" +
                            "bitmap full size is " + ( fullSize / 1024 ) + "kb, \n" +
                            "bitmap final size is " + ( bos.size() / 1024 ) + "kb, \n" +
                            "bitmap quality is " + quality );
        } catch ( Exception e ) {
            e.printStackTrace();
            result = null;
        } finally {
            IOUtils.closeSilently( bos );
        }

        return result;
    }

    /**
     * Use quality compression to compress bitmap to be smaller than a specific max size.
     *
     * @param bitmap  data source
     * @param maxSize a specific max size which's unit is kb.
     * @return a compressed bitmap smaller than the max size.
     */
    public static Bitmap compressBitmap( Bitmap bitmap, int maxSize, final OnCompressListener listener ) {
        if ( bitmap == null || bitmap.isRecycled() ) {
            return null;
        }
        listener.onBeforeCompress();
        ByteArrayOutputStream bos = null;
        Bitmap target = null;

        try {
            bos = new ByteArrayOutputStream();
            int quality = 100;

            do {
                bos.reset();
                bitmap.compress( Bitmap.CompressFormat.JPEG, quality, bos );
            }
            while ( bos.size() / 1024 > maxSize && ( quality -= 5 ) >= 0 );

            byte[] result = bos.toByteArray();
            target = bytesToBitmap( result );
            if ( listener != null ) {
                listener.onCompressSuccess( result );
            }
        } catch ( Exception e ) {
            e.printStackTrace();
            target = null;
            if ( listener != null ) {
                listener.onCompressFailed( "压缩失败" );
            }
        } finally {
            IOUtils.closeSilently( bos );
        }

        return target;
    }


    public static Bitmap compressBitmap( Bitmap bitmap, int maxSize ) {
        if ( bitmap == null ) {
            return null;
        }

        ByteArrayOutputStream bos = null;
        Bitmap target = null;

        try {
            bos = new ByteArrayOutputStream();
            int quality = 100;

            do {
                bos.reset();
                bitmap.compress( Bitmap.CompressFormat.JPEG, quality, bos );
            }
            while ( bos.size() / 1024 > maxSize && ( quality -= 5 ) >= 0 );

            byte[] result = bos.toByteArray();
            target = bytesToBitmap( result );
        } catch ( Exception e ) {
            e.printStackTrace();
            target = null;
        } finally {
            IOUtils.closeSilently( bos );
        }

        return target;
    }

    /**
     * Decode an immutable bitmap from the specified byte array.
     *
     * @param b byte array of compressed image data
     * @return an immutable bitmap or null in case of exception.
     */
    public static Bitmap bytesToBitmap( byte[] b ) {
        if ( b != null && b.length != 0 ) {
            return BitmapFactory.decodeByteArray( b, 0, b.length );
        } else {
            return null;
        }
    }

    /**
     * Decode an immutable bitmap from the specified byte array.
     *
     * @param b       byte array of compressed image data
     * @param options Options that control downsampling and whether the
     *                image should be completely decoded, or just is size returned.
     * @return an immutable bitmap or null in case of exception.
     */
    public static Bitmap bytesToBitmap( byte[] b, BitmapFactory.Options options ) {
        if ( b.length != 0 ) {
            return BitmapFactory.decodeByteArray( b, 0, b.length, options );
        } else {
            return null;
        }
    }

    /**
     * Get max supported image size which will differ from different devices.
     *
     * @return max size related to the device.
     */
    public static int getMaxSupportedImageSize() {
        int textureLimit = getMaxTextureSize();
        if ( textureLimit == 0 ) {
            return SIZE_DEFAULT;
        } else {
            return Math.min( textureLimit, SIZE_LIMIT );
        }
    }

    public static int getMaxTextureSize2() {
        // The OpenGL texture size is the maximum size that can be drawn in an ImageView
        int[] maxSize = new int[1];
        GLES10.glGetIntegerv( GLES10.GL_MAX_TEXTURE_SIZE, maxSize, 0 );
        return maxSize[0];
    }

    /**
     * Decode a bitmap's input stream to find a proper inSampleSize according to device's max supported size.
     *
     * @param is    bitmap's data source
     * @param close whether to close input stream after work is done.
     * @return a proper inSampleSize
     */
    public static int findProperInSampleSize( InputStream is, boolean close ) {
        // Just decode image size into options
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;

        try {
            BitmapFactory.decodeStream( is, null, options );
        } catch ( Exception e ) {
            e.printStackTrace();
        } finally {
            if ( close ) IOUtils.closeSilently( is );
        }

        int maxSize = getMaxSupportedImageSize();
        int sampleSize = 1;

        while ( options.outHeight / sampleSize > maxSize || options.outWidth / sampleSize > maxSize ) {
            sampleSize = sampleSize << 1;
        }

        Log.i( TAG, "sample size is " + sampleSize );
        return sampleSize;
    }

    /**
     * Read a picture's degree from a file.
     *
     * @param file data source of a picture
     * @return degrees range from 0 to 360
     */
    public static int readPictureDegree( File file ) {
        return readPictureDegree( file.getAbsolutePath() );
    }

    /**
     * Read a picture's degree from a file, we use {@link ExifInterface} instead of {@link android.media.ExifInterface}
     * to avoid some unexpected bugs.
     *
     * @param filePath file's absolute path which we can read data source of a picture from.
     * @return degrees range from 0 to 360
     */
    public static int readPictureDegree( String filePath ) {
        int degree = 0;

        try {
            ExifInterface exifInterface = new ExifInterface( filePath );
            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 ( Exception e ) {
            e.printStackTrace();
        }
        Log.i( TAG, "ExifInterface, degree is " + degree );

        return degree;
    }

    /**
     * Rotate an bitmap to a specific angle.
     *
     * @param angle  target angle
     * @param bitmap data source
     * @return Returns an immutable bitmap from subset of the source bitmap,
     * transformed by the optional matrix. The new bitmap may be the
     * same object as source, or a copy may have been made. It is
     * initialized with the same density as the original bitmap.
     * <p>
     * If the source bitmap is immutable and the requested subset is the
     * same as the source bitmap itself, then the source bitmap is
     * returned and no new bitmap is created.
     */
    public static Bitmap rotateBitmap( int angle, Bitmap bitmap ) {
        if ( bitmap == null ) {
            return null;
        }

        try {
            int width = bitmap.getWidth();
            int height = bitmap.getHeight();
            Matrix matrix = new Matrix();
            matrix.preRotate( angle );
            return Bitmap.createBitmap( bitmap, 0, 0, width, height, matrix, true );
        } catch ( Exception e ) {
            e.printStackTrace();
            return bitmap;
        }
    }

    /**
     * Get picture's absolute path according to its uri.
     *
     * @param context context
     * @param uri     picture's uri
     * @return absolute path of uri.
     */
    public static String getRealPathFromUri( Context context, Uri uri ) {
        int sdkVersion = Build.VERSION.SDK_INT;
        if ( sdkVersion >= 19 ) {
            return getRealPathFromUriAboveApi19( context, uri );
        } else {
            return getRealPathFromUriBelowAPI19( context, uri );
        }
    }

    /**
     * Create a default {@link BitmapFactory.Options} .
     * Note this options use rgb_565 and a proper inSampleSize in order to save memory.
     *
     * @param is    data source of picture
     * @param close whether to close data source
     * @return options containing rgb_565 config and a proper inSampleSize.
     */
    public static BitmapFactory.Options newDefaultOptions( InputStream is, boolean close ) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inPreferredConfig = Bitmap.Config.RGB_565;
        options.inSampleSize = BitmapHelper.findProperInSampleSize( is, close );

        return options;
    }

    /**
     * Save picture to local file.
     *
     * @param bitmap data source
     * @param file   local file to store picture.
     */
    public static void savePicture( Bitmap bitmap, File file ) {
        final long start = System.currentTimeMillis();

        if ( bitmap == null || file == null ) {
            Log.i( TAG, "保存失败, bitmap or file is null." );
            return;
        }
        if ( file.getParentFile() != null && !file.getParentFile().exists() ) {
            file.getParentFile().mkdirs();
        }

        try {
            final FileOutputStream fos = new FileOutputStream( file );
            bitmap.compress( Bitmap.CompressFormat.JPEG, 100, fos );
            fos.flush();
            fos.close();

            if ( file.exists() ) {
                Log.i( TAG, "保存成功" );
            }
        } catch ( Exception e ) {
            e.printStackTrace();
        }

        Log.i( TAG, "saving picture costs " + ( System.currentTimeMillis() - start ) + "ms" );
    }

    /**
     * 适配api19以下(不包括api19),根据uri获取图片的绝对路径
     *
     * @param context 上下文对象
     * @param uri     图片的Uri
     * @return 如果Uri对应的图片存在, 那么返回该图片的绝对路径, 否则返回null
     */
    private static String getRealPathFromUriBelowAPI19( Context context, Uri uri ) {
        return getDataColumn( context, uri, null, null );
    }

    /**
     * 适配api19及以上,根据uri获取图片的绝对路径
     *
     * @param context 上下文对象
     * @param uri     图片的Uri
     * @return 如果Uri对应的图片存在, 那么返回该图片的绝对路径, 否则返回null
     */
    @SuppressLint( "NewApi" )
    private static String getRealPathFromUriAboveApi19( Context context, Uri uri ) {
        String filePath = null;

        try {
            // 如果是document类型的 uri, 则通过document id来进行处理
            if ( DocumentsContract.isDocumentUri( context, uri ) ) {
                String documentId = DocumentsContract.getDocumentId( uri );
                if ( isMediaDocument( uri ) ) {
                    // 使用':'分割
                    String id = documentId.split( ":" )[1];
                    String selection = MediaStore.Images.Media._ID + "=?";
                    String[] selectionArgs = {id};
                    filePath = getDataColumn( context, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, selection, selectionArgs );
                } else if ( isDownloadsDocument( uri ) ) {
                    Uri contentUri = ContentUris.withAppendedId( Uri.parse( "content://downloads/public_downloads" ), Long.valueOf( documentId ) );
                    filePath = getDataColumn( context, contentUri, null, null );
                }
            } else if ( "content".equalsIgnoreCase( uri.getScheme() ) ) {
                filePath = getDataColumn( context, uri, null, null );
            } else if ( "file".equals( uri.getScheme() ) ) {
                filePath = uri.getPath();
            }
        } catch ( Exception e ) {
            e.printStackTrace();
        }

        return filePath;
    }

    /**
     * 获取数据库表中的 _data 列，即返回Uri对应的文件路径
     */
    private static String getDataColumn( Context context, Uri uri, String selection, String[] selectionArgs ) {
        String path = null;
        String[] projection = new String[]{MediaStore.Images.Media.DATA};
        Cursor cursor = null;

        try {
            cursor = context.getContentResolver().query( uri, projection, selection, selectionArgs, null );

            if ( cursor != null && cursor.moveToFirst() ) {
                int columnIndex = cursor.getColumnIndexOrThrow( projection[0] );
                path = cursor.getString( columnIndex );
            }
        } catch ( Exception e ) {
            if ( cursor != null ) {
                cursor.close();
                cursor = null;
            }
        } finally {
            if ( cursor != null ) {
                cursor.close();
                cursor = null;
            }
        }

        return path;
    }

    /**
     * @param uri the Uri to check
     * @return Whether the Uri authority is MediaProvider
     */
    private static boolean isMediaDocument( Uri uri ) {
        return "com.android.providers.media.documents".equals( uri.getAuthority() );
    }

    /**
     * @param uri the Uri to check
     * @return Whether the Uri authority is DownloadsProvider
     */
    private static boolean isDownloadsDocument( Uri uri ) {
        return "com.android.providers.downloads.documents".equals( uri.getAuthority() );
    }

    public static int getMaxTextureSize() {
        try {
            // Safe minimum default size
            final int IMAGE_MAX_BITMAP_DIMENSION = SIZE_DEFAULT;

            // Get EGL Display
            EGL10 egl = ( EGL10 ) EGLContext.getEGL();
            EGLDisplay display = egl.eglGetDisplay( EGL10.EGL_DEFAULT_DISPLAY );

            // Initialise
            int[] version = new int[2];
            egl.eglInitialize( display, version );

            // Query total number of configurations
            int[] totalConfigurations = new int[1];
            egl.eglGetConfigs( display, null, 0, totalConfigurations );

            // Query actual list configurations
            EGLConfig[] configurationsList = new EGLConfig[totalConfigurations[0]];
            egl.eglGetConfigs( display, configurationsList, totalConfigurations[0], totalConfigurations );

            int[] textureSize = new int[1];
            int maximumTextureSize = 0;

            // Iterate through all the configurations to located the maximum texture size
            for ( int i = 0; i < totalConfigurations[0]; i++ ) {
                // Only need to check for width since opengl textures are always squared
                egl.eglGetConfigAttrib( display, configurationsList[i], EGL10.EGL_MAX_PBUFFER_WIDTH, textureSize );

                // Keep trackCustomEvent of the maximum texture size
                if ( maximumTextureSize < textureSize[0] )
                    maximumTextureSize = textureSize[0];
            }

            // Release
            egl.eglTerminate( display );

            // Return largest texture size found, or default
            return Math.max( maximumTextureSize, IMAGE_MAX_BITMAP_DIMENSION );
        } catch ( Exception e ) {
            e.printStackTrace();
        }

        return 0;
    }

    public static String bitmapToBase64( Bitmap bitmap ) {
        String result = null;
        try {
            if ( bitmap != null ) {
                result = Base64.encodeToString( bitmapToBytes( bitmap ), Base64.DEFAULT );
            }
        } catch ( Exception e ) {
            e.printStackTrace();
        }
        return result;
    }

    public static Bitmap base64ToBitmap( String base64Data ) {
        byte[] bytes = Base64.decode( base64Data, Base64.DEFAULT );
        return BitmapFactory.decodeByteArray( bytes, 0, bytes.length );
    }

    /**
     * 在系统返回的intent中获取图片信息，并转化为uri
     *
     * @param data
     * @return
     */
    public static Uri convertUri( Context context, Intent data ) {
        if ( data == null || data.getData() == null ) {
            return null;
        }
        Uri localUri = data.getData();
        String scheme = localUri.getScheme();
        String imagePath = "";
        if ( "content".equals( scheme ) ) {
            String[] filePathColumns = {MediaStore.Images.Media.DATA};
            Cursor c = context.getContentResolver().query( localUri, filePathColumns, null, null, null );
            if ( c != null ) {
                c.moveToFirst();
                int columnIndex = c.getColumnIndex( filePathColumns[0] );
                imagePath = c.getString( columnIndex );
                c.close();
            }
        } else if ( "file".equals( scheme ) ) {//小米4选择云相册中的图片是根据此方法获得路径
            imagePath = localUri.getPath();
        }
        if ( TextUtils.isEmpty( imagePath ) ) {
            return localUri;
        }
        Uri uri = Uri.fromFile( new File( imagePath ) );
        return uri != null ? uri : localUri;
    }

    public static Bitmap colorToBitmap( Context context, int colorResId ) {// drawable 转换成bitmap
        Bitmap.Config config = Bitmap.Config.ARGB_8888;// 取drawable的颜色格式
        Bitmap bitmap = Bitmap.createBitmap( 1, 1, config );// 建立对应bitmap
        bitmap.eraseColor( context.getResources().getColor( colorResId ) );
        return bitmap;
    }

    public static String getAlphaHexValue( float alpha ) {
        String color = Integer.toHexString( ( int ) alpha * 255 );
        return TextUtils.isEmpty( color ) ? color : color.toUpperCase();
    }

    /**
     * 抓取本地视频缩略图（操作可能耗时，尽量异步进行）
     *
     * @param filePath
     * @return
     */
    public static Bitmap getVideoThumbnail( String filePath ) {
        Bitmap b = null;
        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
        try {
            retriever.setDataSource( filePath );
            b = retriever.getFrameAtTime();
        } catch ( IllegalArgumentException e ) {
            e.printStackTrace();
        } catch ( RuntimeException e ) {
            e.printStackTrace();

        } finally {
            try {
                retriever.release();
            } catch ( RuntimeException e ) {
                e.printStackTrace();
            }
        }
        return b;
    }

    public interface OnCompressListener {

        void onCompressSuccess( byte[] data );

        void onCompressFailed( String msg );

        void onBeforeCompress();
    }
}