/***
    *     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.Collections;
  import java.util.List;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import android.view.KeyEvent;
  
  /***
   * Controls the {@link GesturesListView} component via the keypad.
   * 
   * @author Martin Vysny
   */
  final class KeypadController implements KeyEvent.Callback {
  	/***
  	 * The owning view.
  	 */
  	private final GesturesListView ownerView;
  
  	/***
  	 * Creates new controller instance.
  	 * 
  	 * @param ownerView
  	 *            the owning view.
  	 */
  	KeypadController(final GesturesListView ownerView) {
  		super();
  		this.ownerView = ownerView;
  	}
  
  	/***
  	 * The mode we are currently in.
  	 * 
  	 * @author Martin Vysny
  	 */
  	private static enum Mode {
  		/***
  		 * Normal mode.
  		 */
  		NORMAL,
  		/***
  		 * Selection mode.Items are selected by pressing the U , D arrow keys.
  		 * To leave this mode, press Center button. Pressing the Center button
  		 * copies selected items into the clipboard.
  		 */
  		SELECTION,
  		/***
  		 * Selected items are moved up/downwards the playlist as the U and D
  		 * buttons are pressed. To leave this mode, press Center button.
  		 */
  		MOVE;
  	}
  
  	/***
  	 * Current working mode.
  	 */
  	private Mode mode = Mode.NORMAL;
  
  	/***
  	 * Previous key event. Serves for remembering gesture combo.
  	 */
  	private int prevKeyCode = -1;
  
  	/***
  	 * Initial index of the item when selecting items.
  	 */
  	private int initialItem = -1;
  
  	private boolean isReadOnly() {
  		if (!ownerView.listener.isReadOnly()) {
  			return false;
  		}
  		ownerView.setMode(R.string.cannotModify, this, false);
  		initialItem = -1;
  		prevKeyCode = -1;
  		mode = Mode.NORMAL;
  		return true;
  	}
 
 	private boolean canHighlight() {
 		if (ownerView.listener.canHighlight()) {
 			return true;
 		}
 		ownerView.setMode(R.string.cannotSelect, this, false);
 		initialItem = -1;
 		prevKeyCode = -1;
 		mode = Mode.NORMAL;
 		return false;
 	}
 
 	public boolean onKeyUp(int keyCode, KeyEvent event) {
 		final int index = ownerView.getSelectedItemPosition();
 		final boolean isEOP = ownerView.isEOP(index);
 		switch (mode) {
 		case NORMAL:
 			switch (keyCode) {
 			case KeyEvent.KEYCODE_DPAD_CENTER:
 				boolean clearHint = true;
 				if (index >= 0) {
 					if (prevKeyCode == -1) {
 						if (!isEOP) {
 							ownerView.listener.itemActivated(index, ownerView
 									.getModel().getModel().get(index));
 						}
 					} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 						// the LC gesture. paste
 						clearHint = false;
 						if (!isReadOnly()) {
 							final List<TrackMetadataBean> tracks = getClipboard();
 							if (!tracks.isEmpty()) {
 								ownerView.setMode(R.string.paste, this, false);
 								ownerView.listener.dropItems(tracks, -1, -1,
 										index);
 							} else {
 								ownerView.setMode(R.string.clipboardEmpty,
 										this, false);
 							}
 						}
 					} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 						// copy to clipboard
 						if (ownerView.listener.canComputeItems()) {
 							clearHint = false;
 							ownerView.setMode(R.string.copyToClipboard, this,
 									false);
 							copy(ownerView.getModel().getHighlight(initialItem));
 						}
 					}
 				}
 				clearMode(clearHint);
 				return true;
 			case KeyEvent.KEYCODE_DPAD_RIGHT:
 				if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 					// RR gesture - enter selection mode
 					if (canHighlight()) {
 						ownerView.getModel().highlight(
 								ownerView.getModel().getAllItems());
 						ownerView.getModel().notifyModified();
 						mode = Mode.SELECTION;
 						prevKeyCode = -1;
 					}
 					return true;
 				}
 				if (index >= 0) {
 					if (canHighlight()) {
 						prevKeyCode = KeyEvent.KEYCODE_DPAD_RIGHT;
 						ownerView.setMode(R.string.selection, this, true);
 						ownerView.getModel()
 								.highlight(Interval.fromItem(index));
 						ownerView.getModel().notifyModified();
 						initialItem = index;
 					}
 					return true;
 				}
 				break;
 			case KeyEvent.KEYCODE_DPAD_DOWN:
 				if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 					// RD - enter selection mode
 					if (canHighlight()) {
 						mode = Mode.SELECTION;
 						prevKeyCode = -1;
 					}
 					// fall back to the original implementation, to fire
 					// selectionChanged event
 					return false;
 				} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 					// LD - move up
 					if (!isReadOnly()) {
 						enterItemMoveMode(isEOP, true);
 					}
 					return true;
 				}
 				break;
 			case KeyEvent.KEYCODE_DPAD_UP:
 				if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 					// RU - clear selection
 					ownerView.setMode(R.string.deselect_all,
 							KeypadController.this, false);
 					ownerView.getModel().highlight(Interval.EMPTY);
 					ownerView.getModel().notifyModified();
 					clearMode(false);
 					return true;
 				} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 					// LU - move up
 					if (!isReadOnly()) {
 						enterItemMoveMode(isEOP, false);
 					}
 					return true;
 				}
 				break;
 			case KeyEvent.KEYCODE_DPAD_LEFT:
 				if (prevKeyCode == -1) {
 					prevKeyCode = KeyEvent.KEYCODE_DPAD_LEFT;
 					ownerView.setMode(ownerView.hintDeleteMovePasteId, this,
 							true);
 					return true;
 				} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 					// LL - delete highlight
 					ownerView.setMode(ownerView.hintDeleteId, this, false);
 					ownerView.listener.removeItems(ownerView.getModel()
 							.getHighlight(true));
 					if (!ownerView.getHighlight().isEmpty()) {
 						ownerView.getModel().highlight(Interval.EMPTY);
 						ownerView.getModel().notifyModified();
 					}
 					clearMode(false);
 					return true;
 				}
 				break;
 			default:
 				clearMode();
 			}
 			break;
 		case SELECTION:
 			// we do not handle UP/DOWN keys - we'll handle the selectionChanged
 			// event instead. The only button we handle is the Center button,
 			// which leaves this mode, and the R button, which selects all
 			// items.
 			switch (keyCode) {
 			case KeyEvent.KEYCODE_DPAD_CENTER:
 				ownerView.setMode(R.string.copyToClipboard, this, false);
 				copy(ownerView.getModel().getHighlight(initialItem));
 				clearMode(false);
 				return true;
 			case KeyEvent.KEYCODE_DPAD_RIGHT:
 				ownerView.getModel().highlight(
 						ownerView.getModel().getAllItems());
 				ownerView.getModel().notifyModified();
 				return true;
 			}
 			break;
 		case MOVE:
 			switch (keyCode) {
 			case KeyEvent.KEYCODE_DPAD_CENTER:
 				clearMode();
 				return true;
 			case KeyEvent.KEYCODE_DPAD_UP: {
 				final Interval newInterval = moveItems(false);
 				ownerView.getModel().highlight(newInterval);
 				ownerView.getModel().notifyModified();
 				ownerView.setSelection(newInterval.start);
 				return true;
 			}
 			case KeyEvent.KEYCODE_DPAD_DOWN: {
 				final Interval newInterval = moveItems(true);
 				ownerView.getModel().highlight(newInterval);
 				ownerView.getModel().notifyModified();
 				ownerView.setSelection(newInterval.end);
 				return true;
 			}
 			}
 			break;
 		}
 		return false;
 	}
 
 	private Interval enterItemMoveMode(final boolean isEOP, final boolean down) {
 		if (!ownerView.canMove() || isEOP) {
 			clearMode(true);
 			return ownerView.getHighlight();
 		}
 		mode = Mode.MOVE;
 		ownerView.setMode(R.string.move, this, true);
 		final Interval result = moveItems(down);
 		ownerView.getModel().notifyModified();
 		return result;
 	}
 
 	private Interval moveItems(final boolean down) {
 		return ownerView.listener.moveItemsByOne(ownerView.getModel()
 				.getHighlight(true), down);
 	}
 
 	private void clearMode() {
 		clearMode(true);
 	}
 
 	private void clearMode(final boolean clearModeHint) {
 		mode = Mode.NORMAL;
 		if (clearModeHint)
 			ownerView.clearMode(this);
 		prevKeyCode = -1;
 	}
 
 	public boolean onKeyDown(int keyCode, android.view.KeyEvent event) {
 		return false;
 	}
 
 	public boolean onKeyMultiple(int keyCode, int arg1,
 			android.view.KeyEvent event) {
 		// do nothing
 		return false;
 	}
 
 	/***
 	 * Invoked when the selection is changed.
 	 */
 	synchronized void selectionChanged() {
 		switch (mode) {
 		case NORMAL:
 			// do nothing
 			return;
 		case SELECTION:
 			final int select = ownerView.getSelectedItemPosition();
 			if (select >= 0) {
 				ownerView.getModel().highlight(
 						Interval.fromRange(select, initialItem));
 				ownerView.getModel().notifyModified();
 			}
 			return;
 		case MOVE:
 			return;
 		}
 	}
 
 	/***
 	 * Invoked by gestures list view if this controller should cancel all its
 	 * work immediately as other controller is about to do something.
 	 */
 	synchronized void cancelWork() {
 		clearMode();
 	}
 
 	/***
 	 * Copies given interval into the clipboard. The operation does not block -
 	 * it may retrieve the tracks in the background
 	 * 
 	 * @param i
 	 *            the interval to copy.
 	 */
 	public void copy(final Interval i) {
 		final boolean isLongOp = ownerView.listener.isComputeTracksLong(i);
 		final boolean isOnlineOp = ownerView.listener
 				.isComputeTracksOnlineOp(i);
 		final Runnable copyOp = new Runnable() {
 			/***
 			 * Retrieved tracks.
 			 */
 			private volatile List<TrackMetadataBean> tracks = null;
 
 			public void run() {
 				if (tracks == null) {
 					tracks = ownerView.listener.computeTracks(i);
 					if (Thread.currentThread().isInterrupted())
 						return;
 					if ((tracks == null) || tracks.isEmpty())
 						return;
 					// prepare a thread-safe list
 					tracks = Collections.synchronizedList(tracks);
 					AmbientApplication.getHandler().post(this);
 				} else {
 					if (ownerView.dragDropViews.isEmpty())
 						return;
 					final TrackListClipboardObject obj = new TrackListClipboardObject(
 							tracks, ownerView.dragDropViews);
 					ownerView.listener.setClipboard(obj);
 				}
 			}
 		};
 		if (isLongOp) {
 			AmbientApplication.getInstance().getBackgroundTasks().schedule(
 					copyOp,
 					GesturesListView.class,
 					isOnlineOp,
 					ownerView.getResources().getString(
 							R.string.copyingToClipboard));
 		} else {
 			try {
 				copyOp.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);
 				}
 			}
 		}
 	}
 
 	/***
 	 * Returns the contents of the clipboard as a list of tracks.
 	 * 
 	 * @return list of tracks, never <code>null</code>, may be empty.
 	 */
 	public List<TrackMetadataBean> getClipboard() {
 		final TrackListClipboardObject obj = ownerView.getClipboard();
 		if (obj == null)
 			return Collections.emptyList();
 		if (!obj.isTarget(ownerView))
 			return Collections.emptyList();
 		return obj.getObjects();
 	}
 }