/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * 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.android.videoeditor;

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import android.view.ScaleGestureDetector.OnScaleGestureListener;
import android.widget.FrameLayout;
import android.widget.RadioGroup;
import android.widget.Toast;

import com.android.videoeditor.widgets.ImageViewTouchBase;

/**
 * Activity for setting the begin and end Ken Burns viewing rectangles
 */
public class KenBurnsActivity extends Activity {
    // Logging
    private static final String TAG = "KenBurnsActivity";

    // State keys
    private static final String STATE_WHICH_RECTANGLE_ID = "which";
    private static final String STATE_START_RECTANGLE = "start";
    private static final String STATE_END_RECTANGLE = "end";

    // Intent extras
    public static final String PARAM_WIDTH = "width";
    public static final String PARAM_HEIGHT = "height";
    public static final String PARAM_FILENAME = "filename";
    public static final String PARAM_MEDIA_ITEM_ID = "media_item_id";
    public static final String PARAM_START_RECT = "start_rect";
    public static final String PARAM_END_RECT = "end_rect";

    private static final int MAX_HW_BITMAP_WIDTH = 2048;
    private static final int MAX_HW_BITMAP_HEIGHT = 2048;
    private static final int MAX_WIDTH = 1296;
    private static final int MAX_HEIGHT = 720;
    private static final int MAX_PAN = 3;

    // Instance variables
    private final Rect mStartRect = new Rect(0, 0, 0, 0);
    private final Rect mEndRect = new Rect(0, 0, 0, 0);
    private final RectF mMatrixRect = new RectF(0, 0, 0, 0);
    private RadioGroup mRadioGroup;
    private ImageViewTouchBase mImageView;
    private View mDoneButton;
    private GestureDetector mGestureDetector;
    private ScaleGestureDetector mScaleGestureDetector;
    private boolean mPaused = true;
    private int mMediaItemWidth, mMediaItemHeight;
    private float mImageViewScale;
    private int mImageSubsample;
    private Bitmap mBitmap;

    /**
     * The simple gestures listener
     */
    private class MyGestureListener extends GestureDetector.SimpleOnGestureListener {
        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            if (mImageView.getScale() > 1F) {
                mImageView.postTranslateCenter(-distanceX, -distanceY);
                saveBitmapRectangle();
            }

            return true;
        }

        @Override
        public boolean onSingleTapUp(MotionEvent e) {
            return true;
        }

        @Override
        public boolean onDoubleTap(MotionEvent e) {
            // Switch between the original scale and 3x scale.
            if (mImageView.getScale() > 2F) {
                mImageView.zoomTo(1F);
            } else {
                mImageView.zoomTo(3F, e.getX(), e.getY());
            }

            saveBitmapRectangle();
            return true;
        }
    }

    /**
     * Scale gesture listener
     */
    private class MyScaleGestureListener implements OnScaleGestureListener {
        @Override
        public boolean onScaleBegin(ScaleGestureDetector detector) {
            return true;
        }

        @Override
        public boolean onScale(ScaleGestureDetector detector) {
            final float relativeScaleFactor = detector.getScaleFactor();
            final float newAbsoluteScale = relativeScaleFactor * mImageView.getScale();
            if (newAbsoluteScale < 1.0F) {
                return false;
            }

            mImageView.zoomTo(newAbsoluteScale, detector.getFocusX(), detector.getFocusY());
            return true;
        }

        @Override
        public void onScaleEnd(ScaleGestureDetector detector) {
            saveBitmapRectangle();
        }
    }

    /**
     * Image loader class
     */
    private class ImageLoaderAsyncTask extends AsyncTask<Void, Void, Bitmap> {
        // Instance variables
        private final String mFilename;

        /**
         * Constructor
         *
         * @param filename The filename
         */
        public ImageLoaderAsyncTask(String filename) {
            mFilename = filename;
            showProgress(true);
        }

        @Override
        protected Bitmap doInBackground(Void... zzz) {
            if (mPaused) {
                return null;
            }

            // Wait for the layout to complete
            while (mImageView.getWidth() <= 0) {
                try {
                    Thread.sleep(30);
                } catch (InterruptedException ex) {
                }
            }

            if (mBitmap != null) {
                return mBitmap;
            } else {
                final BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = mImageSubsample;
                return BitmapFactory.decodeFile(mFilename, options);
            }
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (bitmap == null) {
                if (!mPaused) {
                    finish();
                }
                return;
            }

            if (!mPaused) {
                showProgress(false);
                mRadioGroup.setEnabled(true);
                mImageView.setImageBitmapResetBase(bitmap, true);
                mBitmap = bitmap;
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "Bitmap size: " + bitmap.getWidth() + "x" + bitmap.getHeight()
                            + ", bytes: " + (bitmap.getRowBytes() * bitmap.getHeight()));
                }

                showBitmapRectangle();
            }
        }
    }

    @Override
    public void onCreate(Bundle state) {
        super.onCreate(state);
        setContentView(R.layout.ken_burns_layout);
        setFinishOnTouchOutside(true);

        mMediaItemWidth = getIntent().getIntExtra(PARAM_WIDTH, 0);
        mMediaItemHeight = getIntent().getIntExtra(PARAM_HEIGHT, 0);
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "Media item size: " + mMediaItemWidth + "x" + mMediaItemHeight);
        }

        // Setup the image view
        mImageView = (ImageViewTouchBase)findViewById(R.id.ken_burns_image);

        // Set the width and height of the image view
        final FrameLayout.LayoutParams lp =
            (FrameLayout.LayoutParams)mImageView.getLayoutParams();
        if (mMediaItemWidth >= mMediaItemHeight) {
            lp.width = Math.min(mMediaItemWidth, MAX_WIDTH) / MAX_PAN;
            // Compute the height by preserving the aspect ratio
            lp.height = (lp.width * mMediaItemHeight) / mMediaItemWidth;
            mImageSubsample = mMediaItemWidth / (lp.width * MAX_PAN);
        } else {
            lp.height = Math.min(mMediaItemHeight, MAX_HEIGHT) / MAX_PAN;
            // Compute the width by preserving the aspect ratio
            lp.width = (lp.height * mMediaItemWidth) / mMediaItemHeight;
            mImageSubsample = mMediaItemHeight / (lp.height * MAX_PAN);
        }

        // Ensure that the size of the bitmap will not exceed the size supported
        // by HW vendors
        while ((mMediaItemWidth / mImageSubsample > MAX_HW_BITMAP_WIDTH) ||
                (mMediaItemHeight / mImageSubsample > MAX_HW_BITMAP_HEIGHT)) {
            mImageSubsample++;
        }

        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "View size: " + lp.width + "x" + lp.height
                    + ", subsample: " + mImageSubsample);
        }

        // If the image is too small the image view may be too small to pinch
        if (lp.width < 120 || lp.height < 120) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Image is too small: " + lp.width + "x" + lp.height);
            }

            Toast.makeText(this, getString(R.string.pan_zoom_small_image_error),
                    Toast.LENGTH_LONG).show();
            finish();
            return;
        }

        mImageView.setLayoutParams(lp);
        mImageViewScale = ((float)lp.width) / ((float)mMediaItemWidth);

        mGestureDetector = new GestureDetector(this, new MyGestureListener());
        mScaleGestureDetector = new ScaleGestureDetector(this, new MyScaleGestureListener());

        mRadioGroup = (RadioGroup)findViewById(R.id.which_rectangle);
        if (state != null) {
            mRadioGroup.check(state.getInt(STATE_WHICH_RECTANGLE_ID));
            mStartRect.set((Rect)state.getParcelable(STATE_START_RECTANGLE));
            mEndRect.set((Rect)state.getParcelable(STATE_END_RECTANGLE));
        } else {
            mRadioGroup.check(R.id.start_rectangle);
            final Rect startRect = (Rect)getIntent().getParcelableExtra(PARAM_START_RECT);
            if (startRect != null) {
                mStartRect.set(startRect);
            } else {
                mStartRect.set(0, 0, mMediaItemWidth, mMediaItemHeight);
            }

            final Rect endRect = (Rect)getIntent().getParcelableExtra(PARAM_END_RECT);
            if (endRect != null) {
                mEndRect.set(endRect);
            } else {
                mEndRect.set(0, 0, mMediaItemWidth, mMediaItemHeight);
            }
        }

        mDoneButton = findViewById(R.id.done);
        enableDoneButton();

        // Disable the ratio buttons until we load the image
        mRadioGroup.setEnabled(false);

        mRadioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup group, int checkedId) {
                switch (checkedId) {
                    case R.id.start_rectangle: {
                        showBitmapRectangle();
                        break;
                    }

                    case R.id.end_rectangle: {
                        showBitmapRectangle();
                        break;
                    }

                    case R.id.done: {
                        final Intent extra = new Intent();
                        extra.putExtra(PARAM_MEDIA_ITEM_ID,
                                getIntent().getStringExtra(PARAM_MEDIA_ITEM_ID));
                        extra.putExtra(PARAM_START_RECT, mStartRect);
                        extra.putExtra(PARAM_END_RECT, mEndRect);
                        setResult(RESULT_OK, extra);
                        finish();
                        break;
                    }

                    default: {
                        break;
                    }
                }
            }
        });

        mBitmap = (Bitmap) getLastNonConfigurationInstance();

        mImageView.setEventListener(new ImageViewTouchBase.ImageTouchEventListener() {
            @Override
            public boolean onImageTouchEvent(MotionEvent ev) {
                mScaleGestureDetector.onTouchEvent(ev);
                mGestureDetector.onTouchEvent(ev);
                return true;
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();

        mPaused = false;
        // Load the image
        new ImageLoaderAsyncTask(getIntent().getStringExtra(PARAM_FILENAME)).execute();
    }

    @Override
    protected void onPause() {
        super.onPause();

        mPaused = true;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (!isChangingConfigurations()) {
            if (mBitmap != null) {
                mBitmap.recycle();
                mBitmap = null;
            }

            System.gc();
        }
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        return mBitmap;
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        final RadioGroup radioGroup = (RadioGroup)findViewById(R.id.which_rectangle);

        outState.putInt(STATE_WHICH_RECTANGLE_ID, radioGroup.getCheckedRadioButtonId());
        outState.putParcelable(STATE_START_RECTANGLE, mStartRect);
        outState.putParcelable(STATE_END_RECTANGLE, mEndRect);
    }

    public void onClickHandler(View target) {
        switch (target.getId()) {
            case R.id.done: {
                final Intent extra = new Intent();
                extra.putExtra(PARAM_MEDIA_ITEM_ID,
                        getIntent().getStringExtra(PARAM_MEDIA_ITEM_ID));
                extra.putExtra(PARAM_START_RECT, mStartRect);
                extra.putExtra(PARAM_END_RECT, mEndRect);
                setResult(RESULT_OK, extra);
                finish();
                break;
            }

            default: {
                break;
            }
        }
    }

    /**
     * Show/hide the progress bar
     *
     * @param show true to show the progress
     */
    private void showProgress(boolean show) {
        if (show) {
            findViewById(R.id.image_loading).setVisibility(View.VISIBLE);
        } else {
            findViewById(R.id.image_loading).setVisibility(View.GONE);
        }
    }

    /**
     * Enable the "Done" button if both rectangles are set
     */
    private void enableDoneButton() {
        mDoneButton.setEnabled(!mStartRect.isEmpty() && !mEndRect.isEmpty());
    }

    /**
     * Show the bitmap rectangle
     */
    private void showBitmapRectangle() {
        final int checkedRect = mRadioGroup.getCheckedRadioButtonId();
        switch (checkedRect) {
            case R.id.start_rectangle: {
                if (!mStartRect.isEmpty()) {
                    mImageView.reset();
                    final float scale = ((float)mMediaItemWidth)
                            / ((float)(mStartRect.right - mStartRect.left));
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "showBitmapRectangle START: " + scale + " "
                                + mStartRect.left + ", " + mStartRect.top + ", "
                                + mStartRect.right + ", " + mStartRect.bottom);
                    }
                    if (scale > 1F) {
                        mImageView.zoomToOffset(scale, mStartRect.left * scale * mImageViewScale,
                                mStartRect.top * scale * mImageViewScale);
                    }
                }
                break;
            }

            case R.id.end_rectangle: {
                if (!mEndRect.isEmpty()) {
                    mImageView.reset();
                    final float scale = ((float)mMediaItemWidth)
                            / ((float)(mEndRect.right - mEndRect.left));
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "showBitmapRectangle END: " + scale + " "
                                + mEndRect.left + ", " + mEndRect.top + ", "
                                + mEndRect.right + ", " + mEndRect.bottom);
                    }
                    if (scale > 1F) {
                        mImageView.zoomToOffset(scale, mEndRect.left * scale * mImageViewScale,
                                mEndRect.top * scale * mImageViewScale);
                    }
                }
                break;
            }

            default: {
                break;
            }
        }
    }

    /**
     * Show the bitmap rectangle
     */
    private void saveBitmapRectangle() {
        final int checkedRect = mRadioGroup.getCheckedRadioButtonId();
        final FrameLayout.LayoutParams lp =
            (FrameLayout.LayoutParams)mImageView.getLayoutParams();
        switch (checkedRect) {
            case R.id.start_rectangle: {
                mMatrixRect.set(0, 0, lp.width, lp.height);

                mImageView.mapRect(mMatrixRect);
                final float scale = mImageView.getScale();

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "START RAW: " + scale + ", rect: " + mMatrixRect.left
                            + ", " + mMatrixRect.top + ", " + mMatrixRect.right
                            + ", " + mMatrixRect.bottom);
                }

                final int left = (int)((-mMatrixRect.left/scale) / mImageViewScale);
                final int top = (int)((-mMatrixRect.top/scale) / mImageViewScale);
                final int right = (int)(((-mMatrixRect.left + lp.width)/scale) / mImageViewScale);
                final int bottom = (int)(((-mMatrixRect.top + lp.height)/scale) / mImageViewScale);

                mStartRect.set(left, top, right, bottom);
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "START: " + mStartRect.left + ", " + mStartRect.top + ", "
                            + mStartRect.right + ", " + mStartRect.bottom);
                }

                enableDoneButton();
                break;
            }

            case R.id.end_rectangle: {
                mMatrixRect.set(0, 0, lp.width, lp.height);

                mImageView.mapRect(mMatrixRect);
                final float scale = mImageView.getScale();

                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "END RAW: " + scale + ", rect: " + mMatrixRect.left
                            + ", " + mMatrixRect.top + ", " + mMatrixRect.right
                            + ", " + mMatrixRect.bottom);
                }

                final int left = (int)((-mMatrixRect.left/scale) / mImageViewScale);
                final int top = (int)((-mMatrixRect.top/scale) / mImageViewScale);
                final int right = (int)(((-mMatrixRect.left + lp.width)/scale) / mImageViewScale);
                final int bottom = (int)(((-mMatrixRect.top + lp.height)/scale) / mImageViewScale);

                mEndRect.set(left, top, right, bottom);
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "END: " + mEndRect.left + ", " + mEndRect.top + ", "
                            + mEndRect.right + ", " + mEndRect.bottom);
                }

                enableDoneButton();
                break;
            }

            default: {
                break;
            }
        }
    }
}