/*
 * 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.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);
	}

	/**
	 * 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 triggered 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.
		 * <p>
		 * 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
			}
		}
	}
}
