/*
 * Copyright 2010, 2011, 2012 mapsforge.org
 * Copyright 2012, 2013 OpenScienceMap
 *
 * This program is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */

package org.oscim.view;

import org.oscim.core.Tile;
import org.oscim.overlay.OverlayManager;

import android.content.Context;
import android.os.CountDownTimer;
import android.util.Log;
import android.view.GestureDetector;
import android.view.GestureDetector.OnDoubleTapListener;
import android.view.GestureDetector.OnGestureListener;
import android.view.MotionEvent;
import android.view.animation.DecelerateInterpolator;
import android.widget.Scroller;

/**
 * @author Hannes Janetzek
 * @TODO:
 *        - use one AnimationTimer instead of CountDownTimers
 *        - fix recognition of tilt/rotate/scale state...
 */

final class TouchHandler implements OnGestureListener, OnDoubleTapListener {
	//OnScaleGestureListener,

	private static final String TAG = TouchHandler.class.getName();

	private static final float SCALE_DURATION = 500;
	//private static final float ROTATION_DELAY = 200; // ms

	private static final int INVALID_POINTER_ID = -1;

	private final MapView mMapView;
	private final MapViewPosition mMapPosition;
	private final OverlayManager mOverlayManager;

	private final DecelerateInterpolator mInterpolator;
	//private final DecelerateInterpolator mLinearInterpolator;
	private boolean mBeginScale;
	private float mSumScale;

	private boolean mBeginRotate;
	private boolean mBeginTilt;
	private boolean mLongPress;

	private float mPrevX;
	private float mPrevY;

	private float mPrevX2;
	private float mPrevY2;

	private double mAngle;

	private int mActivePointerId;

	//private final ScaleGestureDetector mScaleGestureDetector;
	private final GestureDetector mGestureDetector;

	//private final float dpi;

	protected static final int JUMP_THRESHOLD = 100;
	protected static final double PINCH_ZOOM_THRESHOLD = 5;
	protected static final double PINCH_ROTATE_THRESHOLD = 0.02;
	protected static final float PINCH_TILT_THRESHOLD = 1f;
	protected int mPrevPointerCount = 0;
	protected double mPrevPinchWidth = -1;

	/**
	 * @param context
	 *            the Context
	 * @param mapView
	 *            the MapView
	 */
	public TouchHandler(Context context, MapView mapView) {
		mMapView = mapView;
		mMapPosition = mapView.getMapPosition();
		mOverlayManager = mapView.getOverlayManager();
		// ViewConfiguration viewConfiguration = ViewConfiguration.get(context);
		// mMapMoveDelta = viewConfiguration.getScaledTouchSlop();
		mActivePointerId = INVALID_POINTER_ID;
		//mScaleGestureDetector = new ScaleGestureDetector(context, this);
		mGestureDetector = new GestureDetector(context, this);
		mGestureDetector.setOnDoubleTapListener(this);

		mInterpolator = new DecelerateInterpolator(2f);

		mScroller = new Scroller(mMapView.getContext(), mInterpolator);
		//mLinearInterpolator = new DecelerateInterpolator(0.8f);//new android.view.animation.LinearInterpolator();

	}

	/**
	 * @param event
	 *            ...
	 * @return ...
	 */
	public boolean handleMotionEvent(MotionEvent event) {

		if (mOverlayManager.onTouchEvent(event, mMapView))
			return true;

		mGestureDetector.onTouchEvent(event);
		//boolean scaling = false; //mScaleGestureDetector.onTouchEvent(event);

		int action = getAction(event);

		if (action == MotionEvent.ACTION_DOWN) {
			mMulti = 0;
			mWasMulti = false;
			if (mOverlayManager.onDown(event, mMapView))
				return true;

			return onActionDown(event);
		} else if (action == MotionEvent.ACTION_MOVE) {
			return onActionMove(event);
		} else if (action == MotionEvent.ACTION_UP) {
			return onActionUp(event);
		} else if (action == MotionEvent.ACTION_CANCEL) {
			return onActionCancel();
		} else if (action == MotionEvent.ACTION_POINTER_DOWN) {
			return onActionPointerDown(event);
		} else if (action == MotionEvent.ACTION_POINTER_UP) {
			return onActionPointerUp(event);
		}

		return false;
	}

	private static int getAction(MotionEvent motionEvent) {
		return motionEvent.getAction() & MotionEvent.ACTION_MASK;
	}

	private boolean onActionCancel() {
		mActivePointerId = INVALID_POINTER_ID;
		mLongPress = true;
		return true;
	}

	private boolean onActionDown(MotionEvent event) {
		mPrevX = event.getX();
		mPrevY = event.getY();

		mBeginRotate = false;
		mBeginTilt = false;
		mBeginScale = false;

		// save the ID of the pointer
		mActivePointerId = event.getPointerId(0);

		return true;
	}

	//private boolean mScaling = false;

	private boolean onActionMove(MotionEvent event) {
		int id = event.findPointerIndex(mActivePointerId);

		float x1 = event.getX(id);
		float y1 = event.getY(id);

		float mx = x1 - mPrevX;
		float my = y1 - mPrevY;

		float width = mMapView.getWidth();
		float height = mMapView.getHeight();

		// double-tap + hold
		if (mLongPress) {
			mMapPosition.scaleMap(1 - my / (height / 5), 0, 0);
			mMapView.redrawMap(true);

			mPrevX = x1;
			mPrevY = y1;
			return true;
		}

		// return if detect a new gesture, as indicated by a large jump
		if (Math.abs(mx) > JUMP_THRESHOLD || Math.abs(my) > JUMP_THRESHOLD)
			return true;

		if (mMulti == 0) {
			// reset pinch variables
			mPrevPinchWidth = -1;
			return true;
		}

		float x2 = event.getX(1);
		float y2 = event.getY(1);

		float dx = (x1 - x2);
		float dy = (y1 - y2);
		float slope = 0;

		if (dx != 0)
			slope = dy / dx;

		double pinchWidth = Math.sqrt(dx * dx + dy * dy);

		final double deltaPinchWidth = pinchWidth - mPrevPinchWidth;

		double rad = Math.atan2(dy, dx);
		double r = rad - mAngle;

		boolean startScale = (mPrevPinchWidth > 0 && Math.abs(deltaPinchWidth) > PINCH_ZOOM_THRESHOLD);

		boolean changed = false;

		if (!mBeginTilt && (mBeginScale || startScale)) {
			mBeginScale = true;

			float scale = (float) (pinchWidth / mPrevPinchWidth);

			mSumScale *= scale;

			if (mSumScale < 0.95 || mSumScale > 1.05)
				mBeginRotate = false;

			// decrease change of scale by the change of rotation
			// pi * 10 is just arbitrary
			scale = 1 + ((scale - 1) * Math.max((1 - (float)(Math.abs(r) * Math.PI) * 10), 0));

			float fx = (x2 + x1) / 2 - width / 2;
			float fy = (y2 + y1) / 2 - height / 2;

			//Log.d(TAG, "zoom " + deltaPinchWidth + " " + scale + " " + mSumScale);
			changed = mMapPosition.scaleMap(scale, fx, fy);
		}

		if (!mBeginScale && !mBeginRotate && Math.abs(slope) < 2) {
			float my2 = y2 - mPrevY2;
			float threshold = PINCH_TILT_THRESHOLD;

			//Log.d(TAG, r + " " + slope + " m1:" + my + " m2:" + my2);

			if ((my > threshold && my2 > threshold)
					|| (my < -threshold && my2 < -threshold))
			{
				mBeginTilt = true;
				changed = mMapPosition.tilt(my / 5);
			}
		}

		if (!mBeginTilt
				&& (mBeginRotate || (Math.abs(slope) > 1 && Math.abs(r) > PINCH_ROTATE_THRESHOLD))) {
			//Log.d(TAG, "rotate: " + mBeginRotate + " " + Math.toDegrees(rad));
			if (!mBeginRotate) {
				mAngle = rad;
				mSumScale = 1;
				mBeginRotate = true;

				mFocusX = (width / 2) - (x1 + x2) / 2;
				mFocusY = (height / 2) - (y1 + y2) / 2;
			} else {
				double da = rad - mAngle;

				if (Math.abs(da) > 0.01) {
					double rsin = Math.sin(r);
					double rcos = Math.cos(r);
					float x = (float) (mFocusX * rcos + mFocusY * -rsin - mFocusX);
					float y = (float) (mFocusX * rsin + mFocusY * rcos - mFocusY);

					mMapPosition.rotateMap((float) Math.toDegrees(da), x, y);

					changed = true;
				}
			}
		}

		if (changed)
			mMapView.redrawMap(true);

		mPrevX = x1;
		mPrevY = y1;
		mPrevX2 = x2;
		mPrevY2 = y2;

		mPrevPinchWidth = pinchWidth;
		mAngle = rad;

		return true;
	}

	private int mMulti = 0;
	private boolean mWasMulti;

	//	private long mMultiTouchDownTime;

	private boolean onActionPointerDown(MotionEvent event) {
		//	mMultiTouchDownTime = event.getEventTime();

		mMulti++;
		mWasMulti = true;
		mSumScale = 1;

		if (mMulti == 1) {
			mPrevX2 = event.getX(1);
			mPrevY2 = event.getY(1);

			double dx = event.getX(0) - mPrevX2;
			double dy = event.getY(0) - mPrevY2;
			mAngle = Math.atan2(dy, dx);
		}
		// Log.d("...", "mMulti down " + mMulti);
		return true;
	}

	private boolean onActionPointerUp(MotionEvent motionEvent) {

		// extract the index of the pointer that left the touch sensor
		int masked = (motionEvent.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK);
		int pointerIndex = masked >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;

		if (motionEvent.getPointerId(pointerIndex) == mActivePointerId) {
			// the active pointer has gone up, choose a new one
			if (pointerIndex == 0) {
				pointerIndex = 1;
			} else {
				pointerIndex = 0;
			}
			// save the position of the event
			//	mPrevX = motionEvent.getX(pointerIndex);
			mPrevY = motionEvent.getY(pointerIndex);
			mActivePointerId = motionEvent.getPointerId(pointerIndex);
		}
		mMulti--;

		mLongPress = false;

		// Log.d("...", "mMulti up " + mMulti);

		return true;
	}

	/**
	 * @param motionEvent
	 *            ...
	 * @return ...
	 */
	private boolean onActionUp(MotionEvent motionEvent) {
		mActivePointerId = INVALID_POINTER_ID;
		//mScaling = false;
		mLongPress = false;

		mMulti = 0;

		mPrevPinchWidth = -1;
		mPrevPointerCount = 0;

		return true;
	}

	/******************* GestureListener *******************/

	private final Scroller mScroller;
	private float mScrollX, mScrollY;
	private boolean fling = false;

	@Override
	public void onShowPress(MotionEvent e) {
		mOverlayManager.onShowPress(e, mMapView);
	}

	@Override
	public boolean onSingleTapUp(MotionEvent e) {
		return mOverlayManager.onSingleTapUp(e, mMapView);
	}

	@Override
	public boolean onDown(MotionEvent e) {
		if (fling) {
			mScroller.forceFinished(true);

			if (mTimer != null) {
				mTimer.cancel();
				mTimer = null;
			}
			fling = false;
		}

		return true;
	}

	boolean scroll() {
		if (mScroller.isFinished()) {
			return false;
		}
		mScroller.computeScrollOffset();

		float moveX = mScroller.getCurrX() - mScrollX;
		float moveY = mScroller.getCurrY() - mScrollY;

		if (moveX >= 1 || moveY >= 1 || moveX <= -1 || moveY <= -1) {
			mMapPosition.moveMap(moveX, moveY);
			mMapView.redrawMap(true);
			mScrollX = mScroller.getCurrX();
			mScrollY = mScroller.getCurrY();
		}
		return true;
	}

	@Override
	public boolean onScroll(final MotionEvent e1, final MotionEvent e2, final float distanceX,
			final float distanceY) {

		if (mOverlayManager.onScroll(e1, e2, distanceX, distanceY, mMapView)) {
			return true;
		}

		//		if (mScaling)
		//			return true;

		if (mMulti == 0) {
			mMapPosition.moveMap(-distanceX, -distanceY);
			mMapView.redrawMap(true);
		}

		return true;
	}

	@Override
	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
			float velocityY) {

		if (mWasMulti)
			return true;

		//		if (mScaling || mWasMulti)
		//			return true;

		int w = Tile.TILE_SIZE * 6;
		int h = Tile.TILE_SIZE * 6;
		mScrollX = 0;
		mScrollY = 0;

		if (mTimer != null) {
			mTimer.cancel();
			mTimer = null;
		}

		if (mMapView.enablePagedFling) {

			double a = Math.sqrt(velocityX * velocityX + velocityY * velocityY);

			float vx = (float) (velocityX / a);
			float vy = (float) (velocityY / a);

			Log.d(TAG, "velocity: " + a + " " + velocityX + " " + velocityY + " - " + vx + " " + vy);

			if (a < 400)
				return true;

			float move = Math.min(mMapView.getWidth(), mMapView.getHeight()) * 2 / 3;
			mMapPosition.animateTo(vx * move, vy * move, 250);
		} else {
			float s = (300 / mMapView.dpi) / 2;
			mScroller.fling(0, 0, Math.round(velocityX * s),
					Math.round(velocityY * s),
					-w, w, -h, h);

			mTimer = new CountDownTimer(1000, 16) {
				@Override
				public void onTick(long tick) {
					scroll();
				}

				@Override
				public void onFinish() {
				}
			}.start();
			fling = true;
		}
		return true;
	}

	@Override
	public void onLongPress(MotionEvent e) {
		if (mLongPress)
			return;

		if (mOverlayManager.onLongPress(e, mMapView)) {
			return;
		}

		//	if (MapView.testRegionZoom) {
		//		Log.d("mapsforge", "long press");
		//		mMapView.mRegionLookup.updateRegion(-1, null);
		//	}
	}

	boolean scale2(long tick) {

		fling = true;
		if (mPrevScale >= 1)
			return false;

		float adv = (SCALE_DURATION - tick) / SCALE_DURATION;
		adv = mInterpolator.getInterpolation(adv);
		float scale = adv - mPrevScale;
		mPrevScale += scale;
		scale *= 0.75;
		scale += 1;
		adv += 1;

		if (scale > 1) {
			mMapPosition.scaleMap(scale, mScrollX / adv, mScrollY / adv);
			mMapView.redrawMap(true);
		}

		return true;
	}

	/******************* DoubleTapListener ****************/
	@Override
	public boolean onSingleTapConfirmed(MotionEvent e) {
		return mOverlayManager.onSingleTapConfirmed(e, mMapView);
	}

	@Override
	public boolean onDoubleTap(MotionEvent e) {
		if (mOverlayManager.onDoubleTap(e, mMapView))
			return true;

		mLongPress = true;

		return true;
	}

	@Override
	public boolean onDoubleTapEvent(MotionEvent e) {
		return false;
	}

	//	/******************* ScaleListener *******************/
	private float mPrevScale;
	private CountDownTimer mTimer;
	boolean mZooutOut;
	//	private float mCenterX;
	//	private float mCenterY;
	private float mFocusX;
	private float mFocusY;
	//	private long mTimeStart;
	//	private long mTimeEnd;
	//
	//	@Override
	//	public boolean onScale(ScaleGestureDetector gd) {
	//
	//		if (mBeginTilt)
	//			return true;
	//
	//		float scale = gd.getScaleFactor();
	//		mFocusX = gd.getFocusX() - mCenterX;
	//		mFocusY = gd.getFocusY() - mCenterY;
	//
	//		mSumScale *= scale;
	//
	//		mTimeEnd = SystemClock.elapsedRealtime();
	//
	//		if (!mBeginScale) {
	//			if (mSumScale > 1.1 || mSumScale < 0.9) {
	//				// Log.d("...", "begin scale " + mSumScale);
	//				mBeginScale = true;
	//				// scale = mSumScale;
	//			}
	//		}
	//
	//		if (mBeginScale && mMapPosition.scaleMap(scale, mFocusX, mFocusY))
	//			mMapView.redrawMap(true);
	//
	//		return true;
	//	}
	//
	//	@Override
	//	public boolean onScaleBegin(ScaleGestureDetector gd) {
	//		mScaling = true;
	//		mBeginScale = false;
	//
	//		mTimeEnd = mTimeStart = SystemClock.elapsedRealtime();
	//		mSumScale = 1;
	//		mCenterX = mMapView.getWidth() >> 1;
	//		mCenterY = mMapView.getHeight() >> 1;
	//
	//		if (mTimer != null) {
	//			mTimer.cancel();
	//			mTimer = null;
	//		}
	//		return true;
	//	}
	//
	//	@Override
	//	public void onScaleEnd(ScaleGestureDetector gd) {
	//		// Log.d("ScaleListener", "Sum " + mSumScale + " " + (mTimeEnd -
	//		// mTimeStart));
	//
	//		if (mTimer == null && mTimeEnd - mTimeStart < 150
	//				&& (mSumScale < 0.99 || mSumScale > 1.01)) {
	//
	//			mPrevScale = 0;
	//
	//			mZooutOut = mSumScale < 0.99;
	//
	//			mTimer = new CountDownTimer((int) SCALE_DURATION, 32) {
	//				@Override
	//				public void onTick(long tick) {
	//					scaleAnim(tick);
	//				}
	//
	//				@Override
	//				public void onFinish() {
	//					scaleAnim(0);
	//				}
	//			}.start();
	//		} else {
	//			mScaling = false;
	//		}
	//
	//		mBeginScale = false;
	//	}
	//

	//
	//	boolean scaleAnim(long tick) {
	//
	//		if (mPrevScale >= 1) {
	//			mTimer = null;
	//			return false;
	//		}
	//
	//		float adv = (SCALE_DURATION - tick) / SCALE_DURATION;
	//		//		adv = mInterpolator.getInterpolation(adv);
	//		adv = mLinearInterpolator.getInterpolation(adv);
	//
	//		float scale = adv - mPrevScale;
	//		mPrevScale += scale;
	//
	//		if (mZooutOut) {
	//			mMapPosition.scaleMap(1 - scale, 0, 0);
	//		} else {
	//			mMapPosition.scaleMap(1 + scale, mFocusX, mFocusY);
	//		}
	//
	//		mMapView.redrawMap(true);
	//
	//		if (tick == 0)
	//			mTimer = null;
	//
	//		return true;
	//	}
}