
package org.zarroboogs.utils;

import org.zarroboogs.util.net.HttpUtility;
import org.zarroboogs.util.net.WeiboException;
import org.zarroboogs.utils.file.FileDownloaderHttpHelper;
import org.zarroboogs.utils.file.FileLocationMethod;
import org.zarroboogs.utils.file.FileManager;
import org.zarroboogs.weibo.BeeboApplication;
import org.zarroboogs.weibo.setting.SettingUtils;
import org.zarroboogs.weibo.support.utils.Utility;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapRegionDecoder;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.media.ExifInterface;
import android.text.TextUtils;
import android.util.DisplayMetrics;

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

import static android.media.ExifInterface.ORIENTATION_NORMAL;
import static android.media.ExifInterface.ORIENTATION_ROTATE_180;
import static android.media.ExifInterface.ORIENTATION_ROTATE_270;
import static android.media.ExifInterface.ORIENTATION_ROTATE_90;
import static android.media.ExifInterface.TAG_ORIENTATION;

public class ImageUtility {

    public static final int WITH_UNDEFINED = -1;

    public static final int HEIGHT_UNDEFINED = -1;

    /**
     * 1. convert gif to normal bitmap 2. cut bitmap
     */
    private static Bitmap getMiddlePictureInTimeLineGif(String filePath, int reqWidth, int reqHeight) {

        try {

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

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

            int height = options.outHeight;
            int width = options.outWidth;

            int cutHeight = 0;
            int cutWidth = 0;

            if (height >= reqHeight && width >= reqWidth) {
                cutHeight = reqHeight;
                cutWidth = reqWidth;

            } else if (height < reqHeight && width >= reqWidth) {

                cutHeight = height;
                cutWidth = (reqWidth * cutHeight) / reqHeight;

            } else if (height >= reqHeight && width < reqWidth) {

                cutWidth = width;
                cutHeight = (reqHeight * cutWidth) / reqWidth;

            } else if (height < reqHeight && width < reqWidth) {

                float betweenWidth = ((float) reqWidth - (float) width) / (float) width;
                float betweenHeight = ((float) reqHeight - (float) height) / (float) height;

                if (betweenWidth > betweenHeight) {
                    cutWidth = width;
                    cutHeight = (reqHeight * cutWidth) / reqWidth;

                } else {
                    cutHeight = height;
                    cutWidth = (reqWidth * cutHeight) / reqHeight;

                }

            }

            if (cutWidth <= 0 || cutHeight <= 0) {
                return null;
            }

            Bitmap region = Bitmap.createBitmap(bitmap, 0, 0, cutWidth, cutHeight);

            if (region != bitmap) {
                bitmap.recycle();
                bitmap = region;
            }

            if (bitmap.getHeight() < reqHeight && bitmap.getWidth() < reqWidth) {
                Bitmap scale = Bitmap.createScaledBitmap(bitmap, reqWidth, reqHeight, true);
                if (scale != bitmap) {
                    bitmap.recycle();
                    bitmap = scale;
                }
            }

            Bitmap cornerBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap);
            if (cornerBitmap != bitmap) {
                bitmap.recycle();
                bitmap = cornerBitmap;
            }
            return bitmap;

        } catch (OutOfMemoryError ignored) {
            return null;
        }
    }

    private static boolean isGif(String path) {
        return path.endsWith(".gif");
    }

    public static Bitmap getMiddlePictureInTimeLine(String url, int reqWidth, int reqHeight,
                                                    FileDownloaderHttpHelper.DownloadListener downloadListener)
            throws WeiboException {
        try {

            String filePath = FileManager.getFilePathFromUrl(url, FileLocationMethod.picture_bmiddle);

            File file = new File(filePath);

            if (!file.exists() && !SettingUtils.isEnablePic()) {
                return null;
            }

            if (!file.exists()) {
                getBitmapFromNetWork(url, filePath, downloadListener);
            }

            if (isGif(filePath)) {
                return getMiddlePictureInTimeLineGif(filePath, reqWidth, reqHeight);
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            int height = options.outHeight;
            int width = options.outWidth;

            int cutHeight = 0;
            int cutWidth = 0;

            if (height >= reqHeight && width >= reqWidth) {
                cutHeight = reqHeight;
                cutWidth = reqWidth;

            } else if (height < reqHeight && width >= reqWidth) {

                cutHeight = height;
                cutWidth = (reqWidth * cutHeight) / reqHeight;

            } else if (height >= reqHeight && width < reqWidth) {

                cutWidth = width;
                cutHeight = (reqHeight * cutWidth) / reqWidth;

            } else if (height < reqHeight && width < reqWidth) {

                float betweenWidth = ((float) reqWidth - (float) width) / (float) width;
                float betweenHeight = ((float) reqHeight - (float) height) / (float) height;

                if (betweenWidth > betweenHeight) {
                    cutWidth = width;
                    cutHeight = (reqHeight * cutWidth) / reqWidth;

                } else {
                    cutHeight = height;
                    cutWidth = (reqWidth * cutHeight) / reqHeight;

                }

            }

            if (cutWidth > 0 && cutHeight > 0) {

                int startX = 0;

                if (cutWidth < width) {
                    startX = (width - cutWidth) / 2;
                }

                try {
                    BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(filePath, false);
                    if (decoder != null) {
                        Bitmap bitmap = decoder.decodeRegion(new Rect(startX, 0, startX + cutWidth, cutHeight), null);
                        if (bitmap.getHeight() < reqHeight && bitmap.getWidth() < reqWidth) {
                            Bitmap scale = Bitmap.createScaledBitmap(bitmap, reqWidth, reqHeight, true);
                            if (scale != bitmap) {
                                bitmap.recycle();
                                bitmap = scale;
                            }
                        }
                        if (bitmap != null) {
                            Bitmap roundedCornerBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap);
                            if (roundedCornerBitmap != bitmap) {
                                bitmap.recycle();
                                bitmap = roundedCornerBitmap;
                            }

                            return bitmap;
                        }
                    }
                } catch (IOException ignored) {

                }

            }

            return null;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static Bitmap getRoundedCornerPic(String url, int reqWidth, int reqHeight, FileLocationMethod method)
            throws WeiboException {
        return getRoundedCornerPic(url, reqWidth, reqHeight, method, null);
    }

    public static Bitmap getRoundedCornerPic(String url, int reqWidth, int reqHeight, FileLocationMethod method,
                                             FileDownloaderHttpHelper.DownloadListener downloadListener) throws WeiboException {
        try {

            if (!FileManager.isExternalStorageMounted()) {
                return null;
            }

            String filePath = FileManager.getFilePathFromUrl(url, method);
            if (!filePath.endsWith(".jpg") && !filePath.endsWith(".gif")) {
                filePath = filePath + ".jpg";
            }

            boolean fileExist = new File(filePath).exists();

            if (!fileExist && !SettingUtils.isEnablePic()) {
                return null;
            }

            if (!fileExist) {
                boolean result = getBitmapFromNetWork(url, filePath, downloadListener);
                if (!result) {
                    return null;
                }
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
            if (size[0] > 0 && size[1] > 0) {
                Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                if (scaledBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = scaledBitmap;
                }
            }

            Bitmap roundedBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap);
            if (roundedBitmap != bitmap) {
                bitmap.recycle();
                bitmap = roundedBitmap;
            }

            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static Bitmap getRoundedCornerPic(String filePath, int reqWidth, int reqHeight) {
        return getRoundedCornerPic(filePath, reqWidth, reqHeight, 0);
    }

    public static Bitmap getRoundedCornerPic(String filePath, int reqWidth, int reqHeight, int cornerRadius) {
        try {

            if (!FileManager.isExternalStorageMounted()) {
                return null;
            }

            if (!filePath.endsWith(".jpg") && !filePath.endsWith(".gif") && !filePath.endsWith(".png")) {
                filePath = filePath + ".jpg";
            }

            boolean fileExist = new File(filePath).exists();

            if (!fileExist && !SettingUtils.isEnablePic()) {
                return null;
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            if (cornerRadius > 0) {
                int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
                if (size[0] > 0 && size[1] > 0) {
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                    if (scaledBitmap != bitmap) {
                        bitmap.recycle();
                        bitmap = scaledBitmap;
                    }
                }

                Bitmap roundedBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap, cornerRadius);
                if (roundedBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = roundedBitmap;
                }

            }
            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static Bitmap readNormalPic(String filePath, int reqWidth, int reqHeight) {
        try {

            if (!FileManager.isExternalStorageMounted()) {
                return null;
            }

            if (TextUtils.isEmpty(filePath)) {
                return null;
            }

            if (!filePath.endsWith(".jpg") && !filePath.endsWith(".gif") && !filePath.endsWith(".png")) {
                filePath = filePath + ".jpg";
            }

            boolean fileExist = new File(filePath).exists();

            if (!fileExist && !SettingUtils.isEnablePic()) {
                return null;
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            if (reqHeight > 0 && reqWidth > 0) {
                options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            }
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            if (reqHeight > 0 && reqWidth > 0) {
                int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
                if (size[0] > 0 && size[1] > 0) {
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                    if (scaledBitmap != bitmap) {
                        bitmap.recycle();
                        bitmap = scaledBitmap;
                    }
                }
            }

            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static Bitmap getMiddlePictureInBrowserMSGActivity(String url, FileLocationMethod method,
                                                              FileDownloaderHttpHelper.DownloadListener downloadListener) {

        try {

            String filePath = FileManager.getFilePathFromUrl(url, method);

            File file = new File(filePath);

            if (!file.exists() && !SettingUtils.isEnablePic()) {
                return null;
            }

            if (!isThisBitmapCanRead(filePath)) {

                getBitmapFromNetWork(url, filePath, downloadListener);

            }
            file = new File(filePath);
            if (file.exists()) {
                DisplayMetrics displayMetrics = BeeboApplication.getInstance().getDisplayMetrics();
                return decodeBitmapFromSDCard(filePath, displayMetrics.widthPixels, 900);
            }
            return null;
        } catch (OutOfMemoryError ignored) {
            return null;
        }
    }

    public static String getLargePictureWithoutRoundedCorner(String url,
                                                             FileDownloaderHttpHelper.DownloadListener downloadListener,
                                                             FileLocationMethod fileLocationMethod) {

        String absoluteFilePath = FileManager.getFilePathFromUrl(url, fileLocationMethod);

        File file = new File(absoluteFilePath);

        if (file.exists()) {
            return absoluteFilePath;

        } else {

            getBitmapFromNetWork(url, absoluteFilePath, downloadListener);

            if (isThisBitmapCanRead(absoluteFilePath)) {
                return absoluteFilePath;
            } else {
                return "about:blank";
            }

        }

    }

    public static boolean isThisBitmapCanRead(String path) {
        if (TextUtils.isEmpty(path)) {
            return false;
        }
        File file = new File(path);

        if (!file.exists()) {
            return false;
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);
        int width = options.outWidth;
        int height = options.outHeight;
        return !(width == -1 || height == -1);

    }

    public static boolean isThisBitmapTooLargeToRead(String path) {

        File file = new File(path);

        if (!file.exists()) {
            return false;
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);
        int width = options.outWidth;
        int height = options.outHeight;
        if (width == -1 || height == -1) {
            return false;
        }

        return width > Utility.getBitmapMaxWidthAndMaxHeight() || height > Utility.getBitmapMaxWidthAndMaxHeight();

    }

    public static int[] getBitmapSize(String path) {
        int[] result = {
                -1, -1
        };
        File file = new File(path);

        if (!file.exists()) {
            return result;
        }

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);
        int width = options.outWidth;
        int height = options.outHeight;
        if (width > 0 && height > 0) {
            result[0] = width;
            result[1] = height;
        }

        return result;
    }

    public static Bitmap decodeBitmapFromSDCard(String path, int reqWidth, int reqHeight) {

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(path, options);

    }

    public static Bitmap getNotificationSendFailedPic(String path) {

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(path, options);

        options.inSampleSize = calculateInSampleSize(options, Utility.getScreenWidth(), Utility.getScreenHeight());

        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(path, options);

    }

    public static Bitmap getWriteWeiboRoundedCornerPic(String url, int reqWidth, int reqHeight, FileLocationMethod method) {
        try {

            if (!FileManager.isExternalStorageMounted()) {
                return null;
            }

            String filePath = FileManager.getFilePathFromUrl(url, method);

            if (!ImageUtility.isThisBitmapCanRead(filePath)) {
                return null;
            }

            if (!filePath.endsWith(".jpg") && !filePath.endsWith(".gif")) {
                filePath = filePath + ".jpg";
            }

            boolean fileExist = new File(filePath).exists();

            if (!fileExist) {
                return null;
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
            if (size[0] > 0 && size[1] > 0) {
                Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                if (scaledBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = scaledBitmap;
                }
            }

            Bitmap roundedBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap);
            if (roundedBitmap != bitmap) {
                bitmap.recycle();
                bitmap = roundedBitmap;
            }

            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static Bitmap getWriteWeiboPictureThumblr(String filePath) {
        try {
            // actionbar button image width and height is 32 dip
            int reqWidth = Utility.dip2px(32);
            int reqHeight = Utility.dip2px(32);

            if (!FileManager.isExternalStorageMounted()) {
                return null;
            }

            boolean fileExist = new File(filePath).exists();

            if (!fileExist) {
                return null;
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
            if (size[0] > 0 && size[1] > 0) {
                Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                if (scaledBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = scaledBitmap;
                }
            }

            Bitmap roundedBitmap = ImageEditUtility.getRoundedCornerBitmap(bitmap);
            if (roundedBitmap != bitmap) {
                bitmap.recycle();
                bitmap = roundedBitmap;
            }

            int exifRotation = ImageUtility.getFileExifRotation(filePath);
            if (exifRotation != 0) {
                Matrix mtx = new Matrix();
                mtx.postRotate(exifRotation);
                Bitmap adjustedBitmap = Bitmap.createBitmap(roundedBitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), mtx,
                        true);
                if (adjustedBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = adjustedBitmap;
                }
            }

            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    public static boolean getBitmapFromNetWork(String url, String path,
                                               FileDownloaderHttpHelper.DownloadListener downloadListener) {
        for (int i = 0; i < 3; i++) {
            if (HttpUtility.getInstance().executeDownloadTask(url, path, downloadListener)) {
                return true;
            }
            new File(path).delete();
        }

        return false;
    }

    private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {

        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            if (height > reqHeight && reqHeight != 0) {
                inSampleSize = (int) Math.floor((double) height / (double) reqHeight);
            }

            int tmp = 0;

            if (width > reqWidth && reqWidth != 0) {
                tmp = (int) Math.floor((double) width / (double) reqWidth);
            }

            inSampleSize = Math.max(inSampleSize, tmp);

        }
        int roundedSize;
        if (inSampleSize <= 8) {
            roundedSize = 1;
            while (roundedSize < inSampleSize) {
                roundedSize <<= 1;
            }
        } else {
            roundedSize = (inSampleSize + 7) / 8 * 8;
        }

        return roundedSize;
    }

    private static int[] calcResize(int actualWidth, int actualHeight, int reqWidth, int reqHeight) {

        int height = actualHeight;
        int width = actualWidth;

        float betweenWidth = ((float) reqWidth) / (float) actualWidth;
        float betweenHeight = ((float) reqHeight) / (float) actualHeight;

        float min = Math.min(betweenHeight, betweenWidth);

        height = (int) (min * actualHeight);
        width = (int) (min * actualWidth);

        return new int[]{
                width, height
        };
    }

    public static String compressPic(Context context, String picPath) {

        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = false;
        options.inSampleSize = 1;

        switch (SettingUtils.getUploadQuality()) {
            case 1:
                return picPath;
            case 2:
                options.inSampleSize = 2;
                break;
            case 3:
                options.inSampleSize = 4;
                break;
            case 4:
                options.inSampleSize = 2;

                if (Utility.isWifi(context)) {
                    return picPath;
                }
                break;
        }

        Bitmap bitmap = BitmapFactory.decodeFile(picPath, options);
        int exifRotation = ImageUtility.getFileExifRotation(picPath);
        if (exifRotation != 0) {
            // TODO write EXIF instead of rotating bitmap.
            Matrix mtx = new Matrix();
            mtx.postRotate(exifRotation);
            Bitmap adjustedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), mtx, true);
            if (adjustedBitmap != bitmap) {
                bitmap.recycle();
                bitmap = adjustedBitmap;
            }
        }
        FileOutputStream stream = null;
        String tmp = FileManager.getUploadPicTempFile();
        try {
            new File(tmp).getParentFile().mkdirs();
            new File(tmp).createNewFile();
            stream = new FileOutputStream(new File(tmp));
        } catch (IOException ignored) {

        }
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);

        if (stream != null) {
            try {
                stream.close();
                bitmap.recycle();
            } catch (IOException ignored) {

            }
        }
        return tmp;
    }

    public static boolean isThisPictureGif(String url) {
        return !TextUtils.isEmpty(url) && url.endsWith(".gif");
    }

    public static int getFileExifRotation(String filePath) {
        try {
            ExifInterface exifInterface = new ExifInterface(filePath);
            int orientation = exifInterface.getAttributeInt(TAG_ORIENTATION, ORIENTATION_NORMAL);
            switch (orientation) {
                case ORIENTATION_ROTATE_90:
                    return 90;
                case ORIENTATION_ROTATE_180:
                    return 180;
                case ORIENTATION_ROTATE_270:
                    return 270;
                default:
                    return 0;
            }
        } catch (IOException e) {
            return 0;
        }
    }
}
