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