/*
 * Copyright (C) 2016 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.incallui.answer.impl.answermethod;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.annotation.SuppressLint;
import android.content.Context;
import android.support.annotation.FloatRange;
import android.support.annotation.IntDef;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.ViewConfiguration;
import com.android.dialer.common.DpUtil;
import com.android.dialer.common.LogUtil;
import com.android.dialer.common.MathUtil;
import com.android.incallui.answer.impl.classifier.FalsingManager;
import com.android.incallui.answer.impl.utils.FlingAnimationUtils;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

/** Touch handler that keeps track of flings for {@link FlingUpDownMethod}. */
@SuppressLint("ClickableViewAccessibility")
class FlingUpDownTouchHandler implements OnTouchListener {

  /** Callback interface for significant events with this touch handler */
  interface OnProgressChangedListener {

    /**
     * Called when the visible answer progress has changed. Implementations should use this for
     * animation, but should not perform accepts or rejects until {@link #onMoveFinish(boolean)} is
     * called.
     *
     * @param progress float representation of the progress with +1f fully accepted, -1f fully
     *     rejected, and 0 neutral.
     */
    void onProgressChanged(@FloatRange(from = -1f, to = 1f) float progress);

    /** Called when a touch event has started being tracked. */
    void onTrackingStart();

    /** Called when touch events stop being tracked. */
    void onTrackingStopped();

    /**
     * Called when the progress has fully animated back to neutral. Normal resting animation should
     * resume, possibly with a hint animation first.
     *
     * @param showHint {@code true} iff the hint animation should be run before resuming normal
     *     animation.
     */
    void onMoveReset(boolean showHint);

    /**
     * Called when the progress has animated fully to accept or reject.
     *
     * @param accept {@code true} if the call has been accepted, {@code false} if it has been
     *     rejected.
     */
    void onMoveFinish(boolean accept);

    /**
     * Determine whether this gesture should use the {@link FalsingManager} to reject accidental
     * touches
     *
     * @param downEvent the MotionEvent corresponding to the start of the gesture
     * @return {@code true} if the {@link FalsingManager} should be used to reject accidental
     *     touches for this gesture
     */
    boolean shouldUseFalsing(@NonNull MotionEvent downEvent);
  }

  // Progress that must be moved through to not show the hint animation after gesture completes
  private static final float HINT_MOVE_THRESHOLD_RATIO = .1f;
  // Dp touch needs to move upward to be considered fully accepted
  private static final int ACCEPT_THRESHOLD_DP = 150;
  // Dp touch needs to move downward to be considered fully rejected
  private static final int REJECT_THRESHOLD_DP = 150;
  // Dp touch needs to move for it to not be considered a false touch (if FalsingManager is not
  // enabled)
  private static final int FALSING_THRESHOLD_DP = 40;

  // Progress at which a fling in the opposite direction will recenter instead of
  // accepting/rejecting
  private static final float PROGRESS_FLING_RECENTER = .1f;

  // Progress at which a slow swipe would continue toward accept/reject after the
  // touch has been let go, otherwise will recenter
  private static final float PROGRESS_SWIPE_RECENTER = .8f;

  private static final float REJECT_FLING_THRESHOLD_MODIFIER = 2f;

  @Retention(RetentionPolicy.SOURCE)
  @IntDef({FlingTarget.CENTER, FlingTarget.ACCEPT, FlingTarget.REJECT})
  private @interface FlingTarget {
    int CENTER = 0;
    int ACCEPT = 1;
    int REJECT = -1;
  }

  /**
   * Create a new FlingUpDownTouchHandler and attach it to the target. Will call {@link
   * View#setOnTouchListener(OnTouchListener)} before returning.
   *
   * @param target View whose touches are to be listened to
   * @param listener Callback to listen to major events
   * @param falsingManager FalsingManager to identify false touches
   * @return the instance of FlingUpDownTouchHandler that has been added as a touch listener
   */
  public static FlingUpDownTouchHandler attach(
      @NonNull View target,
      @NonNull OnProgressChangedListener listener,
      @Nullable FalsingManager falsingManager) {
    FlingUpDownTouchHandler handler = new FlingUpDownTouchHandler(target, listener, falsingManager);
    target.setOnTouchListener(handler);
    return handler;
  }

  @NonNull private final View target;
  @NonNull private final OnProgressChangedListener listener;

  private VelocityTracker velocityTracker;
  private FlingAnimationUtils flingAnimationUtils;

  private boolean touchEnabled = true;
  private boolean flingEnabled = true;
  private float currentProgress;
  private boolean tracking;

  private boolean motionAborted;
  private boolean touchSlopExceeded;
  private boolean hintDistanceExceeded;
  private int trackingPointer;
  private Animator progressAnimator;

  private float touchSlop;
  private float initialTouchY;
  private float acceptThresholdY;
  private float rejectThresholdY;
  private float zeroY;

  private boolean touchAboveFalsingThreshold;
  private float falsingThresholdPx;
  private boolean touchUsesFalsing;

  private final float acceptThresholdPx;
  private final float rejectThresholdPx;
  private final float deadZoneTopPx;

  @Nullable private final FalsingManager falsingManager;

  private FlingUpDownTouchHandler(
      @NonNull View target,
      @NonNull OnProgressChangedListener listener,
      @Nullable FalsingManager falsingManager) {
    this.target = target;
    this.listener = listener;
    Context context = target.getContext();
    touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    flingAnimationUtils = new FlingAnimationUtils(context, .6f);
    falsingThresholdPx = DpUtil.dpToPx(context, FALSING_THRESHOLD_DP);
    acceptThresholdPx = DpUtil.dpToPx(context, ACCEPT_THRESHOLD_DP);
    rejectThresholdPx = DpUtil.dpToPx(context, REJECT_THRESHOLD_DP);

    deadZoneTopPx =
        Math.max(
            context.getResources().getDimension(R.dimen.answer_swipe_dead_zone_top),
            acceptThresholdPx);
    this.falsingManager = falsingManager;
  }

  /** Returns {@code true} iff a touch is being tracked */
  public boolean isTracking() {
    return tracking;
  }

  /**
   * Sets whether touch events will continue to be listened to
   *
   * @param touchEnabled whether future touch events will be listened to
   */
  public void setTouchEnabled(boolean touchEnabled) {
    this.touchEnabled = touchEnabled;
  }

  /**
   * Sets whether fling velocity is used to affect accept/reject behavior
   *
   * @param flingEnabled whether fling velocity will be used when determining whether to
   *     accept/reject or recenter
   */
  public void setFlingEnabled(boolean flingEnabled) {
    this.flingEnabled = flingEnabled;
  }

  public void detach() {
    cancelProgressAnimator();
    setTouchEnabled(false);
  }

  @Override
  public boolean onTouch(View v, MotionEvent event) {
    if (falsingManager != null) {
      falsingManager.onTouchEvent(event);
    }
    if (!touchEnabled) {
      return false;
    }
    if (motionAborted && (event.getActionMasked() != MotionEvent.ACTION_DOWN)) {
      return false;
    }

    int pointerIndex = event.findPointerIndex(trackingPointer);
    if (pointerIndex < 0) {
      pointerIndex = 0;
      trackingPointer = event.getPointerId(pointerIndex);
    }
    final float pointerY = event.getY(pointerIndex);

    switch (event.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        if (pointerY < deadZoneTopPx) {
          return false;
        }
        motionAborted = false;
        startMotion(pointerY, false, currentProgress);
        touchAboveFalsingThreshold = false;
        touchUsesFalsing = listener.shouldUseFalsing(event);
        if (velocityTracker == null) {
          initVelocityTracker();
        }
        trackMovement(event);
        cancelProgressAnimator();
        touchSlopExceeded = progressAnimator != null;
        onTrackingStarted();
        break;
      case MotionEvent.ACTION_POINTER_UP:
        final int upPointer = event.getPointerId(event.getActionIndex());
        if (trackingPointer == upPointer) {
          // gesture is ongoing, find a new pointer to track
          int newIndex = event.getPointerId(0) != upPointer ? 0 : 1;
          float newY = event.getY(newIndex);
          trackingPointer = event.getPointerId(newIndex);
          startMotion(newY, true, currentProgress);
        }
        break;
      case MotionEvent.ACTION_POINTER_DOWN:
        motionAborted = true;
        endMotionEvent(event, pointerY, true);
        return false;
      case MotionEvent.ACTION_MOVE:
        float deltaY = pointerY - initialTouchY;

        if (Math.abs(deltaY) > touchSlop) {
          touchSlopExceeded = true;
        }
        if (Math.abs(deltaY) >= falsingThresholdPx) {
          touchAboveFalsingThreshold = true;
        }
        setCurrentProgress(pointerYToProgress(pointerY));
        trackMovement(event);
        break;

      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_CANCEL:
        trackMovement(event);
        endMotionEvent(event, pointerY, false);
    }
    return true;
  }

  private void endMotionEvent(MotionEvent event, float pointerY, boolean forceCancel) {
    trackingPointer = -1;
    if ((tracking && touchSlopExceeded)
        || Math.abs(pointerY - initialTouchY) > touchSlop
        || event.getActionMasked() == MotionEvent.ACTION_CANCEL
        || forceCancel) {
      float vel = 0f;
      float vectorVel = 0f;
      if (velocityTracker != null) {
        velocityTracker.computeCurrentVelocity(1000);
        vel = velocityTracker.getYVelocity();
        vectorVel =
            Math.copySign(
                (float) Math.hypot(velocityTracker.getXVelocity(), velocityTracker.getYVelocity()),
                vel);
      }

      boolean falseTouch = isFalseTouch();
      boolean forceRecenter =
          falseTouch
              || !touchSlopExceeded
              || forceCancel
              || event.getActionMasked() == MotionEvent.ACTION_CANCEL;

      @FlingTarget
      int target = forceRecenter ? FlingTarget.CENTER : getFlingTarget(pointerY, vectorVel);

      fling(vel, target, falseTouch);
      onTrackingStopped();
    } else {
      onTrackingStopped();
      setCurrentProgress(0);
      onMoveEnded();
    }

    if (velocityTracker != null) {
      velocityTracker.recycle();
      velocityTracker = null;
    }
  }

  @FlingTarget
  private int getFlingTarget(float pointerY, float vectorVel) {
    float progress = pointerYToProgress(pointerY);

    float minVelocityPxPerSecond = flingAnimationUtils.getMinVelocityPxPerSecond();
    if (vectorVel > 0) {
      minVelocityPxPerSecond *= REJECT_FLING_THRESHOLD_MODIFIER;
    }
    if (!flingEnabled || Math.abs(vectorVel) < minVelocityPxPerSecond) {
      // Not a fling
      if (Math.abs(progress) > PROGRESS_SWIPE_RECENTER) {
        // Progress near one of the edges
        return progress > 0 ? FlingTarget.ACCEPT : FlingTarget.REJECT;
      } else {
        return FlingTarget.CENTER;
      }
    }

    boolean sameDirection = vectorVel < 0 == progress > 0;
    if (!sameDirection && Math.abs(progress) >= PROGRESS_FLING_RECENTER) {
      // Being flung back toward center
      return FlingTarget.CENTER;
    }
    // Flung toward an edge
    return vectorVel < 0 ? FlingTarget.ACCEPT : FlingTarget.REJECT;
  }

  @FloatRange(from = -1f, to = 1f)
  private float pointerYToProgress(float pointerY) {
    boolean pointerAboveZero = pointerY > zeroY;
    float nearestThreshold = pointerAboveZero ? rejectThresholdY : acceptThresholdY;

    float absoluteProgress = (pointerY - zeroY) / (nearestThreshold - zeroY);
    return MathUtil.clamp(absoluteProgress * (pointerAboveZero ? -1 : 1), -1f, 1f);
  }

  private boolean isFalseTouch() {
    if (falsingManager != null && falsingManager.isEnabled()) {
      if (falsingManager.isFalseTouch()) {
        if (touchUsesFalsing) {
          LogUtil.i("FlingUpDownTouchHandler.isFalseTouch", "rejecting false touch");
          return true;
        } else {
          LogUtil.i(
              "FlingUpDownTouchHandler.isFalseTouch",
              "Suspected false touch, but not using false touch rejection for this gesture");
          return false;
        }
      } else {
        return false;
      }
    }
    return !touchAboveFalsingThreshold;
  }

  private void trackMovement(MotionEvent event) {
    if (velocityTracker != null) {
      velocityTracker.addMovement(event);
    }
  }

  private void fling(float velocity, @FlingTarget int target, boolean centerBecauseOfFalsing) {
    ValueAnimator animator = createProgressAnimator(target);
    if (target == FlingTarget.CENTER) {
      flingAnimationUtils.apply(animator, currentProgress, target, velocity);
    } else {
      flingAnimationUtils.applyDismissing(animator, currentProgress, target, velocity, 1);
    }
    if (target == FlingTarget.CENTER && centerBecauseOfFalsing) {
      velocity = 0;
    }
    if (velocity == 0) {
      animator.setDuration(350);
    }

    animator.addListener(
        new AnimatorListenerAdapter() {
          boolean canceled;

          @Override
          public void onAnimationCancel(Animator animation) {
            canceled = true;
          }

          @Override
          public void onAnimationEnd(Animator animation) {
            progressAnimator = null;
            if (!canceled) {
              onMoveEnded();
            }
          }
        });
    progressAnimator = animator;
    animator.start();
  }

  private void onMoveEnded() {
    if (currentProgress == 0) {
      listener.onMoveReset(!hintDistanceExceeded);
    } else {
      listener.onMoveFinish(currentProgress > 0);
    }
  }

  private ValueAnimator createProgressAnimator(float targetProgress) {
    ValueAnimator animator = ValueAnimator.ofFloat(currentProgress, targetProgress);
    animator.addUpdateListener(
        new AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            setCurrentProgress((Float) animation.getAnimatedValue());
          }
        });
    return animator;
  }

  private void initVelocityTracker() {
    if (velocityTracker != null) {
      velocityTracker.recycle();
    }
    velocityTracker = VelocityTracker.obtain();
  }

  private void startMotion(float newY, boolean startTracking, float startProgress) {
    initialTouchY = newY;
    hintDistanceExceeded = false;

    if (startProgress <= .25) {
      acceptThresholdY = Math.max(0, initialTouchY - acceptThresholdPx);
      rejectThresholdY = Math.min(target.getHeight(), initialTouchY + rejectThresholdPx);
      zeroY = initialTouchY;
    }

    if (startTracking) {
      touchSlopExceeded = true;
      onTrackingStarted();
      setCurrentProgress(startProgress);
    }
  }

  private void onTrackingStarted() {
    tracking = true;
    listener.onTrackingStart();
  }

  private void onTrackingStopped() {
    tracking = false;
    listener.onTrackingStopped();
  }

  private void cancelProgressAnimator() {
    if (progressAnimator != null) {
      progressAnimator.cancel();
    }
  }

  private void setCurrentProgress(float progress) {
    if (Math.abs(progress) > HINT_MOVE_THRESHOLD_RATIO) {
      hintDistanceExceeded = true;
    }
    currentProgress = progress;
    listener.onProgressChanged(progress);
  }
}