package com.android.launcher3;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.util.Log;
import android.view.View;

import static com.android.launcher3.Workspace.State.NORMAL;
import static com.android.launcher3.Workspace.State.OVERVIEW;

/**
 * Manages the animations that play as the user pinches to/from overview mode.
 *
 *  It will look like this pinching in:
 * - Workspace scales down
 * - At some threshold 1, hotseat and QSB fade out (full animation)
 * - At a later threshold 2, panel buttons fade in and scrim fades in
 * - At a final threshold 3, snap to overview
 *
 * Pinching out:
 * - Workspace scales up
 * - At threshold 1, panel buttons fade out
 * - At threshold 2, hotseat and QSB fade in and scrim fades out
 * - At threshold 3, snap to workspace
 *
 * @see PinchToOverviewListener
 * @see PinchThresholdManager
 */
public class PinchAnimationManager {
    private static final String TAG = "PinchAnimationManager";

    private static final int THRESHOLD_ANIM_DURATION = 150;

    private Launcher mLauncher;
    private Workspace mWorkspace;

    private float mOverviewScale;
    private float mOverviewTranslationY;
    private int mNormalOverviewTransitionDuration;
    private final int[] mVisiblePageRange = new int[2];
    private boolean mIsAnimating;

    // Animators
    private Animator mShowPageIndicatorAnimator;
    private Animator mShowHotseatAnimator;
    private Animator mShowOverviewPanelButtonsAnimator;
    private Animator mShowScrimAnimator;
    private Animator mHidePageIndicatorAnimator;
    private Animator mHideHotseatAnimator;
    private Animator mHideOverviewPanelButtonsAnimator;
    private Animator mHideScrimAnimator;

    public PinchAnimationManager(Launcher launcher) {
        mLauncher = launcher;
        mWorkspace = launcher.mWorkspace;

        mOverviewScale = mWorkspace.getOverviewModeShrinkFactor();
        mOverviewTranslationY = mWorkspace.getOverviewModeTranslationY();
        mNormalOverviewTransitionDuration = mWorkspace.getStateTransitionAnimation()
                .mOverviewTransitionTime;

        initializeAnimators();
    }

    private void initializeAnimators() {
        mShowPageIndicatorAnimator = new LauncherViewPropertyAnimator(
                mWorkspace.getPageIndicator()).alpha(1f).withLayer();
        mShowPageIndicatorAnimator.setInterpolator(null);

        mShowHotseatAnimator = new LauncherViewPropertyAnimator(mLauncher.getHotseat())
                .alpha(1f).withLayer();
        mShowHotseatAnimator.setInterpolator(null);

        mShowOverviewPanelButtonsAnimator = new LauncherViewPropertyAnimator(
                mLauncher.getOverviewPanel()).alpha(1f).withLayer();
        mShowOverviewPanelButtonsAnimator.setInterpolator(null);

        mShowScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
                mWorkspace.getStateTransitionAnimation().mWorkspaceScrimAlpha);
        mShowScrimAnimator.setInterpolator(null);

        mHidePageIndicatorAnimator = new LauncherViewPropertyAnimator(
                mWorkspace.getPageIndicator()).alpha(0f).withLayer();
        mHidePageIndicatorAnimator.setInterpolator(null);
        mHidePageIndicatorAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                if (mWorkspace.getPageIndicator() != null) {
                    mWorkspace.getPageIndicator().setVisibility(View.INVISIBLE);
                }
            }
        });

        mHideHotseatAnimator = new LauncherViewPropertyAnimator(mLauncher.getHotseat())
                .alpha(0f).withLayer();
        mHideHotseatAnimator.setInterpolator(null);
        mHideHotseatAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                mLauncher.getHotseat().setVisibility(View.INVISIBLE);
            }
        });

        mHideOverviewPanelButtonsAnimator = new LauncherViewPropertyAnimator(
                mLauncher.getOverviewPanel()).alpha(0f).withLayer();
        mHideOverviewPanelButtonsAnimator.setInterpolator(null);
        mHideOverviewPanelButtonsAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                mLauncher.getOverviewPanel().setVisibility(View.INVISIBLE);
            }
        });

        mHideScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha", 0f);
        mHideScrimAnimator.setInterpolator(null);
    }

    public int getNormalOverviewTransitionDuration() {
        return mNormalOverviewTransitionDuration;
    }

    /**
     * Interpolate from {@param currentProgress} to {@param toProgress}, calling
     * {@link #setAnimationProgress(float)} throughout the duration. If duration is -1,
     * the default overview transition duration is used.
     */
    public void animateToProgress(float currentProgress, float toProgress, int duration,
            final PinchThresholdManager thresholdManager) {
        if (duration == -1) {
            duration = mNormalOverviewTransitionDuration;
        }
        ValueAnimator animator = ValueAnimator.ofFloat(currentProgress, toProgress);
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
               @Override
               public void onAnimationUpdate(ValueAnimator animation) {
                   float pinchProgress = (Float) animation.getAnimatedValue();
                   setAnimationProgress(pinchProgress);
                   thresholdManager.updateAndAnimatePassedThreshold(pinchProgress,
                           PinchAnimationManager.this);
               }
           }
        );
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                mIsAnimating = false;
                thresholdManager.reset();
            }
        });
        animator.setDuration(duration).start();
        mIsAnimating = true;
    }

    public boolean isAnimating() {
        return mIsAnimating;
    }

    /**
     * Animates to the specified progress. This should be called repeatedly throughout the pinch
     * gesture to run animations that interpolate throughout the gesture.
     * @param interpolatedProgress The progress from 0 to 1, where 0 is overview and 1 is workspace.
     */
    public void setAnimationProgress(float interpolatedProgress) {
        float interpolatedScale = interpolatedProgress * (1f - mOverviewScale) + mOverviewScale;
        float interpolatedTranslationY = (1f - interpolatedProgress) * mOverviewTranslationY;
        mWorkspace.setScaleX(interpolatedScale);
        mWorkspace.setScaleY(interpolatedScale);
        mWorkspace.setTranslationY(interpolatedTranslationY);
        setOverviewPanelsAlpha(1f - interpolatedProgress, 0);

        // Make sure adjacent pages, except custom content page, are visible while scaling.
        mWorkspace.setCustomContentVisibility(View.INVISIBLE);
        mWorkspace.invalidate();
    }

    /**
     * Animates certain properties based on which threshold was passed, and in what direction. The
     * starting state must also be taken into account because the thresholds mean different things
     * when going from workspace to overview and vice versa.
     * @param threshold One of {@link PinchThresholdManager#THRESHOLD_ONE},
     *                  {@link PinchThresholdManager#THRESHOLD_TWO}, or
     *                  {@link PinchThresholdManager#THRESHOLD_THREE}
     * @param startState {@link Workspace.State#NORMAL} or {@link Workspace.State#OVERVIEW}.
     * @param goingTowards {@link Workspace.State#NORMAL} or {@link Workspace.State#OVERVIEW}.
 *                     Note that this doesn't have to be the opposite of startState;
     */
    public void animateThreshold(float threshold, Workspace.State startState,
            Workspace.State goingTowards) {
        if (threshold == PinchThresholdManager.THRESHOLD_ONE) {
            if (startState == OVERVIEW) {
                animateOverviewPanelButtons(goingTowards == OVERVIEW);
            } else if (startState == NORMAL) {
                animateHotseatAndPageIndicator(goingTowards == NORMAL);
                animateQsb(goingTowards == NORMAL);
            }
        } else if (threshold == PinchThresholdManager.THRESHOLD_TWO) {
            if (startState == OVERVIEW) {
                animateHotseatAndPageIndicator(goingTowards == NORMAL);
                animateQsb(goingTowards == NORMAL);
                animateScrim(goingTowards == OVERVIEW);
            } else if (startState == NORMAL) {
                animateOverviewPanelButtons(goingTowards == OVERVIEW);
                animateScrim(goingTowards == OVERVIEW);
            }
        } else if (threshold == PinchThresholdManager.THRESHOLD_THREE) {
            // Passing threshold 3 ends the pinch and snaps to the new state.
            if (startState == OVERVIEW && goingTowards == NORMAL) {
                mLauncher.showWorkspace(true);
                mWorkspace.snapToPage(mWorkspace.getPageNearestToCenterOfScreen());
            } else if (startState == NORMAL && goingTowards == OVERVIEW) {
                mLauncher.showOverviewMode(true);
            }
        } else {
            Log.e(TAG, "Received unknown threshold to animate: " + threshold);
        }
    }

    private void setOverviewPanelsAlpha(float alpha, int duration) {
        mWorkspace.getVisiblePages(mVisiblePageRange);
        for (int i = mVisiblePageRange[0]; i <= mVisiblePageRange[1]; i++) {
            View page = mWorkspace.getPageAt(i);
            if (!mWorkspace.shouldDrawChild(page)) {
                continue;
            }
            if (duration == 0) {
                ((CellLayout) page).setBackgroundAlpha(alpha);
            } else {
                ObjectAnimator.ofFloat(page, "backgroundAlpha", alpha)
                        .setDuration(duration).start();
            }
        }
    }

    private void animateHotseatAndPageIndicator(boolean show) {
        if (show) {
            mLauncher.getHotseat().setVisibility(View.VISIBLE);
            mShowHotseatAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
            if (mWorkspace.getPageIndicator() != null) {
                // There aren't page indicators in landscape mode on phones, hence the null check.
                mWorkspace.getPageIndicator().setVisibility(View.VISIBLE);
                mShowPageIndicatorAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
            }
        } else {
            mHideHotseatAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
            if (mWorkspace.getPageIndicator() != null) {
                // There aren't page indicators in landscape mode on phones, hence the null check.
                mHidePageIndicatorAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
            }
        }
    }

    private void animateQsb(boolean show) {
        SearchDropTargetBar.State searchBarState = show ? SearchDropTargetBar.State.SEARCH_BAR
                : SearchDropTargetBar.State.INVISIBLE;
        mLauncher.getSearchDropTargetBar().animateToState(searchBarState, THRESHOLD_ANIM_DURATION);
    }

    private void animateOverviewPanelButtons(boolean show) {
        if (show) {
            mLauncher.getOverviewPanel().setVisibility(View.VISIBLE);
            mShowOverviewPanelButtonsAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
        } else {
            mHideOverviewPanelButtonsAnimator.setDuration(THRESHOLD_ANIM_DURATION).start();
        }
    }

    private void animateScrim(boolean show) {
        // We reninitialize the animators here so that they have the correct start values.
        if (show) {
            mShowScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
                    mWorkspace.getStateTransitionAnimation().mWorkspaceScrimAlpha);
            mShowScrimAnimator.setInterpolator(null);
            mShowScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
        } else {
            mHideScrimAnimator.setupStartValues();
            mHideScrimAnimator = ObjectAnimator.ofFloat(mLauncher.getDragLayer(), "backgroundAlpha",
                    0f);
            mHideScrimAnimator.setInterpolator(null);
            mHideScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
            mHideScrimAnimator.setDuration(mNormalOverviewTransitionDuration).start();
        }
    }
}