/*

 * Copyright (C) 2008 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.

 *

 * Modified for aFreeRDP by Martin Fleisz (martin.fleisz@thincast.com)

 */

package com.freerdp.freerdpcore.utils;

import android.content.Context;

import android.os.Build;

import android.os.Handler;

import android.os.Message;

import android.util.DisplayMetrics;

import android.view.MotionEvent;

import android.view.ViewConfiguration;

public class GestureDetector

{

	private static final int TAP_TIMEOUT = 100;

	private static final int DOUBLE_TAP_TIMEOUT = 200;

	// Distance a touch can wander before we think the user is the first touch in a sequence of

	// double tap

	private static final int LARGE_TOUCH_SLOP = 18;

	// Distance between the first touch and second touch to still be considered a double tap

	private static final int DOUBLE_TAP_SLOP = 100;

	// constants for Message.what used by GestureHandler below

	private static final int SHOW_PRESS = 1;

	private static final int LONG_PRESS = 2;

	private static final int TAP = 3;

	private final Handler mHandler;

	private final OnGestureListener mListener;

	private int mTouchSlopSquare;

	private int mLargeTouchSlopSquare;

	private int mDoubleTapSlopSquare;

	private int mLongpressTimeout = 100;

	private OnDoubleTapListener mDoubleTapListener;

	private boolean mStillDown;

	private boolean mInLongPress;

	private boolean mAlwaysInTapRegion;

	private boolean mAlwaysInBiggerTapRegion;

	private MotionEvent mCurrentDownEvent;

	private MotionEvent mPreviousUpEvent;

	/**

	 * True when the user is still touching for the second tap (down, move, and

	 * up events). Can only be true if there is a double tap listener attached.

	 */

	private boolean mIsDoubleTapping;

	private float mLastMotionY;

	private float mLastMotionX;

	private boolean mIsLongpressEnabled;

	/**

	 * True if we are at a target API level of >= Froyo or the developer can

	 * explicitly set it. If true, input events with > 1 pointer will be ignored

	 * so we can work side by side with multitouch gesture detectors.

	 */

	private boolean mIgnoreMultitouch;

	/**

	 * Creates a GestureDetector with the supplied listener.

	 * You may only use this constructor from a UI thread (this is the usual situation).

	 *

	 * @param context  the application's context

	 * @param listener the listener invoked for all the callbacks, this must

	 *                 not be null.

	 * @throws NullPointerException if {@code listener} is null.

	 * @see android.os.Handler#Handler()

	 */

	public GestureDetector(Context context, OnGestureListener listener)

	{

		this(context, listener, null);

	}

	/**

	 * Creates a GestureDetector with the supplied listener.

	 * You may only use this constructor from a UI thread (this is the usual situation).

	 *

	 * @param context  the application's context

	 * @param listener the listener invoked for all the callbacks, this must

	 *                 not be null.

	 * @param handler  the handler to use

	 * @throws NullPointerException if {@code listener} is null.

	 * @see android.os.Handler#Handler()

	 */

	public GestureDetector(Context context, OnGestureListener listener, Handler handler)

	{

		this(context, listener, handler,

		     context != null &&

		         context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.FROYO);

	}

	/**

	 * Creates a GestureDetector with the supplied listener.

	 * You may only use this constructor from a UI thread (this is the usual situation).

	 *

	 * @param context          the application's context

	 * @param listener         the listener invoked for all the callbacks, this must

	 *                         not be null.

	 * @param handler          the handler to use

	 * @param ignoreMultitouch whether events involving more than one pointer should

	 *                         be ignored.

	 * @throws NullPointerException if {@code listener} is null.

	 * @see android.os.Handler#Handler()

	 */

	public GestureDetector(Context context, OnGestureListener listener, Handler handler,

	                       boolean ignoreMultitouch)

	{

		if (handler != null)

		{

			mHandler = new GestureHandler(handler);

		}

		else

		{

			mHandler = new GestureHandler();

		}

		mListener = listener;

		if (listener instanceof OnDoubleTapListener)

		{

			setOnDoubleTapListener((OnDoubleTapListener)listener);

		}

		init(context, ignoreMultitouch);

	}

	private void init(Context context, boolean ignoreMultitouch)

	{

		if (mListener == null)

		{

			throw new NullPointerException("OnGestureListener must not be null");

		}

		mIsLongpressEnabled = true;

		mIgnoreMultitouch = ignoreMultitouch;

		// Fallback to support pre-donuts releases

		int touchSlop, largeTouchSlop, doubleTapSlop;

		if (context == null)

		{

			// noinspection deprecation

			touchSlop = ViewConfiguration.getTouchSlop();

			largeTouchSlop = touchSlop + 2;

			doubleTapSlop = DOUBLE_TAP_SLOP;

		}

		else

		{

			final DisplayMetrics metrics = context.getResources().getDisplayMetrics();

			final float density = metrics.density;

			final ViewConfiguration configuration = ViewConfiguration.get(context);

			touchSlop = configuration.getScaledTouchSlop();

			largeTouchSlop = (int)(density * LARGE_TOUCH_SLOP + 0.5f);

			doubleTapSlop = configuration.getScaledDoubleTapSlop();

		}

		mTouchSlopSquare = touchSlop * touchSlop;

		mLargeTouchSlopSquare = largeTouchSlop * largeTouchSlop;

		mDoubleTapSlopSquare = doubleTapSlop * doubleTapSlop;

	}

	/**

	 * Sets the listener which will be called for double-tap and related

	 * gestures.

	 *

	 * @param onDoubleTapListener the listener invoked for all the callbacks, or

	 *                            null to stop listening for double-tap gestures.

	 */

	public void setOnDoubleTapListener(OnDoubleTapListener onDoubleTapListener)

	{

		mDoubleTapListener = onDoubleTapListener;

	}

	/**

	 * Set whether longpress is enabled, if this is enabled when a user

	 * presses and holds down you get a longpress event and nothing further.

	 * If it's disabled the user can press and hold down and then later

	 * moved their finger and you will get scroll events. By default

	 * longpress is enabled.

	 *

	 * @param isLongpressEnabled whether longpress should be enabled.

	 */

	public void setIsLongpressEnabled(boolean isLongpressEnabled)

	{

		mIsLongpressEnabled = isLongpressEnabled;

	}

	/**

	 * @return true if longpress is enabled, else false.

	 */

	public boolean isLongpressEnabled()

	{

		return mIsLongpressEnabled;

	}

	public void setLongPressTimeout(int timeout)

	{

		mLongpressTimeout = timeout;

	}

	/**

	 * Analyzes the given motion event and if applicable triggers the

	 * appropriate callbacks on the {@link OnGestureListener} supplied.

	 *

	 * @param ev The current motion event.

	 * @return true if the {@link OnGestureListener} consumed the event,

	 * else false.

	 */

	public boolean onTouchEvent(MotionEvent ev)

	{

		final int action = ev.getAction();

		final float y = ev.getY();

		final float x = ev.getX();

		boolean handled = false;

		switch (action & MotionEvent.ACTION_MASK)

		{

			case MotionEvent.ACTION_POINTER_DOWN:

				if (mIgnoreMultitouch)

				{

					// Multitouch event - abort.

					cancel();

				}

				break;

			case MotionEvent.ACTION_POINTER_UP:

				// Ending a multitouch gesture and going back to 1 finger

				if (mIgnoreMultitouch && ev.getPointerCount() == 2)

				{

					int index = (((action & MotionEvent.ACTION_POINTER_INDEX_MASK) >>

					              MotionEvent.ACTION_POINTER_INDEX_SHIFT) == 0)

					                ? 1

					                : 0;

					mLastMotionX = ev.getX(index);

					mLastMotionY = ev.getY(index);

				}

				break;

			case MotionEvent.ACTION_DOWN:

				if (mDoubleTapListener != null)

				{

					boolean hadTapMessage = mHandler.hasMessages(TAP);

					if (hadTapMessage)

						mHandler.removeMessages(TAP);

					if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) &&

					    hadTapMessage &&

					    isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev))

					{

						// This is a second tap

						mIsDoubleTapping = true;

						// Give a callback with the first tap of the double-tap

						handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent);

						// Give a callback with down event of the double-tap

						handled |= mDoubleTapListener.onDoubleTapEvent(ev);

					}

					else

					{

						// This is a first tap

						mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT);

					}

				}

				mLastMotionX = x;

				mLastMotionY = y;

				if (mCurrentDownEvent != null)

				{

					mCurrentDownEvent.recycle();

				}

				mCurrentDownEvent = MotionEvent.obtain(ev);

				mAlwaysInTapRegion = true;

				mAlwaysInBiggerTapRegion = true;

				mStillDown = true;

				mInLongPress = false;

				if (mIsLongpressEnabled)

				{

					mHandler.removeMessages(LONG_PRESS);

					mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() +

					                                                TAP_TIMEOUT +

					                                                mLongpressTimeout);

				}

				mHandler.sendEmptyMessageAtTime(SHOW_PRESS,

				                                mCurrentDownEvent.getDownTime() + TAP_TIMEOUT);

				handled |= mListener.onDown(ev);

				break;

			case MotionEvent.ACTION_MOVE:

				if (mIgnoreMultitouch && ev.getPointerCount() > 1)

				{

					break;

				}

				final float scrollX = mLastMotionX - x;

				final float scrollY = mLastMotionY - y;

				if (mIsDoubleTapping)

				{

					// Give the move events of the double-tap

					handled |= mDoubleTapListener.onDoubleTapEvent(ev);

				}

				else if (mAlwaysInTapRegion)

				{

					final int deltaX = (int)(x - mCurrentDownEvent.getX());

					final int deltaY = (int)(y - mCurrentDownEvent.getY());

					int distance = (deltaX * deltaX) + (deltaY * deltaY);

					if (distance > mTouchSlopSquare)

					{

						mLastMotionX = x;

						mLastMotionY = y;

						mAlwaysInTapRegion = false;

						mHandler.removeMessages(TAP);

						mHandler.removeMessages(SHOW_PRESS);

						mHandler.removeMessages(LONG_PRESS);

					}

					if (distance > mLargeTouchSlopSquare)

					{

						mAlwaysInBiggerTapRegion = false;

					}

					handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);

				}

				else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1))

				{

					handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);

					mLastMotionX = x;

					mLastMotionY = y;

				}

				break;

			case MotionEvent.ACTION_UP:

				mStillDown = false;

				MotionEvent currentUpEvent = MotionEvent.obtain(ev);

				if (mIsDoubleTapping)

				{

					// Finally, give the up event of the double-tap

					handled |= mDoubleTapListener.onDoubleTapEvent(ev);

				}

				else if (mInLongPress)

				{

					mHandler.removeMessages(TAP);

					mListener.onLongPressUp(ev);

					mInLongPress = false;

				}

				else if (mAlwaysInTapRegion)

				{

					handled = mListener.onSingleTapUp(mCurrentDownEvent);

				}

				else

				{

					// A fling must travel the minimum tap distance

				}

				if (mPreviousUpEvent != null)

				{

					mPreviousUpEvent.recycle();

				}

				// Hold the event we obtained above - listeners may have changed the original.

				mPreviousUpEvent = currentUpEvent;

				mIsDoubleTapping = false;

				mHandler.removeMessages(SHOW_PRESS);

				mHandler.removeMessages(LONG_PRESS);

				handled |= mListener.onUp(ev);

				break;

			case MotionEvent.ACTION_CANCEL:

				cancel();

				break;

		}

		return handled;

	}

	private void cancel()

	{

		mHandler.removeMessages(SHOW_PRESS);

		mHandler.removeMessages(LONG_PRESS);

		mHandler.removeMessages(TAP);

		mAlwaysInTapRegion = false; // ensures that we won't receive an OnSingleTap notification

		                            // when a 2-Finger tap is performed

		mIsDoubleTapping = false;

		mStillDown = false;

		if (mInLongPress)

		{

			mInLongPress = false;

		}

	}

	private boolean isConsideredDoubleTap(MotionEvent firstDown, MotionEvent firstUp,

	                                      MotionEvent secondDown)

	{

		if (!mAlwaysInBiggerTapRegion)

		{

			return false;

		}

		if (secondDown.getEventTime() - firstUp.getEventTime() > DOUBLE_TAP_TIMEOUT)

		{

			return false;

		}

		int deltaX = (int)firstDown.getX() - (int)secondDown.getX();

		int deltaY = (int)firstDown.getY() - (int)secondDown.getY();

		return (deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare);

	}

	private void dispatchLongPress()

	{

		mHandler.removeMessages(TAP);

		mInLongPress = true;

		mListener.onLongPress(mCurrentDownEvent);

	}

	/**

	 * The listener that is used to notify when gestures occur.

	 * If you want to listen for all the different gestures then implement

	 * this interface. If you only want to listen for a subset it might

	 * be easier to extend {@link SimpleOnGestureListener}.

	 */

	public interface OnGestureListener {

		/**

		 * Notified when a tap occurs with the down {@link MotionEvent}

		 * that triggered it. This will be triggered immediately for

		 * every down event. All other events should be preceded by this.

		 *

		 * @param e The down motion event.

		 */

		boolean onDown(MotionEvent e);

		/**

		 * Notified when a tap finishes with the up {@link MotionEvent}

		 * that triggered it. This will be triggered immediately for

		 * every up event. All other events should be preceded by this.

		 *

		 * @param e The up motion event.

		 */

		boolean onUp(MotionEvent e);

		/**

		 * The user has performed a down {@link MotionEvent} and not performed

		 * a move or up yet. This event is commonly used to provide visual

		 * feedback to the user to let them know that their action has been

		 * recognized i.e. highlight an element.

		 *

		 * @param e The down motion event

		 */

		void onShowPress(MotionEvent e);

		/**

		 * Notified when a tap occurs with the up {@link MotionEvent}

		 * that triggered it.

		 *

		 * @param e The up motion event that completed the first tap

		 * @return true if the event is consumed, else false

		 */

		boolean onSingleTapUp(MotionEvent e);

		/**

		 * Notified when a scroll occurs with the initial on down {@link MotionEvent} and the

		 * current move {@link MotionEvent}. The distance in x and y is also supplied for

		 * convenience.

		 *

		 * @param e1        The first down motion event that started the scrolling.

		 * @param e2        The move motion event that triggered the current onScroll.

		 * @param distanceX The distance along the X axis that has been scrolled since the last

		 *                  call to onScroll. This is NOT the distance between {@code e1}

		 *                  and {@code e2}.

		 * @param distanceY The distance along the Y axis that has been scrolled since the last

		 *                  call to onScroll. This is NOT the distance between {@code e1}

		 *                  and {@code e2}.

		 * @return true if the event is consumed, else false

		 */

		boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY);

		/**

		 * Notified when a long press occurs with the initial on down {@link MotionEvent}

		 * that trigged it.

		 *

		 * @param e The initial on down motion event that started the longpress.

		 */

		void onLongPress(MotionEvent e);

		/**

		 * Notified when a long press ends with the final {@link MotionEvent}.

		 *

		 * @param e The up motion event that ended the longpress.

		 */

		void onLongPressUp(MotionEvent e);

	}

	/**

	 * The listener that is used to notify when a double-tap or a confirmed

	 * single-tap occur.

	 */

	public interface OnDoubleTapListener {

		/**

		 * Notified when a single-tap occurs.

		 * 

		 * Unlike {@link OnGestureListener#onSingleTapUp(MotionEvent)}, this

		 * will only be called after the detector is confident that the user's

		 * first tap is not followed by a second tap leading to a double-tap

		 * gesture.

		 *

		 * @param e The down motion event of the single-tap.

		 * @return true if the event is consumed, else false

		 */

		boolean onSingleTapConfirmed(MotionEvent e);

		/**

		 * Notified when a double-tap occurs.

		 *

		 * @param e The down motion event of the first tap of the double-tap.

		 * @return true if the event is consumed, else false

		 */

		boolean onDoubleTap(MotionEvent e);

		/**

		 * Notified when an event within a double-tap gesture occurs, including

		 * the down, move, and up events.

		 *

		 * @param e The motion event that occurred during the double-tap gesture.

		 * @return true if the event is consumed, else false

		 */

		boolean onDoubleTapEvent(MotionEvent e);

	}

	/**

	 * A convenience class to extend when you only want to listen for a subset

	 * of all the gestures. This implements all methods in the

	 * {@link OnGestureListener} and {@link OnDoubleTapListener} but does

	 * nothing and return {@code false} for all applicable methods.

	 */

	public static class SimpleOnGestureListener implements OnGestureListener, OnDoubleTapListener

	{

		public boolean onSingleTapUp(MotionEvent e)

		{

			return false;

		}

		public void onLongPress(MotionEvent e)

		{

		}

		public void onLongPressUp(MotionEvent e)

		{

		}

		public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)

		{

			return false;

		}

		public void onShowPress(MotionEvent e)

		{

		}

		public boolean onDown(MotionEvent e)

		{

			return false;

		}

		public boolean onUp(MotionEvent e)

		{

			return false;

		}

		public boolean onDoubleTap(MotionEvent e)

		{

			return false;

		}

		public boolean onDoubleTapEvent(MotionEvent e)

		{

			return false;

		}

		public boolean onSingleTapConfirmed(MotionEvent e)

		{

			return false;

		}

	}

	private class GestureHandler extends Handler

	{

		GestureHandler()

		{

			super();

		}

		GestureHandler(Handler handler)

		{

			super(handler.getLooper());

		}

		@Override public void handleMessage(Message msg)

		{

			switch (msg.what)

			{

				case SHOW_PRESS:

					mListener.onShowPress(mCurrentDownEvent);

					break;

				case LONG_PRESS:

					dispatchLongPress();

					break;

				case TAP:

					// If the user's finger is still down, do not count it as a tap

					if (mDoubleTapListener != null && !mStillDown)

					{

						mDoubleTapListener.onSingleTapConfirmed(mCurrentDownEvent);

					}

					break;

				default:

					throw new RuntimeException("Unknown message " + msg); // never

			}

		}

	}

}