/*
 * Copyright (C) 2015 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.android.libraries.cast.companionlibrary.utils;

import android.annotation.TargetApi;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Point;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * An AsyncTask to fetch an image over HTTP and scale it to the desired size. Clients need to extend
 * this and implement their own {@code onPostExecute(Bitmap bitmap)} method. It provides a uniform
 * treatment of ThreadPool across various versions of Android.
 */
public abstract class FetchBitmapTask extends AsyncTask<Uri, Void, Bitmap> {
    private final int mPreferredWidth;
    private final int mPreferredHeight;
    private final boolean mAllowedToScale;

    /**
     * Constructs a new FetchBitmapTask that will do in-sampling and scaling, if needed.
     *
     * @param preferredWidth The preferred image width.
     * @param preferredHeight The preferred image height.
     * @param allowedToScale If {@code true}, the resulting bitmap will be scaled to match the
     * preferred dimensions while keeping the aspect ratio. Otherwise, no additional scaling will
     * be performed.
     */
    public FetchBitmapTask(int preferredWidth, int preferredHeight, boolean allowedToScale) {
        mPreferredWidth = preferredWidth;
        mPreferredHeight = preferredHeight;
        mAllowedToScale = allowedToScale;
    }

    /**
     * Constructs a new FetchBitmapTask that will do in-sampling but no scaling.
     *
     * @param preferredWidth The preferred image width.
     * @param preferredHeight The preferred image height.
     *
     * @see FetchBitmapTask#FetchBitmapTask(int, int, boolean)
     */
    public FetchBitmapTask(int preferredWidth, int preferredHeight) {
        this(preferredWidth, preferredHeight, false);
    }

    /**
     * Constructs a new FetchBitmapTask. No scaling or in-sampling will be performed if you use this
     * constructor.
     *
     * @see FetchBitmapTask#FetchBitmapTask(int, int)
     * @see FetchBitmapTask#FetchBitmapTask(int, int, boolean)
     */
    public FetchBitmapTask() {
        this(0, 0);
    }

    @Override
    protected Bitmap doInBackground(Uri... uris) {
        if (uris.length != 1 || uris[0] == null) {
            return null;
        }

        Bitmap bitmap = null;
        URL url;
        try {
            url = new URL(uris[0].toString());
        } catch (MalformedURLException e) {
            return null;
        }
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = false;
        options.inSampleSize = 1;
        if ((mPreferredWidth > 0) && (mPreferredHeight > 0)) {
            // This is done to do appropriate resampling when the image is too large for the
            // desired target size; instead of downloading the original image and resizing that
            // (which can run into OOM exception), we find an appropriate in-sample-size and
            // only adjust the options to download the resized version.
            Point originalSize = calculateOriginalDimensions(url);
            if (originalSize.x > 0 && originalSize.y > 0) {
                options.inSampleSize = calculateInSampleSize(originalSize.x, originalSize.y,
                        mPreferredWidth, mPreferredHeight);
            }
        }
        HttpURLConnection urlConnection = null;
        InputStream stream = null;
        try {
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.setDoInput(true);

            if (urlConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                stream = new BufferedInputStream(urlConnection.getInputStream());
                bitmap = BitmapFactory.decodeStream(stream, null, options);
                if ((mPreferredWidth > 0) && (mPreferredHeight > 0) && mAllowedToScale) {
                    bitmap = scaleBitmap(bitmap);
                }
            }
        } catch (IOException e) { /* ignore */
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) { /* ignore */
                }
            }
        }

        return bitmap;
    }

    /**
     * Executes the task.
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public void execute(Uri uri) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, uri);
        } else {
            execute(new Uri[] {uri});
        }
    }

    /*
     * Scales the bitmap to the preferred width and height.
     *
     * @param bitmap The bitmap to scale.
     * @return The scaled bitmap.
     */
    private Bitmap scaleBitmap(Bitmap bitmap) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();

        // Calculate deltas.
        int dw = width - mPreferredWidth;
        int dh = height - mPreferredHeight;

        if ((dw == 0) && (dh == 0)) {
            return bitmap;
        }

        float scaleWidth = (float) mPreferredWidth / width;
        float scaleHeight = (float) mPreferredHeight / height;
        float scaleFactor = Math.min(scaleHeight, scaleWidth);

        int finalWidth = (int) ((width * scaleFactor) + 0.5f);
        int finalHeight = (int) ((height * scaleFactor) + 0.5f);

        return Bitmap.createScaledBitmap(bitmap, finalWidth, finalHeight, false);
    }

    /**
     * Returns the original size of the image.
     */
    private Point calculateOriginalDimensions(URL url) {
        int inSampleSize = 0;
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        options.inSampleSize = inSampleSize;
        HttpURLConnection connection = null;
        InputStream stream = null;
        try {
            connection = (HttpURLConnection) url.openConnection();
            stream = connection.getInputStream();
            BitmapFactory.decodeStream(stream, null, options);
            return new Point(options.outWidth, options.outHeight);
        } catch (IOException e) {
             /* ignore */
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e) { /* ignore */
                }
            }
        }
        return new Point(0, 0);
    }

    /**
     * Find the appropriate in-sample-size (as an inverse power of 2) to help reduce the size of
     * downloaded image.
     */
    private int calculateInSampleSize(int originalWidth, int originalHeight,
            int reqWidth, int reqHeight) {
        // Raw height and width of image
        int inSampleSize = 1;

        if (originalHeight > reqHeight || originalWidth > reqWidth) {

            final int halfHeight = originalHeight / 2;
            final int halfWidth = originalWidth / 2;

            // Calculate the largest inSampleSize value that is a power of 2 and keeps both
            // height and width larger than the requested height and width.
            while ((halfHeight / inSampleSize) > reqHeight
                    && (halfWidth / inSampleSize) > reqWidth) {
                inSampleSize *= 2;
            }
        }

        return inSampleSize;
    }
}