/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU 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 General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package sk.baka.ambient.views.gesturelist;
  
  import java.util.List;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.views.ViewUtils;
  import sk.baka.ambient.views.gesturelist.MouseGesturesRecognizer.GestureEnum;
  import android.graphics.Point;
  import android.os.Handler;
  import android.view.Gravity;
  import android.view.MotionEvent;
  import android.view.View;
  import android.view.ViewGroup.LayoutParams;
  import android.widget.PopupWindow;
  import android.widget.TextView;
  
  /***
   * Controls the {@link GesturesListView} component via the touchpad.
   * 
   * @author Martin Vysny
   */
  final class TouchPadController {
  	private final Handler handler = AmbientApplication.getHandler();
  
  	/***
  	 * The view being controlled.
  	 */
  	private final GesturesListView owningView;
  
  	/***
  	 * Creates new controller.
  	 * 
  	 * @param view
  	 *            the view to control.
  	 */
  	TouchPadController(final GesturesListView view) {
  		super();
  		this.owningView = view;
  	}
  
  	/***
  	 * The gesture recognizer.
  	 */
  	private final MouseGesturesRecognizer gestureRecognizer = new MouseGesturesRecognizer();
  
  	/***
  	 * If <code>false</code> then gesture handling is disabled until next
  	 * PEN_DOWN event. Useful when leaving scrolling to the android component.
  	 */
  	private boolean enableGestureProcessing = true;
  
  	/***
  	 * If <code>true</code> then we are selecting items with the R/RD gesture.
  	 * Default event processing is disabled.
  	 */
  	private boolean highlighting = false;
  
  	/***
  	 * If <code>true</code> then super {@link #onTouchEvent(MotionEvent)} is
  	 * not invoked.
  	 */
  	private boolean suppressHandler = false;
  
  	/***
  	 * Initial PEN_DOWN point.
  	 */
  	private Point initialPoint;
  
  	/***
  	 * Initial index of the item.
  	 */
  	private int initialItem;
  
  	/***
  	 * If <code>true</code> then the LU/LD gestures are in effect.
  	 */
  	private boolean draggingItems = false;
 
 	/***
 	 * Reflects last {@link MotionEvent} coordinates.
 	 */
 	private final Point currentEventPoint = new Point();
 
 	/***
 	 * If {@link #draggingItems dragging} then this window contain an overview
 	 * of dragged items attached to the cursor.
 	 */
 	private PopupWindow dragHintWindow;
 
 	private boolean canHighlight() {
 		if (owningView.listener.canHighlight()) {
 			return true;
 		}
 		owningView.setMode(R.string.cannotSelect, this, false);
 		initialItem = -1;
 		draggingItems = false;
 		highlighting = false;
 		enableGestureProcessing = false;
 		suppressHandler = false;
 		return false;
 	}
 
 	/***
 	 * Handles the {@link View#onTouchEvent(MotionEvent)} events.
 	 * 
 	 * @param event
 	 *            the event to handle
 	 * @return if <code>false</code> then the event is not handled and should
 	 *         be routed to super class.
 	 */
 	boolean onTouchEvent(MotionEvent event) {
 		currentEventPoint.x = (int) event.getX();
 		currentEventPoint.y = (int) event.getY();
 		if (event.getAction() == MotionEvent.ACTION_DOWN) {
 			enableGestureProcessing = true;
 			suppressHandler = false;
 			initialPoint = ViewUtils.clone(currentEventPoint);
 			initialItem = owningView.pointToPosition(initialPoint.x,
 					initialPoint.y);
 			final boolean isEOP = owningView.isEOP(initialItem);
 			if (isEOP) {
 				initialItem = -1;
 			}
 		}
 		if (enableGestureProcessing) {
 			handleGestures(event);
 		}
 		if (highlighting) {
 			// post highlight event
 			int item = owningView.getItemIndex(event);
 			if (item < 0) {
 				if (event.getY() < 0) {
 					item = 0;
 				} else {
 					item = owningView.getCount() - 1;
 				}
 			}
 			if (!owningView.getHighlight().equals(initialItem, item)) {
 				owningView.getModel().highlight(
 						Interval.fromRange(initialItem, item));
 				owningView.getModel().notifyModified();
 			}
 			if (ViewUtils.isPenUp(event)) {
 				owningView.clearMode(this);
 				highlighting = false;
 				owningView.restoreSelector();
 				handleScrolling(null, true);
 			} else {
 				handleScrolling(currentEventPoint, false);
 			}
 		}
 		if (draggingItems) {
 			utils.translateCoordinatesToRoot(currentEventPoint, owningView);
 			if (dragHintWindow != null) {
 				dragHintWindow.update(utils.translated.x, utils.translated.y,
 						-1, -1);
 			}
 			final GesturesListView target = owningView
 					.findView(currentEventPoint);
 			if (ViewUtils.isPenUp(event)) {
 				// PEN_UP. Look up a GesturesListView underneath the cursor
 				// and drop the items there.
 				owningView.clearMode(this);
 				setDragging(false);
 				if (dragHintWindow != null) {
 					dragHintWindow.dismiss();
 					dragHintWindow = null;
 				}
 				if (target != null) {
 					if (!ViewUtils.isCancel(event)) {
 						invokeDragDropEvent(currentEventPoint);
 					}
 					target.touchController.handleScrolling(null, true);
 				}
 			} else {
 				if (target != null) {
 					utils.translateCoordinates(currentEventPoint, owningView,
 							target);
 					target.touchController.handleScrolling(utils.translated,
 							false);
 				}
 			}
 		}
 		return suppressHandler;
 	}
 
 	/***
 	 * Checks if this event activates a gesture, and in such case acts
 	 * accordingly.
 	 * 
 	 * @param event
 	 *            the mouse event.
 	 */
 	private void handleGestures(MotionEvent event) {
 		final GestureEnum g = gestureRecognizer.processMouseEvent(event);
 		final String gesture = gestureRecognizer.getGesture();
 		if (g == GestureEnum.NewGesture) {
 			final char firstGesture = gestureRecognizer.getLastGesture();
 			// prevent handler to grab PEN_UP event which will result in
 			// onClick event
 			suppressHandler = true;
 			if ((firstGesture == MouseGesturesRecognizer.DOWN_MOVE)
 					|| (firstGesture == MouseGesturesRecognizer.UP_MOVE)) {
 				// scrolling event. disable gesture processing and let
 				// android scroll by itself
 				enableGestureProcessing = false;
 				suppressHandler = false;
 			} else if (firstGesture == MouseGesturesRecognizer.RIGHT_MOVE) {
 				// select a single item
 				if (canHighlight()) {
 					final int item = initialItem;
 					if (item >= 0) {
 						owningView.getModel()
 								.highlight(Interval.fromItem(item));
 						owningView.getModel().notifyModified();
 					}
 					owningView.setMode(R.string.selection, this, true);
 				}
 			} else {
 				assert firstGesture == MouseGesturesRecognizer.LEFT_MOVE;
 				owningView.setMode(owningView.hintDeleteCopyMoveId, this, true);
 				// do nothing, wait for further gestures
 			}
 		} else if (g == GestureEnum.GestureFinished) {
 			boolean clearMode = true;
 			if ("L".equals(gesture)) {
 				// remove selected items
 				owningView.setMode(owningView.hintDeleteId, this, false);
 				clearMode = false;
 				owningView.listener.removeItems(owningView.getModel()
 						.getHighlight(initialItem));
 				if (!owningView.getHighlight().isEmpty()) {
 					owningView.getModel().highlight(Interval.EMPTY);
 					owningView.getModel().notifyModified();
 				}
 			} else if ("R".equals(gesture)) {
 				// select all items
 				clearMode = false;
 				if (canHighlight()) {
 					owningView.setMode(R.string.select_all, this, false);
 					owningView.getModel().highlight(
 							owningView.getModel().getAllItems());
 					owningView.getModel().notifyModified();
 				}
 			}
 			enableGestureProcessing = false;
 			if (clearMode) {
 				owningView.clearMode(this);
 			}
 		} else if (g == GestureEnum.ContinuingGesture) {
 			if ("RU".equals(gesture)) {
 				// deselect items
 				owningView.getModel().highlight(Interval.EMPTY);
 				owningView.getModel().notifyModified();
 				owningView.setMode(R.string.deselect_all, this, false);
 			} else if ("RD".equals(gesture)) {
 				// selecting multiple items for sure.
 				if (owningView.listener.canHighlight()) {
 					highlighting = true;
 					owningView.transparentSelector();
 				}
 			} else if (gesture.startsWith("L")
 					&& canComputeItems()) {
 				// drag'n'drop / move items up/down
 				setDragging(true);
 				final String hint = owningView.listener.getHint(owningView
 						.getModel().getHighlight(initialItem));
 				if (hint != null) {
 					dragHintWindow = new PopupWindow(owningView.getContext());
 					final TextView textView = new TextView(owningView
 							.getContext());
 					textView.setText(hint);
 					dragHintWindow.setContentView(textView);
 					dragHintWindow.showAtLocation(owningView.getRootView(),
 							Gravity.NO_GRAVITY, 0, 0);
 					dragHintWindow.update(0, 0, LayoutParams.WRAP_CONTENT,
 							LayoutParams.WRAP_CONTENT);
 				}
 				owningView.setMode(R.string.dragDrop, this, true);
 			}
 			enableGestureProcessing = false;
 		}
 	}
 
 	private boolean canComputeItems() {
 		if (owningView.listener.canComputeItems()) {
 			return true;
 		}
 		owningView.setMode(R.string.cannotDragDrop, this, false);
 		return false;
 	}
 
 	private void setDragging(boolean b) {
 		draggingItems = b;
 		for (final GesturesListView target : owningView.dragDropViews) {
 			target.getModel().adapter.setEOP(b);
 		}
 	}
 
 	/***
 	 * Activates or deactivates scrolling according to the point location in the
 	 * view.
 	 * 
 	 * @param point
 	 *            the point in this view's coordinate system
 	 * @param cancel
 	 *            if <code>true</code> then scrolling is canceled regardless of
 	 *            the point location.
 	 */
 	private void handleScrolling(final Point point, final boolean cancel) {
 		if (cancel) {
 			handler.removeCallbacks(scroller);
 			scrolling = 0;
 		} else {
 			// scroll if the pen is in the bottom area
 			if (owningView.getHeight() - point.y < 30) {
 				if (scrolling < 1) {
 					scrolling = 1;
 					currentScrolledItem = owningView.pointToPosition(point.x,
 							point.y)
 							- scrolling - 1;
 					handler.post(scroller);
 				}
 			} else if (point.y < 30) {
 				if (scrolling > -1) {
 					scrolling = -1;
 					currentScrolledItem = owningView.pointToPosition(point.x,
 							point.y)
 							- scrolling + 1;
 					handler.post(scroller);
 				}
 			} else {
 				if (scrolling != 0) {
 					handler.removeCallbacks(scroller);
 					scrolling = 0;
 				}
 			}
 		}
 	}
 
 	private final ViewUtils utils = new ViewUtils();
 
 	/***
 	 * Finds a view containing given point and invokes drag event on the view.
 	 * The method does nothing if given point does not intersect any registered
 	 * view.
 	 * 
 	 * @param point
 	 *            the point, relative to this view.
 	 */
 	private void invokeDragDropEvent(final Point point) {
 		final GesturesListView view = owningView.findView(point);
 		if (view == null)
 			return;
 		// we found the view. compute relative position
 		utils.translateCoordinates(point, owningView, view);
 		final Point p = ViewUtils.clone(utils.translated);
 		final Interval hl = owningView.getModel().getHighlight(
 				initialItem);
 		// compute item index, where to insert.
 		int _index = view.pointToPosition(p.x, p.y);
 		if (_index < 0) {
 			_index = view.getCount();
 		}
 		final int index = _index;
 		final boolean isMoving = (view == owningView);
 		if (isMoving) {
 			final Interval newInterval = view.listener.moveItems(hl, index);
 			view.getModel().highlight(newInterval);
 			view.getModel().notifyModified();
 			return;
 		}
 		final boolean isLongOp = owningView.listener
 				.isComputeTracksLong(hl);
 		final boolean isOnlineOp = owningView.listener
 				.isComputeTracksOnlineOp(hl);
 		// run the dragdrop/move operation
 		final Runnable dragDrop = new Runnable() {
 			private volatile List<TrackMetadataBean> tracks;
 
 			private volatile boolean obtainedTracks = false;
 
 			public void run() {
 				// drag'n'drop
 				if (!obtainedTracks) {
 					tracks = owningView.listener.computeTracks(hl);
 					obtainedTracks = true;
 					if (tracks != null) {
 						// copy items to a thread-safe list
 						tracks = new CopyOnWriteArrayList<TrackMetadataBean>(
 								tracks);
 					}
 					handler.post(this);
 				} else {
 					if ((tracks != null) && !tracks.isEmpty()) {
 						view.listener.dropItems(tracks, p.x, p.y, index);
 					}
 				}
 			}
 		};
 		if (isLongOp) {
 			AmbientApplication.getInstance().getBackgroundTasks().schedule(
 					dragDrop,
 					GesturesListView.class,
 					isOnlineOp,
 					owningView.getResources().getString(
 							R.string.fb_adding_tracks));
 		} else {
 			try {
 				dragDrop.run();
 			} catch (final Exception ex) {
 				if (!Thread.currentThread().isInterrupted()) {
 					final AmbientApplication app = AmbientApplication
 							.getInstance();
 					app.error(KeypadController.class, true, app
 							.getString(R.string.error), ex);
 				}
 			}
 		}
 	}
 
 	/***
 	 * If not <code>0</code> then the {@link #scroller} is active.
 	 */
 	private short scrolling = 0;
 
 	/***
 	 * The list view's current selection is set to this item, which causes the
 	 * list view to be scrolled automatically.
 	 */
 	private int currentScrolledItem = 0;
 
 	/***
 	 * Scrolls the view as requested and reschedules itself.
 	 */
 	private final Runnable scroller = new Runnable() {
 		public void run() {
 			currentScrolledItem += scrolling;
 			owningView.setSelection(currentScrolledItem);
 			handler.postDelayed(this, 250);
 		}
 	};
 }