/***
    *     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.keypad;
  
  import java.util.Collections;
  import java.util.List;
  import java.util.concurrent.Callable;
  
  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.commons.MiscUtils;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  import sk.baka.ambient.views.gesturelist.TrackListClipboardObject;
  import android.view.KeyEvent;
  
  /***
   * Controls the {@link GesturesListView} component via the keypad.
   * 
   * @author Martin Vysny
   */
  public final class KeypadController extends AbstractKeypadHandler {
  	@Override
  	public boolean isActivatedByKey(int keyCode, final KeyEvent event) {
  		return keyCode == KeyEvent.KEYCODE_DPAD_LEFT
  				|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT;
  	}
  
  	@Override
  	public boolean isStarted() {
  		return mode != Mode.NORMAL || initialItem != -1 || prevKeyCode != -1;
  	}
  
  	@Override
  	public void start() {
  		initialItem = -1;
  		prevKeyCode = -1;
  		mode = Mode.NORMAL;
  	}
  
  	@Override
  	public synchronized void stop() {
  		initialItem = -1;
  		prevKeyCode = -1;
  		mode = Mode.NORMAL;
  		clearMode();
  	}
  
  	/***
  	 * Creates new controller instance.
  	 * 
  	 * @param ownerView
  	 *            the owning view.
  	 */
  	public KeypadController(final GesturesListView ownerView) {
  		super(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 (!owner.listener.isReadOnly()) {
 			return false;
 		}
 		owner.setTooltip(R.string.cannotModify, this, false);
 		initialItem = -1;
 		prevKeyCode = -1;
 		mode = Mode.NORMAL;
 		return true;
 	}
 
 	private boolean canHighlight() {
 		if (owner.listener.canHighlight()) {
 			return true;
 		}
 		owner.setTooltip(R.string.cannotSelect, this, false);
 		initialItem = -1;
 		prevKeyCode = -1;
 		mode = Mode.NORMAL;
 		return false;
 	}
 
 	@Override
 	protected boolean onKey(int keyCode, int count, KeyEvent event) {
 		switch (mode) {
 		case NORMAL:
 			return onKeyNormalMode(keyCode);
 		case SELECTION:
 			return onKeySelectionMode(keyCode);
 		case MOVE:
 			return onKeyMoveMode(keyCode);
 		}
 		throw new IllegalStateException();
 	}
 
 	private boolean onKeyMoveMode(int keyCode) {
 		switch (keyCode) {
 		case KeyEvent.KEYCODE_DPAD_CENTER:
 		case KeyEvent.KEYCODE_ENTER:
 			clearMode();
 			return true;
 		case KeyEvent.KEYCODE_DPAD_UP: {
 			final Interval newInterval = moveItems(false);
 			owner.getModel().highlight(newInterval);
 			owner.getModel().notifyModified();
 			owner.setSelection(newInterval.start);
 			return true;
 		}
 		case KeyEvent.KEYCODE_DPAD_DOWN: {
 			final Interval newInterval = moveItems(true);
 			owner.getModel().highlight(newInterval);
 			owner.getModel().notifyModified();
 			owner.setSelection(newInterval.end);
 			return true;
 		}
 		case KeyEvent.KEYCODE_BACK:
 			// cancel
 			clearMode();
 			owner.getModel().highlight(null);
 			owner.getModel().notifyModified();
 			return true;
 		}
 		return false;
 	}
 
 	private boolean onKeySelectionMode(int keyCode) {
 		// 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:
 		case KeyEvent.KEYCODE_ENTER:
 			owner.setTooltip(R.string.copyToClipboard, this, false);
 			copy(owner.getModel().getHighlight(initialItem));
 			clearMode(false);
 			return true;
 		case KeyEvent.KEYCODE_DPAD_RIGHT:
 			owner.getModel().highlight(owner.getModel().getAllItems());
 			owner.getModel().notifyModified();
 			return true;
 		case KeyEvent.KEYCODE_BACK:
 			// cancel
 			clearMode();
 			owner.getModel().highlight(null);
 			owner.getModel().notifyModified();
 			return true;
 		}
 		return false;
 	}
 
 	private boolean onKeyNormalMode(final int keyCode) {
 		final int index = owner.getSelectedItemPosition();
 		final boolean isEOP = owner.isEOP(index);
 		switch (keyCode) {
 		case KeyEvent.KEYCODE_DPAD_CENTER:
 		case KeyEvent.KEYCODE_ENTER:
 			boolean clearHint = true;
 			if (index >= 0) {
 				if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 					// the LC gesture. paste
 					clearHint = false;
 					if (!isReadOnly()) {
 						final List<TrackMetadataBean> tracks = getClipboard();
 						if (!tracks.isEmpty()) {
 							owner.setTooltip(R.string.paste, this, false);
 							owner.listener.dropItems(tracks, -1, -1, index);
 						} else {
 							owner.setTooltip(R.string.clipboardEmpty, this, false);
 						}
 					}
 				} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 					// copy to clipboard
 					if (owner.listener.canComputeItems()) {
 						clearHint = false;
 						owner.setTooltip(R.string.copyToClipboard, this, false);
 						copy(owner.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()) {
 					owner.getModel().highlight(owner.getModel().getAllItems());
 					owner.getModel().notifyModified();
 					mode = Mode.SELECTION;
 					prevKeyCode = -1;
 					owner.setTooltip(R.string.select_some, this, true);
 				}
 				return true;
 			} else if ((prevKeyCode == -1) && (index >= 0)) {
 				if (canHighlight()) {
 					prevKeyCode = KeyEvent.KEYCODE_DPAD_RIGHT;
 					owner.setTooltip(R.string.selection, this, true);
 					owner.getModel().highlight(Interval.fromItem(index));
 					owner.getModel().notifyModified();
 					initialItem = index;
 				}
 				return true;
 			}
 			break;
 		case KeyEvent.KEYCODE_DPAD_DOWN:
 			if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 				// RD - enter selection mode
 				if (canHighlight()) {
 					owner.setTooltip(R.string.select_some, this, true);
 					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 down
 				if (!isReadOnly()) {
 					enterItemMoveMode(isEOP, true);
 				}
 				return false;
 			}
 			break;
 		case KeyEvent.KEYCODE_DPAD_UP:
 			if (prevKeyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
 				// RU - clear selection
 				owner.setTooltip(R.string.deselect_all, KeypadController.this,
 						false);
 				owner.getModel().highlight(Interval.EMPTY);
 				owner.getModel().notifyModified();
 				clearMode(false);
 				return true;
 			} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 				// LU - move up
 				if (!isReadOnly()) {
 					enterItemMoveMode(isEOP, false);
 				}
 				return false;
 			}
 			break;
 		case KeyEvent.KEYCODE_DPAD_LEFT:
 			if (prevKeyCode == -1) {
 				prevKeyCode = KeyEvent.KEYCODE_DPAD_LEFT;
 				owner.setTooltip(owner.hintDeleteMovePasteId, this, true);
 				return true;
 			} else if (prevKeyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
 				// LL - delete highlight
 				owner.setTooltip(owner.hintDeleteId, this, false);
 				owner.listener.removeItems(owner.getModel().getHighlight(true));
 				if (!owner.getHighlight().isEmpty()) {
 					owner.getModel().highlight(Interval.EMPTY);
 					owner.getModel().notifyModified();
 				}
 				clearMode(false);
 				return true;
 			}
 			break;
 		case KeyEvent.KEYCODE_BACK:
 			// cancel
 			clearMode();
 			owner.getModel().highlight(null);
 			owner.getModel().notifyModified();
 			return true;
 		default:
 			clearMode();
 		}
 		return false;
 	}
 
 	private Interval enterItemMoveMode(final boolean isEOP, final boolean down) {
 		if (!owner.canMove() || isEOP) {
 			clearMode(true);
 			return owner.getHighlight();
 		}
 		mode = Mode.MOVE;
 		owner.setTooltip(R.string.move, this, true);
 		final Interval result = moveItems(down);
 		owner.getModel().notifyModified();
 		return result;
 	}
 
 	private Interval moveItems(final boolean down) {
 		return owner.listener.moveItemsByOne(owner.getModel()
 				.getHighlight(true), down);
 	}
 
 	private void clearMode() {
 		clearMode(true);
 	}
 
 	private void clearMode(final boolean clearModeHint) {
 		if (clearModeHint) {
 			owner.clearTooltip(this);
 		}
 		initialItem = -1;
 		prevKeyCode = -1;
 		mode = Mode.NORMAL;
 	}
 
 	@Override
 	public void selectionChanged() {
 		switch (mode) {
 		case NORMAL:
 			// do nothing
 			return;
 		case SELECTION:
 			final int select = owner.getSelectedItemPosition();
 			if (select >= 0) {
 				owner.getModel().highlight(
 						Interval.fromRange(select, initialItem));
 				owner.getModel().notifyModified();
 			}
 			return;
 		case MOVE:
 			return;
 		}
 	}
 
 	/***
 	 * 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 = owner.listener.isComputeTracksLong(i);
 		final boolean isOnlineOp = owner.listener.isComputeTracksOnlineOp(i);
 		final Callable<Void> copyOp = new Callable<Void>() {
 			/***
 			 * Retrieved tracks.
 			 */
 			private volatile List<TrackMetadataBean> tracks = null;
 
 			public Void call() {
 				if (tracks == null) {
 					tracks = owner.listener.computeTracks(i);
 					if (Thread.currentThread().isInterrupted()) {
 						return null;
 					}
 					if ((tracks == null) || tracks.isEmpty()) {
 						return null;
 					}
 					// prepare a thread-safe list
 					tracks = Collections.synchronizedList(tracks);
 					AmbientApplication.getHandler().post(
 							MiscUtils.toRunnable(this));
 				} else {
 					if (owner.dragDropViews.isEmpty()) {
 						return null;
 					}
 					final TrackListClipboardObject obj = new TrackListClipboardObject(
 							tracks, owner.dragDropViews);
 					owner.listener.setClipboard(obj);
 				}
 				return null;
 			}
 		};
 		if (isLongOp) {
 			AmbientApplication.getInstance().getBackgroundTasks()
 					.schedule(
 							copyOp,
 							GesturesListView.class,
 							isOnlineOp,
 							owner.getResources().getString(
 									R.string.copyingToClipboard));
 		} else {
 			try {
 				copyOp.call();
 			} 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 = owner.getClipboard();
 		if (obj == null) {
 			return Collections.emptyList();
 		}
 		if (!obj.isTarget(owner)) {
 			return Collections.emptyList();
 		}
 		return obj.getObjects();
 	}
 }