package com.doumee.lib_coremodel.http.utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.net.Uri;
import android.text.TextUtils;
import com.facebook.common.executors.UiThreadImmediateExecutorService;
import com.facebook.common.references.CloseableReference;
import com.facebook.common.util.UriUtil;
import com.facebook.datasource.BaseDataSubscriber;
import com.facebook.datasource.DataSource;
import com.facebook.datasource.DataSubscriber;
import com.facebook.drawee.backends.pipeline.Fresco;
import com.facebook.drawee.backends.pipeline.PipelineDraweeControllerBuilder;
import com.facebook.drawee.controller.ControllerListener;
import com.facebook.drawee.drawable.ScalingUtils;
import com.facebook.drawee.generic.GenericDraweeHierarchy;
import com.facebook.drawee.interfaces.DraweeController;
import com.facebook.drawee.view.DraweeView;
import com.facebook.drawee.view.SimpleDraweeView;
import com.facebook.fresco.helper.ImageLoader;
import com.facebook.fresco.helper.blur.BitmapBlurHelper;
import com.facebook.fresco.helper.listener.IResult;
import com.facebook.imagepipeline.animated.base.AnimatedImageResult;
import com.facebook.imagepipeline.common.ImageDecodeOptions;
import com.facebook.imagepipeline.common.ResizeOptions;
import com.facebook.imagepipeline.common.RotationOptions;
import com.facebook.imagepipeline.core.ImagePipeline;
import com.facebook.imagepipeline.image.CloseableAnimatedImage;
import com.facebook.imagepipeline.image.CloseableBitmap;
import com.facebook.imagepipeline.image.CloseableImage;
import com.facebook.imagepipeline.image.ImageInfo;
import com.facebook.imagepipeline.request.BasePostprocessor;
import com.facebook.imagepipeline.request.ImageRequest;
import com.facebook.imagepipeline.request.ImageRequestBuilder;

import timber.log.Timber;
//import com.nostra13.universalimageloader.core.assist.ImageSize;


/**
 * Created by Administrator on 2017/9/18.
 */

public class FrescoUtils {
    public interface ImageLoadingListener {
        void onSuccess(Bitmap var1);

        void onFailure();
    }

    public static void clearMeary(){
        /*ImagePipeline imagePipeline = Fresco.getImagePipeline();
        imagePipeline.clearMemoryCaches();
        imagePipeline.clearDiskCaches();
        // combines above two lines
        imagePipeline.clearCaches();*/
    }

    /*public static void displayImageFresco(String url, SimpleDraweeView draweeView) {
        *//*if(url!=null){
            url="http://picture.yxshow.tv/default.jpg";
        }*//*
        try {
            if(TextUtils.isEmpty(url)){
                draweeView.setImageURI((new Uri.Builder()).scheme("res").path(String.valueOf(R.mipmap.circle_nomal_pic)).build());
            }else {
                //draweeView.setImageURI(url);
                ImageLoader.loadImage(draweeView,url,false);
            }

        }catch (Exception e){

        }
        *//*ImageRequest request = ImageRequestBuilder.newBuilderWithSource(uri).build();
        DraweeController controller = Fresco.newDraweeControllerBuilder()
                .setImageRequest(request).setAutoPlayAnimations(true).build();
        draweeView.setController(controller);*//*
    }*/

    public static void displayImageFresco(final String url, final SimpleDraweeView simpleDraweeView) {
        if(url==null){
            return;
        }
        DraweeController controller = Fresco.newDraweeControllerBuilder()
                .setUri(Uri.parse(url))
                .setRetainImageOnFailure(false)
                .setTapToRetryEnabled(false)
                .setOldController(simpleDraweeView.getController())
                .build();

        simpleDraweeView.setController(controller);
    }

    /*
    isUnGIF:是否要去除gif
    * */
    public static void displayImageFresco(final String url, final SimpleDraweeView simpleDraweeView, final boolean isSmall, final boolean isGIF, int type) {
        GenericDraweeHierarchy hierarchy = simpleDraweeView.getHierarchy();
        /*if(isSmall){
            hierarchy.setPlaceholderImage(R.drawable.default_user_head);
        }else {
            hierarchy.setPlaceholderImage(R.mipmap.circle_nomal_pic);
        }*/

        if(type==1){
            hierarchy.setActualImageScaleType(ScalingUtils.ScaleType.FIT_CENTER);
        }else {
            hierarchy.setActualImageScaleType(ScalingUtils.ScaleType.CENTER_CROP);
        }

        try {
            if(TextUtils.isEmpty(url)){
                if(isSmall){
                    //simpleDraweeView.setImageURI((new Uri.Builder()).scheme("res").path(String.valueOf(R.drawable.default_user_head)).build());
                }else {
                    //simpleDraweeView.setImageURI((new Uri.Builder()).scheme("res").path(String.valueOf(R.mipmap.circle_nomal_pic)).build());
                }
            }else {
                simpleDraweeView.post(new Runnable() {
                    @Override
                    public void run() {
                        int width = simpleDraweeView.getWidth();
                        int height = simpleDraweeView.getHeight();
                        if(isGIF){
                            ImageLoader.loadImage(simpleDraweeView, Uri.parse(url.trim()),width,height,null,null,isSmall);
                        }else {
                            loadImageUnGIF(simpleDraweeView, Uri.parse(url.trim()),width,height,null,null ,isSmall);
                        }
                    }
                });
            }

        }catch (Exception e){

        }
    }

    public static void displayImageFresco(final String url, final SimpleDraweeView simpleDraweeView, final boolean isSmall, int nomalPic) {
        if(url==null){
            return;
        }
        GenericDraweeHierarchy hierarchy = simpleDraweeView.getHierarchy();
        if(nomalPic>0){
            hierarchy.setPlaceholderImage(nomalPic);
        }

        hierarchy.setActualImageScaleType(ScalingUtils.ScaleType.CENTER_CROP);
        try {
            if(TextUtils.isEmpty(url)){
                if(isSmall){
                    //simpleDraweeView.setImageURI((new Uri.Builder()).scheme("res").path(String.valueOf(R.drawable.default_user_head)).build());
                }else {
                    //simpleDraweeView.setImageURI((new Uri.Builder()).scheme("res").path(String.valueOf(R.mipmap.circle_nomal_pic)).build());
                }
            }else {
                simpleDraweeView.post(new Runnable() {
                    @Override
                    public void run() {
                        int width = simpleDraweeView.getWidth();
                        int height = simpleDraweeView.getHeight();
                        ImageLoader.loadImage(simpleDraweeView, Uri.parse(url.trim()),width,height,null,null,isSmall);
                    }
                });
            }

        }catch (Exception e){

        }
    }

    public static void loadImageUnGIF(SimpleDraweeView simpleDraweeView,
                                      Uri uri,
                                      final int reqWidth,
                                      final int reqHeight,
                                      BasePostprocessor postprocessor,
                                      ControllerListener<ImageInfo> controllerListener,
                                      boolean isSmall) {
        ImageDecodeOptions options= ImageDecodeOptions.newBuilder().setForceStaticImage(true).setDecodePreviewFrame(true).build();
        ImageRequestBuilder imageRequestBuilder = ImageRequestBuilder.newBuilderWithSource(uri);
        imageRequestBuilder.setImageDecodeOptions(options);
        imageRequestBuilder.setRotationOptions(RotationOptions.autoRotate());

        // 不支持图片渐进式加载，理由：https://github.com/facebook/fresco/issues/1204
        imageRequestBuilder.setProgressiveRenderingEnabled(false);

        if (isSmall) {
            imageRequestBuilder.setCacheChoice(ImageRequest.CacheChoice.SMALL);
        }

        if (reqWidth > 0 && reqHeight > 0) {
            imageRequestBuilder.setResizeOptions(new ResizeOptions(reqWidth, reqHeight));
        }

        if (UriUtil.isLocalFileUri(uri)) {
            imageRequestBuilder.setLocalThumbnailPreviewsEnabled(true);
        }

        if (postprocessor != null) {
            imageRequestBuilder.setPostprocessor(postprocessor);
        }

        ImageRequest imageRequest = imageRequestBuilder.build();

        PipelineDraweeControllerBuilder draweeControllerBuilder = Fresco.newDraweeControllerBuilder();
        draweeControllerBuilder.setOldController(simpleDraweeView.getController());
        draweeControllerBuilder.setImageRequest(imageRequest);

        if (controllerListener != null) {
            draweeControllerBuilder.setControllerListener(controllerListener);
        }

        draweeControllerBuilder.setTapToRetryEnabled(true); // 开启重试功能
        draweeControllerBuilder.setAutoPlayAnimations(true); // 自动播放gif动画
        DraweeController draweeController = draweeControllerBuilder.build();
        simpleDraweeView.setController(draweeController);
    }

    /**
     * 从本地文件或网络获取Bitmap
     *
     * @param context
     * @param url
     * @param reqWidth
     * @param reqHeight
     * @param loadImageResult
     */
    public static void loadImage(final Context context,
                                 String url,
                                 final int reqWidth,
                                 final int reqHeight,
                                 final IResult<Bitmap> loadImageResult) {
        if (TextUtils.isEmpty(url)) {
            //MLog.i("url is null");
            if(loadImageResult!=null){
                loadImageResult.onResult(null);
            }
            return;
        }

        Uri uri = Uri.parse(url.trim());
        if (!UriUtil.isNetworkUri(uri)) {
            uri = new Uri.Builder()
                    .scheme(UriUtil.LOCAL_FILE_SCHEME)
                    .path(url.trim())
                    .build();
        }

        ImagePipeline imagePipeline = Fresco.getImagePipeline();

        ImageRequestBuilder imageRequestBuilder = ImageRequestBuilder.newBuilderWithSource(uri);
        if (reqWidth > 0 && reqHeight > 0) {
            imageRequestBuilder.setResizeOptions(new ResizeOptions(reqWidth, reqHeight));
        }
        ImageRequest imageRequest = imageRequestBuilder.build();

        // 获取已解码的图片，返回的是Bitmap
        DataSource<CloseableReference<CloseableImage>> dataSource = imagePipeline.fetchDecodedImage(imageRequest, context);
        DataSubscriber dataSubscriber = new BaseDataSubscriber<CloseableReference<CloseableImage>>() {
            @Override
            public void onNewResultImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
                if (!dataSource.isFinished()) {
                    if (loadImageResult != null) {
                        loadImageResult.onResult(null);
                    }
                    return;
                }

                CloseableReference<CloseableImage> imageReference = dataSource.getResult();
                if (imageReference != null) {
                    final CloseableReference<CloseableImage> closeableReference = imageReference.clone();
                    try {
                        CloseableImage closeableImage = closeableReference.get();
                        if (closeableImage instanceof CloseableAnimatedImage) {
                            AnimatedImageResult animatedImageResult = ((CloseableAnimatedImage) closeableImage).getImageResult();
                            if (animatedImageResult != null && animatedImageResult.getImage() != null) {
                                int imageWidth = animatedImageResult.getImage().getWidth();
                                int imageHeight = animatedImageResult.getImage().getHeight();

                                Bitmap.Config bitmapConfig = Bitmap.Config.ARGB_8888;
                                Bitmap bitmap = Bitmap.createBitmap(imageWidth, imageHeight, bitmapConfig);
                                animatedImageResult.getImage().getFrame(0).renderFrame(imageWidth, imageHeight, bitmap);
                                if (loadImageResult != null) {
                                    loadImageResult.onResult(bitmap);
                                }
                            }else {
                                if (loadImageResult != null) {
                                    loadImageResult.onResult(null);
                                }
                            }
                        } else if (closeableImage instanceof CloseableBitmap) {
                            CloseableBitmap closeableBitmap = (CloseableBitmap) closeableImage;
                            Bitmap bitmap = closeableBitmap.getUnderlyingBitmap();
                            if (bitmap != null && !bitmap.isRecycled()) {
                                // https://github.com/facebook/fresco/issues/648
                                final Bitmap tempBitmap = bitmap.copy(bitmap.getConfig(), false);
                                if (loadImageResult != null) {
                                    loadImageResult.onResult(tempBitmap);
                                }
                            }else {
                                if (loadImageResult != null) {
                                    loadImageResult.onResult(null);
                                }
                            }
                        }else {
                            if (loadImageResult != null) {
                                loadImageResult.onResult(null);
                            }
                        }
                    } finally {
                        imageReference.close();
                        closeableReference.close();
                    }
                }else {
                    if (loadImageResult != null) {
                        loadImageResult.onResult(null);
                    }
                }
            }

            @Override
            public void onFailureImpl(DataSource dataSource) {
                Throwable throwable = dataSource.getFailureCause();
                if (throwable != null) {
                    Timber.tag("ImageLoader").e("onFailureImpl = " + throwable.toString());
                }
                if (loadImageResult != null) {
                    loadImageResult.onResult(null);
                }
            }
        };
        dataSource.subscribe(dataSubscriber, UiThreadImmediateExecutorService.getInstance());
    }


    public static void loadImageBlur(final SimpleDraweeView draweeView, String url) {
        ImageLoader.loadImage(draweeView, url.trim(), new BasePostprocessor() {
            @Override
            public String getName() {
                return "blurPostprocessor";
            }

            @Override
            public void process(Bitmap bitmap) {
                BitmapBlurHelper.blur(bitmap, 25);
            }
        });
    }

    public static void loadImageBlur(final SimpleDraweeView draweeView, int resId) {
        ImageLoader.loadDrawable(draweeView, resId, new BasePostprocessor() {
            @Override
            public String getName() {
                return "blurPostprocessor";
            }

            @Override
            public void process(Bitmap bitmap) {
                BitmapBlurHelper.blur(bitmap, 20);
            }
        });
    }

    /*public static void loadImage(Context context, String url, ImageSize size, final ImageLoadingListener listener) {
        if (listener == null) {
            return;
        }

        if (TextUtils.isEmpty(url.trim())) {
            listener.onFailure();
            return;
        }

        ImageRequestBuilder builder = ImageRequestBuilder
                .newBuilderWithSource(Uri.parse(url.trim()))
                .setProgressiveRenderingEnabled(false);
        if (size != null) {
            builder.setResizeOptions(new ResizeOptions(size.getWidth(), size.getHeight()));
        }

        ImageRequest imageRequest = builder.build();
        ImagePipeline imagePipeline = Fresco.getImagePipeline();
        final DataSource<CloseableReference<CloseableImage>>
                dataSource = imagePipeline.fetchDecodedImage(imageRequest, context);

        final DataSubscriber<CloseableReference<CloseableImage>> dataSubscriber = new
                BaseDataSubscriber<CloseableReference<CloseableImage>>() {
                    @Override
                    public void onNewResultImpl(
                            DataSource<CloseableReference<CloseableImage>> dataSource) {
                        if (!dataSource.isFinished()) {
                            return;
                        }
                        CloseableReference<CloseableImage> closeableReference = dataSource
                                .getResult();
                        if (closeableReference == null) {
                            return;
                        }
                        try {
                            Bitmap bitmap = null;
                            if (closeableReference.get() instanceof CloseableBitmap) {
                                CloseableBitmap closeableBitmap = (CloseableBitmap)
                                        closeableReference.get();
                                bitmap = closeableBitmap.getUnderlyingBitmap();
                            }

                            //Bitmap bitmap = closeableBitmap.getUnderlyingBitmap();
                            if (bitmap != null && !bitmap.isRecycled()) {
                                //Bitmap copybitmap =
                                SoftReference<Bitmap> copyBitmap = new SoftReference<Bitmap>(Bitmap.createBitmap(bitmap));
                                //  Bitmap copybitmap = ImageBlur.createRGBABitmap(bitmap, bitmap.getWidth(), bitmap.getHeight(),1);
                                listener.onSuccess(copyBitmap.get());
                            }
                        } finally {
                            closeableReference.close();
                            dataSource.close();
                        }
                    }

                    @Override
                    public void onFailureImpl(DataSource dataSource) {
                        listener.onFailure();
                        dataSource.close();
                    }
                };
        dataSource.subscribe(dataSubscriber, CallerThreadExecutor.getInstance());
    }*/

    /*//（做处理压缩重新设置宽高）模糊化需要
    public static void getImageThumbnail(Context context, String uri, ImageSize size, final ImageLoadingListener listener) {
        if (listener == null) {
            return;
        }

        if(uri!=null){
            uri.trim();
        }

        if (TextUtils.isEmpty(uri)) {
            listener.onFailure();
            return;
        }

        ImageRequestBuilder builder = ImageRequestBuilder
                .newBuilderWithSource(Uri.parse(uri))
                .setProgressiveRenderingEnabled(false);
        if (size != null) {
            builder.setResizeOptions(new ResizeOptions(size.getWidth(), size.getHeight()));
        }

        ImageRequest imageRequest = builder.build();
        ImagePipeline imagePipeline = Fresco.getImagePipeline();
        final DataSource<CloseableReference<CloseableImage>>
                dataSource = imagePipeline.fetchDecodedImage(imageRequest, context);

        dataSource.subscribe(new BaseDataSubscriber<CloseableReference<CloseableImage>>() {
                                 @Override
                                 public void onNewResultImpl(
                                         DataSource<CloseableReference<CloseableImage>> dataSource) {
                                     if (!dataSource.isFinished()) {
                                         return;
                                     }
                                     CloseableReference<CloseableImage> closeableReference = dataSource
                                             .getResult();
                                     if (closeableReference != null) {
                                         try {
                                             Bitmap bitmap = null;
                                             if (closeableReference.get() instanceof CloseableBitmap) {
                                                 CloseableBitmap closeableBitmap = (CloseableBitmap)
                                                         closeableReference.get();
                                                 bitmap = closeableBitmap.getUnderlyingBitmap();
                                             }
                                             //Bitmap bitmap = closeableBitmap.getUnderlyingBitmap();
                                             if (bitmap != null && !bitmap.isRecycled()) {
                                                 // Bitmap thumbbitmap = ThumbnailUtils.extractThumbnail(bitmap, 100, 100);
                                                 SoftReference<Bitmap> copyBitmap = new SoftReference<Bitmap>(Bitmap.createBitmap(bitmap,0,0,100, 100));
                                                 listener.onSuccess(copyBitmap.get());
                                             }
                                         } finally {
                                             closeableReference.close();
                                             dataSource.close();
                                         }
                                     }
                                 }

                                 @Override
                                 public void onFailureImpl(DataSource dataSource) {
                                     listener.onFailure();
                                     dataSource.close();
                                 }
                             },
                CallerThreadExecutor.getInstance());
    }*/

    public static DraweeController getDraweeController(DraweeView targetView, String filepath) {
        Uri uri= Uri.parse(filepath);
        int w=targetView.getWidth();
        int h=targetView.getHeight();
        ImageRequest request = ImageRequestBuilder.newBuilderWithSource(uri)
                //根据View的尺寸放缩图片
                .setResizeOptions(new ResizeOptions(targetView.getWidth(), targetView.getHeight()))
                .build();

        DraweeController controller = Fresco.newDraweeControllerBuilder()
                .setOldController(targetView.getController())
                .setImageRequest(request)
                .setCallerContext(uri)
                .build();
        return controller;
    }
}