/*

   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());

        }

    }

}