/*
 * Copyright (C) 2010 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.widgets;

import java.util.List;

import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.util.AttributeSet;
import android.util.Log;
import android.view.ActionMode;
import android.view.Display;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

import com.android.videoeditor.AlertDialogs;
import com.android.videoeditor.OverlayTitleEditor;
import com.android.videoeditor.VideoEditorActivity;
import com.android.videoeditor.service.ApiService;
import com.android.videoeditor.service.MovieMediaItem;
import com.android.videoeditor.service.MovieOverlay;
import com.android.videoeditor.service.VideoEditorProject;
import com.android.videoeditor.util.FileUtils;
import com.android.videoeditor.util.MediaItemUtils;
import com.android.videoeditor.R;

/**
 * LinearLayout which displays overlays.
 */
public class OverlayLinearLayout extends LinearLayout {
    // Logging
    private static final String TAG = "OverlayLinearLayout";

    // Dialog parameter ids
    private static final String PARAM_DIALOG_MEDIA_ITEM_ID = "media_item_id";

    // Default overlay duration
    public static final long DEFAULT_TITLE_DURATION = 3000;

    // Instance variables
    private final ItemMoveGestureListener mOverlayGestureListener;
    private final int mHalfParentWidth;
    private final Handler mHandler;
    private final int mHandleWidth;
    private ActionMode mOverlayActionMode;
    private boolean mPlaybackInProgress;
    private VideoEditorProject mProject;
    private HandleView mLeftHandle, mRightHandle;
    private boolean mMoveLayoutPending;
    private View mResizingView;

    /**
     * The overlay listener
     */
    public interface OverlayLayoutListener {
        /**
         * Add a new overlay
         */
        public void onAddOverlay();
    }

    /**
     * The overlay action mode handler.
     */
    private class OverlayActionModeCallback implements ActionMode.Callback {
        // Instance variables
        private final MovieMediaItem mMediaItem;

        public OverlayActionModeCallback(MovieMediaItem mediaItem) {
            mMediaItem = mediaItem;
        }

        @Override
        public boolean onCreateActionMode(ActionMode mode, Menu menu) {
            mOverlayActionMode = mode;

            final Activity activity = (Activity) getContext();
            activity.getMenuInflater().inflate(R.menu.overlay_mode_menu, menu);
            return true;
        }

        @Override
        public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
            final boolean enable = !ApiService.isProjectBeingEdited(mProject.getPath()) &&
                !mPlaybackInProgress;

            final MenuItem eomi = menu.findItem(R.id.action_edit_overlay);
            eomi.setEnabled(enable);

            final MenuItem romi = menu.findItem(R.id.action_remove_overlay);
            romi.setEnabled(enable);

            return true;
        }

        @Override
        public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
            switch (item.getItemId()) {
                case R.id.action_edit_overlay: {
                    final Activity activity = (Activity) getContext();
                    final Intent intent = new Intent(activity, OverlayTitleEditor.class);
                    intent.putExtra(OverlayTitleEditor.PARAM_MEDIA_ITEM_ID, mMediaItem.getId());

                    final MovieOverlay overlay = mMediaItem.getOverlay();
                    intent.putExtra(OverlayTitleEditor.PARAM_OVERLAY_ID, overlay.getId());
                    intent.putExtra(OverlayTitleEditor.PARAM_OVERLAY_ATTRIBUTES,
                            overlay.buildUserAttributes());
                    activity.startActivityForResult(intent,
                            VideoEditorActivity.REQUEST_CODE_PICK_OVERLAY);
                    break;
                }

                case R.id.action_remove_overlay: {
                    final Bundle bundle = new Bundle();
                    bundle.putString(PARAM_DIALOG_MEDIA_ITEM_ID, mMediaItem.getId());
                    ((Activity) getContext()).showDialog(
                            VideoEditorActivity.DIALOG_REMOVE_OVERLAY_ID, bundle);
                    break;
                }

                default: {
                    break;
                }
            }

            return true;
        }

        @Override
        public void onDestroyActionMode(ActionMode mode) {
            final View overlayView = getOverlayView(mMediaItem.getId());
            if (overlayView != null) {
                selectView(overlayView, false);
            }

            mOverlayActionMode = null;
        }
    }

    public OverlayLinearLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        mOverlayGestureListener = new ItemMoveGestureListener() {
            private MovieMediaItem mScrollMediaItem;
            private MovieOverlay mScrollOverlay;
            private long mScrollTotalDurationMs, mScrollMediaItemStartTime;
            private boolean mScrolled;

            @Override
            public boolean onSingleTapConfirmed(View view, int area, MotionEvent e) {
                if (mPlaybackInProgress) {
                    return false;
                }

                switch (((OverlayView)view).getState()) {
                    case OverlayView.STATE_STUB: {
                        unselectAllViews();
                        ((OverlayView)view).setState(OverlayView.STATE_ADD_BUTTON);
                        break;
                    }

                    case OverlayView.STATE_ADD_BUTTON: {
                        final MovieMediaItem mediaItem = (MovieMediaItem)view.getTag();
                        final Intent intent = new Intent(getContext(), OverlayTitleEditor.class);
                        intent.putExtra(OverlayTitleEditor.PARAM_MEDIA_ITEM_ID, mediaItem.getId());
                        ((Activity) getContext()).startActivityForResult(intent,
                                VideoEditorActivity.REQUEST_CODE_PICK_OVERLAY);
                        break;
                    }

                    case OverlayView.STATE_OVERLAY: {
                        if (!view.isSelected()) {
                            selectView(view, true);
                        }
                        break;
                    }

                    default: {
                        break;
                    }
                }

                return true;
            }

            @Override
            public void onLongPress(View view, MotionEvent e) {
                if (mPlaybackInProgress) {
                    return;
                }

                switch (((OverlayView)view).getState()) {
                    case OverlayView.STATE_STUB: {
                        break;
                    }

                    case OverlayView.STATE_ADD_BUTTON: {
                        break;
                    }

                    case OverlayView.STATE_OVERLAY: {
                        if (!view.isSelected()) {
                            selectView(view, true);
                        }

                        if (mOverlayActionMode == null) {
                            startActionMode(new OverlayActionModeCallback(
                                    (MovieMediaItem)view.getTag()));
                        }
                        break;
                    }

                    default: {
                        break;
                    }
                }
            }

            @Override
            public boolean onMoveBegin(View view, MotionEvent e) {
                if (mPlaybackInProgress) {
                    return false;
                }

                mScrollMediaItem = (MovieMediaItem)view.getTag();
                mScrollMediaItemStartTime = mProject.getMediaItemBeginTime(mScrollMediaItem.getId());
                mScrollOverlay = mScrollMediaItem.getOverlay();
                // The duration of the timeline does not change while moving the Overlay
                mScrollTotalDurationMs = mProject.computeDuration();
                mRightHandle.setVisibility(View.GONE);
                mScrolled = false;
                return true;
            }

            @Override
            public boolean onMove(View view, MotionEvent e1, MotionEvent e2) {
                final int beginPos = (int)(view.getLeft() - mHalfParentWidth - e1.getX() +
                        e2.getX());
                long startTimeMs = ((beginPos * mScrollTotalDurationMs) /
                        (getWidth() - (2 * mHalfParentWidth)));
                if (startTimeMs <= mScrollMediaItemStartTime) {
                    startTimeMs = mScrollMediaItemStartTime;
                } else if (startTimeMs + mScrollOverlay.getAppDuration() >
                    mScrollMediaItemStartTime + mScrollMediaItem.getAppTimelineDuration()) {
                    startTimeMs = mScrollMediaItemStartTime +
                        mScrollMediaItem.getAppTimelineDuration() - mScrollOverlay.getAppDuration();
                }

                mScrolled = true;
                mScrollOverlay.setAppStartTime(startTimeMs - mScrollMediaItemStartTime +
                        mScrollMediaItem.getAppBoundaryBeginTime());
                requestLayout();
                return true;
            }

            @Override
            public void onMoveEnd(View view) {
                mRightHandle.setVisibility(View.VISIBLE);
                if (mScrolled) {
                    mScrolled = false;
                    // Update the limits of the right handle
                    mRightHandle.setLimitReached(mScrollOverlay.getAppDuration() <=
                        MediaItemUtils.getMinimumMediaItemDuration(mScrollMediaItem),
                        mScrollOverlay.getAppStartTime() + mScrollOverlay.getAppDuration() >=
                            mScrollMediaItem.getAppBoundaryEndTime());

                    ApiService.setOverlayStartTime(getContext(), mProject.getPath(),
                            mScrollMediaItem.getId(), mScrollOverlay.getId(),
                            mScrollOverlay.getAppStartTime());
                }
            }
        };

        // Add the beginning timeline item
        final View beginView = inflate(getContext(), R.layout.empty_timeline_item, null);
        beginView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                unselectAllViews();
            }
        });
        addView(beginView);

        // Add the end timeline item
        final View endView = inflate(getContext(), R.layout.empty_timeline_item, null);
        endView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                unselectAllViews();
            }
        });
        addView(endView);

        mLeftHandle = (HandleView)inflate(getContext(), R.layout.left_handle_view, null);
        addView(mLeftHandle);

        mRightHandle = (HandleView)inflate(getContext(), R.layout.right_handle_view, null);
        addView(mRightHandle);

        mHandleWidth = (int)context.getResources().getDimension(R.dimen.handle_width);

        // Compute half the width of the screen (and therefore the parent view)
        final Display display = ((Activity)context).getWindowManager().getDefaultDisplay();
        mHalfParentWidth = display.getWidth() / 2;

        mHandler = new Handler();

        setMotionEventSplittingEnabled(false);
   }

    public OverlayLinearLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public OverlayLinearLayout(Context context) {
        this(context, null, 0);
    }

    /**
     * @param project The project
     */
    public void setProject(VideoEditorProject project) {
        // Close the contextual action bar
        if (mOverlayActionMode != null) {
            mOverlayActionMode.finish();
            mOverlayActionMode = null;
        }

        mLeftHandle.setVisibility(View.GONE);
        mLeftHandle.setListener(null);
        mRightHandle.setVisibility(View.GONE);
        mRightHandle.setListener(null);

        removeViews();

        mProject = project;
    }

    /**
     * @param inProgress true if playback is in progress
     */
    public void setPlaybackInProgress(boolean inProgress) {
        mPlaybackInProgress = inProgress;

        // Don't allow the user to interact with the overlays while playback
        // is in progress
        if (inProgress && mOverlayActionMode != null) {
            mOverlayActionMode.finish();
            mOverlayActionMode = null;
        }
    }

    /**
     * Add all the media items
     *
     * @param mediaItems The list of media items
     */
    public void addMediaItems(List<MovieMediaItem> mediaItems) {
        if (mOverlayActionMode != null) {
            mOverlayActionMode.finish();
            mOverlayActionMode = null;
        }

        removeViews();

        for (MovieMediaItem mediaItem : mediaItems) {
            addMediaItem(mediaItem);
        }
    }

    /**
     * Add a new media item at the end of the timeline
     *
     * @param mediaItem The media item
     * @return The view that was added
     */
    private View addMediaItem(MovieMediaItem mediaItem) {
        final OverlayView overlayView = (OverlayView)inflate(getContext(),
                R.layout.overlay_item, null);
        if (mediaItem.getOverlay() != null) {
            overlayView.setState(OverlayView.STATE_OVERLAY);
        } else {
            overlayView.setState(OverlayView.STATE_STUB);
        }

        overlayView.setTag(mediaItem);

        overlayView.setGestureListener(mOverlayGestureListener);

        final LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
                LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.FILL_PARENT);
        addView(overlayView, getChildCount() - 1, lp);

        if (mOverlayActionMode != null) {
            mOverlayActionMode.invalidate();
        }

        requestLayout();
        return overlayView;
    }

    /**
     * Insert a new media item after the specified media item id
     *
     * @param mediaItem The media item
     * @param afterMediaItemId The id of the media item preceding the media item
     */
    public void insertMediaItem(MovieMediaItem mediaItem, String afterMediaItemId) {
        final OverlayView overlayView = (OverlayView)inflate(getContext(),
                R.layout.overlay_item, null);
        if (mediaItem.getOverlay() != null) {
            overlayView.setState(OverlayView.STATE_OVERLAY);
        } else {
            overlayView.setState(OverlayView.STATE_STUB);
        }

        overlayView.setTag(mediaItem);

        overlayView.setGestureListener(mOverlayGestureListener);

        int insertViewIndex;
        if (afterMediaItemId != null) {
            if ((insertViewIndex = getMediaItemViewIndex(afterMediaItemId)) == -1) {
                Log.e(TAG, "Media item not found: " + afterMediaItemId);
                return;
            }

            insertViewIndex++;
        } else { // Insert at the beginning
            insertViewIndex = 1;
        }

        final LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
                LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.FILL_PARENT);
        addView(overlayView, insertViewIndex, lp);

        if (mOverlayActionMode != null) {
            mOverlayActionMode.invalidate();
        }

        requestLayout();
    }

    /**
     * Update media item
     *
     * @param mediaItem The media item
     */
    public void updateMediaItem(MovieMediaItem mediaItem) {
        final String mediaItemId = mediaItem.getId();
        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View childView = getChildAt(i);
            final MovieMediaItem mi = (MovieMediaItem)childView.getTag();
            if (mi != null && mediaItemId.equals(mi.getId())) {
                if (mediaItem != mi) {
                    // The media item is a new instance
                    childView.setTag(mediaItem);
                }
                break;
            }
        }

        requestLayout();
        invalidate();
    }

    /**
     * Remove a media item
     *
     * @param mediaItemId The media item id
     * @return The view which was removed
     */
    public View removeMediaItem(String mediaItemId) {
        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View childView = getChildAt(i);
            final MovieMediaItem mediaItem = (MovieMediaItem)childView.getTag();
            if (mediaItem != null && mediaItem.getId().equals(mediaItemId)) {
                removeViewAt(i);
                requestLayout();
                return childView;
            }
        }

        return null;
    }

    /**
     * A new overlay was added
     *
     * @param mediaItemId The media item which owns the overlay
     * @param overlay The overlay which was added
     */
    public void addOverlay(String mediaItemId, MovieOverlay overlay) {
        final OverlayView view = (OverlayView)getOverlayView(mediaItemId);
        if (view == null) {
            Log.e(TAG, "addOverlay: Media item not found: " + mediaItemId);
            return;
        }

        view.setState(OverlayView.STATE_OVERLAY);

        requestLayout();
        invalidate();
    }

    /**
     * An overlay was removed
     *
     * @param mediaItemId The media item which owns the overlay
     * @param overlayId The overlay id
     */
    public void removeOverlay(String mediaItemId, String overlayId) {
        final OverlayView view = (OverlayView)getOverlayView(mediaItemId);
        if (view == null) {
            Log.e(TAG, "removeOverlay: Media item not found: " + mediaItemId);
            return;
        }

        view.setState(OverlayView.STATE_STUB);

        requestLayout();
        invalidate();

        if (mOverlayActionMode != null) {
            mOverlayActionMode.finish();
            mOverlayActionMode = null;
        }
    }

    /**
     * Update the overlay attributes
     *
     * @param mediaItemId The media item id
     * @param overlayId The overlay id
     * @param userAttributes The overlay attributes
     */
    public void updateOverlayAttributes(String mediaItemId, String overlayId,
            Bundle userAttributes) {
        final MovieMediaItem mediaItem = mProject.getMediaItem(mediaItemId);
        if (mediaItem == null) {
            Log.e(TAG, "updateOverlayAttributes: Media item not found: " + mediaItemId);
            return;
        }

        final View overlayView = getOverlayView(mediaItemId);
        if (overlayView == null) {
            Log.e(TAG, "updateOverlayAttributes: Overlay not found: " + overlayId);
            return;
        }

        overlayView.invalidate();
    }

    /**
     * Refresh the view
     */
    public void refresh() {
        requestLayout();
        invalidate();
    }

    /**
     * Invalidate the CAB
     */
    public void invalidateCAB() {
        if (mOverlayActionMode != null) {
            mOverlayActionMode.invalidate();
        }
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        final long totalDurationMs = mProject.computeDuration();
        final int viewWidth = getWidth() - (2 * mHalfParentWidth);

        final int leftViewWidth = (Integer)((View)getParent().getParent()).getTag(
                R.id.left_view_width);
        long mediaItemStartTimeMs = 0;
        int left = 0;
        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View view = getChildAt(i);
            final MovieMediaItem mediaItem = (MovieMediaItem)view.getTag();
            if (mediaItem != null) { // Media item
                final MovieOverlay overlay = mediaItem.getOverlay();

                final int right;
                if (overlay != null) {
                    // Note that this logic matches the one used in ApiService
                    // when handling the OP_MEDIA_ITEM_SET_BOUNDARIES command
                    if (overlay.getAppStartTime() <= mediaItem.getAppBoundaryBeginTime()) {
                        left = leftViewWidth + (int)((mediaItemStartTimeMs * viewWidth) /
                                totalDurationMs);
                        final long durationMs = Math.min(overlay.getAppDuration(),
                                mediaItem.getAppTimelineDuration());
                        right = leftViewWidth + (int)(((mediaItemStartTimeMs + durationMs) *
                                viewWidth) / totalDurationMs);
                    } else if (overlay.getAppStartTime() + overlay.getAppDuration() >
                                mediaItem.getAppBoundaryEndTime()) {
                        final long startTimeMs = Math.max(mediaItem.getAppBoundaryBeginTime(),
                                mediaItem.getAppBoundaryEndTime() - overlay.getAppDuration());
                        left = leftViewWidth + (int)(((mediaItemStartTimeMs + startTimeMs -
                                mediaItem.getAppBoundaryBeginTime()) * viewWidth) /
                                totalDurationMs);
                        final long durationMs = mediaItem.getAppBoundaryEndTime() - startTimeMs;
                        right = leftViewWidth + (int)(((mediaItemStartTimeMs + startTimeMs -
                                mediaItem.getAppBoundaryBeginTime() +
                                durationMs) * viewWidth) / totalDurationMs);
                    } else {
                        left = leftViewWidth + (int)(((mediaItemStartTimeMs +
                                overlay.getAppStartTime() - mediaItem.getAppBoundaryBeginTime()) *
                                viewWidth) / totalDurationMs);
                        right = leftViewWidth + (int)(((mediaItemStartTimeMs
                                + overlay.getAppStartTime() - mediaItem.getAppBoundaryBeginTime() +
                                overlay.getAppDuration()) * viewWidth) / totalDurationMs);
                    }
                } else {
                    left = leftViewWidth + (int)((mediaItemStartTimeMs * viewWidth) /
                            totalDurationMs);
                    right = leftViewWidth + (int)(((mediaItemStartTimeMs
                            + mediaItem.getAppTimelineDuration()) * viewWidth) / totalDurationMs);
                }

                view.layout(left, 0, right, b - t);

                mediaItemStartTimeMs += mediaItem.getAppTimelineDuration();
                if (mediaItem.getEndTransition() != null) {
                    mediaItemStartTimeMs -= mediaItem.getEndTransition().getAppDuration();
                }

                left = right;
            } else if (view == mLeftHandle) {
                if (mResizingView != null) {
                    view.layout(mResizingView.getLeft() - mHandleWidth,
                            mResizingView.getPaddingTop(),
                            mResizingView.getLeft(), b - t - mResizingView.getPaddingBottom());
                }
            } else if (view == mRightHandle) {
                if (mResizingView != null) {
                    view.layout(mResizingView.getRight(), mResizingView.getPaddingTop(),
                            mResizingView.getRight() + mHandleWidth,
                            b - t - mResizingView.getPaddingBottom());
                }
            } else if (i == 0) { // Begin view
                view.layout(left, 0, left + leftViewWidth, b - t);
                left += leftViewWidth;
            } else { // End view
                view.layout(getWidth() - mHalfParentWidth - (mHalfParentWidth - leftViewWidth), 0,
                        getWidth(), b - t);
            }
        }

        mMoveLayoutPending = false;
    }

    /**
     * Create a new dialog
     *
     * @param id The dialog id
     * @param bundle The dialog bundle
     * @return The dialog
     */
    public Dialog onCreateDialog(int id, final Bundle bundle) {
        // If the project is not yet loaded do nothing.
        if (mProject == null) {
            return null;
        }

        switch (id) {
            case VideoEditorActivity.DIALOG_REMOVE_OVERLAY_ID: {
                final MovieMediaItem mediaItem = mProject.getMediaItem(
                        bundle.getString(PARAM_DIALOG_MEDIA_ITEM_ID));
                if (mediaItem == null) {
                    return null;
                }

                final Activity activity = (Activity) getContext();
                return AlertDialogs.createAlert(activity, FileUtils.getSimpleName(
                        mediaItem.getFilename()), 0,
                        activity.getString(R.string.editor_remove_overlay_question),
                        activity.getString(R.string.yes),
                        new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        if (mOverlayActionMode != null) {
                            mOverlayActionMode.finish();
                            mOverlayActionMode = null;
                        }
                        activity.removeDialog(VideoEditorActivity.DIALOG_REMOVE_OVERLAY_ID);

                        ApiService.removeOverlay(activity, mProject.getPath(), mediaItem.getId(),
                                mediaItem.getOverlay().getId());
                    }
                }, activity.getString(R.string.no), new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        activity.removeDialog(VideoEditorActivity.DIALOG_REMOVE_OVERLAY_ID);
                    }
                }, new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialog) {
                        activity.removeDialog(VideoEditorActivity.DIALOG_REMOVE_OVERLAY_ID);
                    }
                }, true);
            }

            default: {
                return null;
            }
        }
    }

    /**
     * Find the overlay view with the specified id
     *
     * @param mediaItemId The media item id
     * @return The overlay view
     */
    private View getOverlayView(String mediaItemId) {
        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View childView = getChildAt(i);
            final MovieMediaItem mediaItem = (MovieMediaItem)childView.getTag();
            if (mediaItem != null && mediaItemId.equals(mediaItem.getId())) {
                return childView;
            }
        }

        return null;
    }

    /**
     * Find the media item view index with the specified id
     *
     * @param mediaItemId The media item id
     * @return The media item view index
     */
    private int getMediaItemViewIndex(String mediaItemId) {
        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View childView = getChildAt(i);
            final Object tag = childView.getTag();
            if (tag != null && tag instanceof MovieMediaItem) {
                final MovieMediaItem mediaItem = (MovieMediaItem)tag;
                if (mediaItemId.equals(mediaItem.getId())) {
                    return i;
                }
            }
        }

        return -1;
    }

    /**
     * Remove all overlay views (leave the beginning and end views)
     */
    private void removeViews() {
        int index = 0;
        while (index < getChildCount()) {
            final MovieMediaItem mediaItem = (MovieMediaItem)getChildAt(index).getTag();
            if (mediaItem != null) {
                removeViewAt(index);
            } else {
                index++;
            }
        }

        requestLayout();
    }

    @Override
    public void setSelected(boolean selected) {
        if (selected == false) {
            // Close the contextual action bar
            if (mOverlayActionMode != null) {
                mOverlayActionMode.finish();
                mOverlayActionMode = null;
            }

            mLeftHandle.setVisibility(View.GONE);
            mLeftHandle.setListener(null);
            mRightHandle.setVisibility(View.GONE);
            mRightHandle.setListener(null);
            mResizingView = null;
        }

        final int childrenCount = getChildCount();
        for (int i = 0; i < childrenCount; i++) {
            final View childView = getChildAt(i);
            childView.setSelected(false);
        }
    }

    /**
     * Select a view and unselect any view that is selected.
     *
     * @param view The view to select
     * @param selected true if selected
     */
    private void selectView(final View selectedView, boolean selected) {
        // Check if the selection has changed
        if (selectedView.isSelected() == selected) {
            return;
        }

        if (selected == false) {
            // Select the new view
            selectedView.setSelected(selected);
            mResizingView = null;
            mLeftHandle.setVisibility(View.GONE);
            mLeftHandle.setListener(null);
            mRightHandle.setVisibility(View.GONE);
            mRightHandle.setListener(null);
            return;
        }

        // Unselect all other views
        unselectAllViews();

        // Select the new view
        selectedView.setSelected(selected);

        final Object tag = selectedView.getTag();
        final MovieMediaItem mediaItem = (MovieMediaItem)tag;
        if (mOverlayActionMode == null) {
            startActionMode(new OverlayActionModeCallback(mediaItem));
        }

        final MovieOverlay overlay = mediaItem.getOverlay();
        final View overlayView = getOverlayView(mediaItem.getId());
        mResizingView = overlayView;

        mRightHandle.setVisibility(View.VISIBLE);
        mRightHandle.bringToFront();
        mRightHandle.setLimitReached(overlay.getAppDuration() <=
            MediaItemUtils.getMinimumMediaItemDuration(mediaItem),
                overlay.getAppStartTime() + overlay.getAppDuration() >=
                    mediaItem.getAppBoundaryEndTime());
        mRightHandle.setListener(new HandleView.MoveListener() {
            private MovieMediaItem mMediaItem;
            private int mMovePosition;
            private long mMinimumDurationMs;

            @Override
            public void onMoveBegin(HandleView view) {
                mMediaItem = mediaItem;
                mMinimumDurationMs = MediaItemUtils.getMinimumMediaItemDuration(mediaItem);
            }

            @Override
            public boolean onMove(HandleView view, int left, int delta) {
                if (mMoveLayoutPending) {
                    return false;
                }

                final int position = left + delta;
                // Compute what will become the width of the view
                final int newWidth = position - overlayView.getLeft();

                // Compute the new duration
                long newDurationMs = (newWidth * mProject.computeDuration()) /
                        (getWidth() - (2 * mHalfParentWidth));

                if (newDurationMs < mMinimumDurationMs) {
                    newDurationMs = mMinimumDurationMs;
                } else if (overlay.getAppStartTime() + newDurationMs >
                        mMediaItem.getAppBoundaryEndTime()) {
                    newDurationMs = mMediaItem.getAppBoundaryEndTime() - overlay.getAppStartTime();
                }

                mRightHandle.setLimitReached(overlay.getAppDuration() <= mMinimumDurationMs,
                        overlay.getAppStartTime() + overlay.getAppDuration() >=
                            mMediaItem.getAppBoundaryEndTime());
                overlay.setAppDuration(newDurationMs);

                mMovePosition = position;
                mMoveLayoutPending = true;

                requestLayout();

                return true;
            }

            @Override
            public void onMoveEnd(final HandleView view, final int left, final int delta) {
                final int position = left + delta;
                if (mMoveLayoutPending || (position != mMovePosition)) {
                    mHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            if (mMoveLayoutPending) {
                                mHandler.post(this);
                            } else if (position != mMovePosition) {
                                if (onMove(view, left, delta)) {
                                    mHandler.post(this);
                                } else {
                                    scaleDone();
                                }
                            } else {
                                scaleDone();
                            }
                        }
                    });
                } else {
                    scaleDone();
                }
            }

            /**
             * Scale is done
             */
            public void scaleDone() {
                ApiService.setOverlayDuration(getContext(), mProject.getPath(),
                        mMediaItem.getId(), overlay.getId(), overlay.getAppDuration());
            }
        });
    }

    /**
     * Unselect all views
     */
    private void unselectAllViews() {
        ((RelativeLayout)getParent()).setSelected(false);
    }
}