/*

   2 finger gesture detector

   Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz

   This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.

   If a copy of the MPL was not distributed with this file, You can obtain one at

   http://mozilla.org/MPL/2.0/.

*/

package com.freerdp.freerdpcore.utils;

import android.content.Context;

import android.os.Handler;

import android.view.MotionEvent;

import android.view.ScaleGestureDetector;

import com.freerdp.freerdpcore.utils.GestureDetector.OnGestureListener;

public class DoubleGestureDetector

{

	// timeout during that the second finger has to touch the screen before the double finger

	// detection is cancelled

	private static final long DOUBLE_TOUCH_TIMEOUT = 100;

	// timeout during that an UP event will trigger a single double touch event

	private static final long SINGLE_DOUBLE_TOUCH_TIMEOUT = 1000;

	// constants for Message.what used by GestureHandler below

	private static final int TAP = 1;

	// different detection modes

	private static final int MODE_UNKNOWN = 0;

	private static final int MODE_PINCH_ZOOM = 1;

	private static final int MODE_SCROLL = 2;

	private static final int SCROLL_SCORE_TO_REACH = 20;

	private final OnDoubleGestureListener mListener;

	private int mPointerDistanceSquare;

	private int mCurrentMode;

	private int mScrollDetectionScore;

	private ScaleGestureDetector scaleGestureDetector;

	private boolean mCancelDetection;

	private boolean mDoubleInProgress;

	private GestureHandler mHandler;

	private MotionEvent mCurrentDownEvent;

	private MotionEvent mCurrentDoubleDownEvent;

	private MotionEvent mPreviousUpEvent;

	private MotionEvent mPreviousPointerUpEvent;

	/**

	 * 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 DoubleGestureDetector(Context context, Handler handler, OnDoubleGestureListener listener)

	{

		mListener = listener;

		init(context, handler);

	}

	private void init(Context context, Handler handler)

	{

		if (mListener == null)

		{

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

		}

		if (handler != null)

			mHandler = new GestureHandler(handler);

		else

			mHandler = new GestureHandler();

		// we use 1cm distance to decide between scroll and pinch zoom

		//  - first convert cm to inches

		//  - then multiply inches by dots per inch

		float distInches = 0.5f / 2.54f;

		float distPixelsX = distInches * context.getResources().getDisplayMetrics().xdpi;

		float distPixelsY = distInches * context.getResources().getDisplayMetrics().ydpi;

		mPointerDistanceSquare = (int)(distPixelsX * distPixelsX + distPixelsY * distPixelsY);

	}

	/**

	 * Set scale gesture detector

	 *

	 * @param scaleGestureDetector

	 */

	public void setScaleGestureDetector(ScaleGestureDetector scaleGestureDetector)

	{

		this.scaleGestureDetector = scaleGestureDetector;

	}

	/**

	 * 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)

	{

		boolean handled = false;

		final int action = ev.getAction();

		// dumpEvent(ev);

		switch (action & MotionEvent.ACTION_MASK)

		{

			case MotionEvent.ACTION_DOWN:

				if (mCurrentDownEvent != null)

					mCurrentDownEvent.recycle();

				mCurrentMode = MODE_UNKNOWN;

				mCurrentDownEvent = MotionEvent.obtain(ev);

				mCancelDetection = false;

				mDoubleInProgress = false;

				mScrollDetectionScore = 0;

				handled = true;

				break;

			case MotionEvent.ACTION_POINTER_UP:

				if (mPreviousPointerUpEvent != null)

					mPreviousPointerUpEvent.recycle();

				mPreviousPointerUpEvent = MotionEvent.obtain(ev);

				break;

			case MotionEvent.ACTION_POINTER_DOWN:

				// more than 2 fingers down? cancel

				// 2nd finger touched too late? cancel

				if (ev.getPointerCount() > 2 ||

				    (ev.getEventTime() - mCurrentDownEvent.getEventTime()) > DOUBLE_TOUCH_TIMEOUT)

				{

					cancel();

					break;

				}

				// detection cancelled?

				if (mCancelDetection)

					break;

				// double touch gesture in progress

				mDoubleInProgress = true;

				if (mCurrentDoubleDownEvent != null)

					mCurrentDoubleDownEvent.recycle();

				mCurrentDoubleDownEvent = MotionEvent.obtain(ev);

				// set detection mode to unkown and send a TOUCH timeout event to detect single taps

				mCurrentMode = MODE_UNKNOWN;

				mHandler.sendEmptyMessageDelayed(TAP, SINGLE_DOUBLE_TOUCH_TIMEOUT);

				handled |= mListener.onDoubleTouchDown(ev);

				break;

			case MotionEvent.ACTION_MOVE:

				// detection cancelled or not active?

				if (mCancelDetection || !mDoubleInProgress || ev.getPointerCount() != 2)

					break;

				// determine mode

				if (mCurrentMode == MODE_UNKNOWN)

				{

					// did the pointer distance change?

					if (pointerDistanceChanged(mCurrentDoubleDownEvent, ev))

					{

						handled |= scaleGestureDetector.onTouchEvent(mCurrentDownEvent);

						MotionEvent e = MotionEvent.obtain(ev);

						e.setAction(mCurrentDoubleDownEvent.getAction());

						handled |= scaleGestureDetector.onTouchEvent(e);

						mCurrentMode = MODE_PINCH_ZOOM;

						break;

					}

					else

					{

						mScrollDetectionScore++;

						if (mScrollDetectionScore >= SCROLL_SCORE_TO_REACH)

							mCurrentMode = MODE_SCROLL;

					}

				}

				switch (mCurrentMode)

				{

					case MODE_PINCH_ZOOM:

						if (scaleGestureDetector != null)

							handled |= scaleGestureDetector.onTouchEvent(ev);

						break;

					case MODE_SCROLL:

						handled = mListener.onDoubleTouchScroll(mCurrentDownEvent, ev);

						break;

					default:

						handled = true;

						break;

				}

				break;

			case MotionEvent.ACTION_UP:

				// fingers were not removed equally? cancel

				if (mPreviousPointerUpEvent != null &&

				    (ev.getEventTime() - mPreviousPointerUpEvent.getEventTime()) >

				        DOUBLE_TOUCH_TIMEOUT)

				{

					mPreviousPointerUpEvent.recycle();

					mPreviousPointerUpEvent = null;

					cancel();

					break;

				}

				// detection cancelled or not active?

				if (mCancelDetection || !mDoubleInProgress)

					break;

				boolean hasTapEvent = mHandler.hasMessages(TAP);

				MotionEvent currentUpEvent = MotionEvent.obtain(ev);

				if (mCurrentMode == MODE_UNKNOWN && hasTapEvent)

					handled = mListener.onDoubleTouchSingleTap(mCurrentDoubleDownEvent);

				else if (mCurrentMode == MODE_PINCH_ZOOM)

					handled = scaleGestureDetector.onTouchEvent(ev);

				if (mPreviousUpEvent != null)

					mPreviousUpEvent.recycle();

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

				mPreviousUpEvent = currentUpEvent;

				handled |= mListener.onDoubleTouchUp(ev);

				break;

			case MotionEvent.ACTION_CANCEL:

				cancel();

				break;

		}

		if ((action == MotionEvent.ACTION_MOVE) && handled == false)

			handled = true;

		return handled;

	}

	private void cancel()

	{

		mHandler.removeMessages(TAP);

		mCurrentMode = MODE_UNKNOWN;

		mCancelDetection = true;

		mDoubleInProgress = false;

	}

	// returns true of the distance between the two pointers changed

	private boolean pointerDistanceChanged(MotionEvent oldEvent, MotionEvent newEvent)

	{

		int deltaX1 = Math.abs((int)oldEvent.getX(0) - (int)oldEvent.getX(1));

		int deltaX2 = Math.abs((int)newEvent.getX(0) - (int)newEvent.getX(1));

		int distXSquare = (deltaX2 - deltaX1) * (deltaX2 - deltaX1);

		int deltaY1 = Math.abs((int)oldEvent.getY(0) - (int)oldEvent.getY(1));

		int deltaY2 = Math.abs((int)newEvent.getY(0) - (int)newEvent.getY(1));

		int distYSquare = (deltaY2 - deltaY1) * (deltaY2 - deltaY1);

		return (distXSquare + distYSquare) > mPointerDistanceSquare;

	}

	/**

	 * 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 OnDoubleGestureListener {

		/**

		 * Notified when a multi tap event starts

		 */

		boolean onDoubleTouchDown(MotionEvent e);

		/**

		 * Notified when a multi tap event ends

		 */

		boolean onDoubleTouchUp(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 onDoubleTouchSingleTap(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 onDoubleTouchScroll(MotionEvent e1, MotionEvent e2);

	}

	/*

	private void dumpEvent(MotionEvent event) {

	       String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,

	          "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };

	       StringBuilder sb = new StringBuilder();

	       int action = event.getAction();

	       int actionCode = action & MotionEvent.ACTION_MASK;

	       sb.append("event ACTION_" ).append(names[actionCode]);

	       if (actionCode == MotionEvent.ACTION_POINTER_DOWN

	             || actionCode == MotionEvent.ACTION_POINTER_UP) {

	          sb.append("(pid " ).append(

	          action >> MotionEvent.ACTION_POINTER_ID_SHIFT);

	          sb.append(")" );

	       }

	       sb.append("[" );

	       for (int i = 0; i < event.getPointerCount(); i++) {

	          sb.append("#" ).append(i);

	          sb.append("(pid " ).append(event.getPointerId(i));

	          sb.append(")=" ).append((int) event.getX(i));

	          sb.append("," ).append((int) event.getY(i));

	          if (i + 1 < event.getPointerCount())

	             sb.append(";" );

	       }

	       sb.append("]" );

	       Log.d("DoubleDetector", sb.toString());

	    }

	*/

	private class GestureHandler extends Handler

	{

		GestureHandler()

		{

			super();

		}

		GestureHandler(Handler handler)

		{

			super(handler.getLooper());

		}

	}

}