/***
    *     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.ArrayList;
  import java.util.List;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.views.ContainedPopupWindow;
  import sk.baka.ambient.views.Iconify;
  import sk.baka.ambient.views.ViewUtils;
  import sk.baka.ambient.views.gesturelist.keypad.KeypadDpadSearch;
  import sk.baka.ambient.views.gesturelist.keypad.KeypadManager;
  import android.content.Context;
  import android.content.res.TypedArray;
  import android.graphics.Color;
  import android.graphics.Point;
  import android.graphics.Rect;
  import android.graphics.drawable.Drawable;
  import android.graphics.drawable.PaintDrawable;
  import android.text.SpannableStringBuilder;
  import android.util.AttributeSet;
  import android.util.Log;
  import android.view.KeyEvent;
  import android.view.MotionEvent;
  import android.view.View;
  import android.widget.AdapterView;
  import android.widget.ListAdapter;
  import android.widget.ListView;
  import android.widget.TextView;
  
  /***
   * <p>
   * Captures the {@link MotionEvent motion events} and generates more high-level
   * gesture events.
   * </p>
   * <p>
   * To configure the view you may need to set the two properties:
   * </p>
   * <ul>
   * <li>The {@link #dragDropViews} list - list of targets where the items can be
   * dropped. May be <code>null</code> - this has the same meaning as an empty
   * list</li>
   * <li>The event handler {@link #listener} </li>
   * </ul>
   * <p>
   * The view offers a lot simplified API than the classical {@link ListView}, at
   * the price of disabling support for other adapters. For example, there is no
   * need to set the {@link ListAdapter} and evade the minefield of
   * list-scroll-position-resetting functions like {@link #getAdapter()}
   * </p>
   * <p>
   * To work with this modified list view, you just need to modify model using the
   * {@link #getModel() model holder}.
   * </p>
   * 
   * @author Martin Vysny
   */
  public class GesturesListView extends ListView {
  
  	/***
  	 * Layout ID for each item in the list.
  	 */
  	int itemLayoutId;
  
  	/***
  	 * The string id of the "Delete" (L, LL) gesture.
  	 */
  	public int hintDeleteId = R.string.delete;
  	/***
  	 * The string id of the "Delete/Copy/Move" (touchpad L?) gesture.
  	 */
  	public int hintDeleteCopyMoveId = R.string.delete_copy_move;
  	/***
  	 * The string id of the "Delete/Move/Paste" (keyboard L?) gesture.
  	 */
  	public int hintDeleteMovePasteId = R.string.delete_move_paste;
  
  	/***
  	 * Returns the clipboard contents.
  	 * @return the clipboard contents, <code>null</code> if the clipboard is incompatible or empty.
 	 */
 	public TrackListClipboardObject getClipboard() {
 		if (listener == null) {
 			return null;
 		}
 		return TrackListClipboardObject.fromObject(listener.getClipboard());
 	}
 
 	/***
 	 * Invoke to let the listview know that the clipboard was modified.
 	 */
 	public void clipboardChanged() {
 		model.adapter.eopModified();
 	}
 
 	/***
 	 * The model for this listview.
 	 */
 	private ModelHolder model;
 
 	/***
 	 * Returns the model holder.
 	 * 
 	 * @return a holder of live list of item data.
 	 */
 	public ModelHolder getModel() {
 		return model;
 	}
 
 	/***
 	 * Returns current highlight.
 	 * 
 	 * @return current highlight, never <code>null</code>.
 	 */
 	public Interval getHighlight() {
 		return model.getHighlight();
 	}
 
 	/***
 	 * Creates new view.
 	 * 
 	 * @param context
 	 *            the context
 	 * @param itemLayoutId
 	 *            layout ID for each item in the list.
 	 */
 	public GesturesListView(Context context, final int itemLayoutId) {
 		super(context);
 		this.itemLayoutId = itemLayoutId;
 		checkValues();
 		init();
 	}
 
 	/***
 	 * Creates new view.
 	 * 
 	 * @param context
 	 * @param attrs
 	 * @param defStyle
 	 */
 	public GesturesListView(Context context, AttributeSet attrs, int defStyle) {
 		super(context, attrs, defStyle);
 		init(attrs);
 	}
 
 	/***
 	 * Creates new view.
 	 * 
 	 * @param context
 	 * @param attrs
 	 */
 	public GesturesListView(Context context, AttributeSet attrs) {
 		super(context, attrs);
 		init(attrs);
 	}
 
 	/***
 	 * Initializes the view.
 	 * 
 	 * @param attrs
 	 */
 	private void init(AttributeSet attrs) {
 		final TypedArray a = getContext().obtainStyledAttributes(
 				attrs, R.styleable.GesturesListView);
 		itemLayoutId = a.getResourceId(
 				R.styleable.GesturesListView_itemLayoutId, -1);
 		hintDeleteId = a.getResourceId(
 				R.styleable.GesturesListView_hintDeleteId, R.string.delete);
 		hintDeleteCopyMoveId = a.getResourceId(
 				R.styleable.GesturesListView_hintDeleteCopyMoveId,
 				R.string.delete_copy_move);
 		hintDeleteMovePasteId = a.getResourceId(
 				R.styleable.GesturesListView_hintDeleteMovePasteId,
 				R.string.delete_move_paste);
 		checkValues();
 		init();
 	}
 
 	private void checkValues() {
 		if (itemLayoutId < 0) {
 			throw new IllegalArgumentException(
 					"The itemLayoutId attribute missing");
 		}
 	}
 
 	/***
 	 * Initializes the component.
 	 */
 	private void init() {
 		model = new ModelHolder(this);
 		super.setAdapter(model.adapter);
 		super.setOnItemClickListener(new OnItemClickListener() {
 			@SuppressWarnings("unchecked")
 			public void onItemClick(android.widget.AdapterView arg0,
 					android.view.View arg1, int arg2, long arg3) {
 				if (arg2 < 0) {
 					return;
 				}
 				listener.itemActivated(arg2, model.getModel().get(arg2));
 			}
 		});
 		// setup the selection change listener so that the keypad controller
 		// will receive selection-changed events
 		setOnItemSelectedListener(null);
 	}
 
 	@Override
 	protected void onAttachedToWindow() {
 		super.onAttachedToWindow();
 		setSelector(selector);
 	}
 
 	@Override
 	public void setOnItemClickListener(OnItemClickListener l) {
 		Log.w(GesturesListView.class.getSimpleName(),
 				"Trying to set itemclick listener, ignoring");
 	}
 
 	@Override
 	public void setAdapter(ListAdapter adapter) {
 		Log.w(GesturesListView.class.getSimpleName(),
 				"Trying to set custom adapter, ignoring");
 	}
 
 	/***
 	 * If not empty then the LU/LD gestures will drag'n'drop selected items to
 	 * these views. The view is able to drag'n'drop items onto itself - in this
 	 * case the items are moved to new location.
 	 */
 	public final List<GesturesListView> dragDropViews = new ArrayList<GesturesListView>();
 
 	/***
 	 * Checks if the move events (
 	 * {@link IGestureListViewListener#moveItems(Interval, int)} and
 	 * {@link IGestureListViewListener#moveItemsByOne(Interval, boolean)}) can
 	 * be invoked.
 	 * 
 	 * @return <code>true</code> if this list view can drag'n'drop items onto
 	 *         itself, <code>false</code> otherwise.
 	 */
 	public boolean canMove() {
 		return !listener.isReadOnly();
 	}
 
 	/***
 	 * Handles the touchpad events and controls this view.
 	 */
 	final TouchPadController touchController = new TouchPadController(this);
 
 	@Override
 	public boolean onTouchEvent(MotionEvent event) {
 		keyMan.activate(null);
 		final boolean isEventHandled = touchController.onTouchEvent(event);
 		if (isEventHandled) {
 			return true;
 		}
 		return super.onTouchEvent(event);
 	}
 
 	/***
 	 * The keypad manager.
 	 */
 	private final KeypadManager keyMan = new KeypadManager(this);
 	
 	@Override
 	public boolean onKeyDown(int keyCode, KeyEvent event) {
 		return keyMan.onKeyDown(keyCode, event) ? true : super.onKeyDown(
 				keyCode, event);
 	}
 
 	@Override
 	public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
 		return keyMan.onKeyMultiple(keyCode, repeatCount, event) ? true
 				: super.onKeyMultiple(keyCode, repeatCount, event);
 	}
 
 	@Override
 	public boolean onKeyUp(int keyCode, KeyEvent event) {
 		return keyMan.onKeyUp(keyCode, event) ? true : super.onKeyUp(
 				keyCode, event);
 	}
 
 	/***
 	 * The listview selection is drawn by this paint.
 	 */
 	private final Drawable transparent;
 	private final Drawable selector;
 	{
 		transparent = new PaintDrawable(Color.TRANSPARENT);
 		final int cursorColor = getResources()
 				.getColor(R.color.listview_cursor);
 		selector = new PaintDrawable(cursorColor);
 	}
 
 	/***
 	 * Remembers the original selector and sets a transparent (non-visible)
 	 * selector.
 	 */
 	void transparentSelector() {
 		setSelector(transparent);
 	}
 
 	/***
 	 * Restores the original selector.
 	 */
 	void restoreSelector() {
 		setSelector(selector);
 	}
 
 	private final ViewUtils utils = new ViewUtils();
 
 	@Override
 	public int pointToPosition(int x, int y) {
 		// a bug in Android? Sometimes the returned position is over the
 		// .getCount()
 		int result = super.pointToPosition(x, y);
 		final int count = getCount();
 		if (result > count)
 			result = count;
 		if (result == -1) {
 			// we may be pointing onto a thin line under the item
 			// (http://code.google.com/p/android/issues/detail?id=520).
 			// Workaround
 			int indexPrev = super.pointToPosition(x, y - 1);
 			int indexNext = super.pointToPosition(x, y + 1);
 			if (indexPrev + 1 == indexNext) {
 				result = indexPrev;
 			}
 		}
 		return result;
 	}
 
 	/***
 	 * Finds a view from the {@link #dragDropViews registered list of views}
 	 * that contains given point.
 	 * 
 	 * @param point
 	 *            the point in this view's coordinate system
 	 * @return view containing given point or <code>null</code> if no such
 	 *         view exists.
 	 */
 	public GesturesListView findView(final Point point) {
 		if (dragDropViews == null)
 			return null;
 		final Rect viewRect = new Rect();
 		viewRect.left = 0;
 		viewRect.top = 0;
 		for (final GesturesListView view : dragDropViews) {
 			utils.translateCoordinates(point, this, view);
 			if (view.getVisibility() == View.VISIBLE) {
 				viewRect.right = view.getWidth();
 				viewRect.bottom = view.getHeight();
 			} else {
 				// the view may be hidden - this is the case of the playlist
 				// with
 				// zero items. Just pretend that the view contains the point.
 				viewRect.right = Integer.MAX_VALUE;
 				viewRect.bottom = Integer.MAX_VALUE;
 			}
 			if (viewRect.contains(utils.translated.x, utils.translated.y))
 				return view;
 		}
 		return null;
 	}
 
 	/***
 	 * Returns item index the event coordinates is pointing to.
 	 * 
 	 * @param event
 	 *            the event
 	 * @return the item index.
 	 */
 	public int getItemIndex(final MotionEvent event) {
 		final int result = pointToPosition((int) event.getX(), (int) event
 				.getY());
 		return result;
 	}
 
 	/***
 	 * The gesture listener.
 	 */
 	public IGestureListViewListener listener;
 
 	/***
 	 * Shows the mode the listview is currently in.
 	 */
 	private final ContainedPopupWindow viewModeHint = new ContainedPopupWindow(
 			this, new ContainedPopupWindow.IPlaceable() {
 				public int[] getCoordinates(ContainedPopupWindow popup,
 						CharSequence text, final TextView textView) {
 					return new int[] {
 							getWidth()
 									- ViewUtils.intMeasureText(textView
 											.getPaint(), text.toString()) - 10,
 							0 };
 				}
 			});
 
 	/***
 	 * The controller which displayed the {@link #viewModeHint} lastly.
 	 */
 	private Object hintController = null;
 
 	/***
 	 * Sets the tooltip text for the view. Use {@link #clearTooltip(Object)} to
 	 * remove the tooltip.
 	 * 
 	 * @param resId
 	 *            the string to show.
 	 * @param controller
 	 *            callee
 	 * @param persistent
 	 *            if <code>false</code> then the mode hint will disappear
 	 *            automatically after 2 seconds.
 	 * @param params
 	 *            optional formatter parameters.
 	 */
 	public void setTooltip(final int resId, final Object controller,
 			final boolean persistent, final Object... params) {
 		hintController = controller;
 		final SpannableStringBuilder sb = new SpannableStringBuilder(MiscUtils
 				.format(resId, params));
 		Iconify.iconify(getContext(), sb);
 		viewModeHint.setText(sb);
 		if (!persistent) {
 			viewModeHint.dismissAfter(2500);
 		}
 	}
 
 	/***
 	 * Clears the mode and dismisses the window.
 	 * 
 	 * @param controller
 	 *            callee
 	 */
 	public void clearTooltip(final Object controller) {
 		if (hintController != controller) {
 			// prevent a controller to hide hint from another controller.
 			return;
 		}
 		viewModeHint.dismiss();
 	}
 
 	@Override
 	public void setOnItemSelectedListener(OnItemSelectedListener listener) {
 		super.setOnItemSelectedListener(new SelectionChanged(listener));
 	}
 
 	private class SelectionChanged implements OnItemSelectedListener {
 
 		private final OnItemSelectedListener delegate;
 
 		/***
 		 * Creates new event wrapper instance.
 		 * 
 		 * @param delegate
 		 *            the delegate.
 		 */
 		public SelectionChanged(final OnItemSelectedListener delegate) {
 			this.delegate = delegate;
 		}
 
 		public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2,
 				long arg3) {
 			if (delegate != null) {
 				delegate.onItemSelected(arg0, arg1, arg2, arg3);
 			}
 			doSelectionChanged();
 		}
 
 		public void onNothingSelected(AdapterView<?> arg0) {
 			if (delegate != null) {
 				delegate.onNothingSelected(arg0);
 			}
 			doSelectionChanged();
 		}
 
 		private void doSelectionChanged() {
 			AmbientApplication.getHandler().post(new Runnable() {
 				public void run() {
 					keyMan.selectionChanged();
 				}
 			});
 		}
 	}
 
 	@Override
 	protected void onFocusChanged(boolean gainFocus, int direction,
 			Rect previouslyFocusedRect) {
 		if (!gainFocus) {
 			keyMan.activate(null);
 			viewModeHint.dismiss();
 			// we cannot lose highlight - if we lose highlight then we cannot
 			// queue tracks using keypad :)
 			// model.highlight(Interval.EMPTY);
 			// model.notifyModified();
 		} else {
 			// display hint
 			viewModeHint.setText(Iconify.iconify(getContext(), listener
 					.isReadOnly() ? R.string.glv_unmodifiable_hint
 					: R.string.glv_modifiable_hint));
 			viewModeHint.dismissAfter(1000);
 		}
 	}
 
 	/***
 	 * Checks if given item is the EOP item.
 	 * 
 	 * @param position
 	 *            the item index
 	 * @return <code>true</code> if it is EOP, <code>false</code> otherwise.
 	 */
 	public boolean isEOP(final int position) {
 		return model.adapter.isEOP(position);
 	}
 
 	/***
 	 * Zooms or un-zooms the items.
 	 * 
 	 * @param zoom
 	 *            <code>true</code> if zoom the view.
 	 */
 	public void zoom(final int zoom) {
 		model.adapter.zoom(zoom);
 	}
 
 	/***
 	 * Activates the binary search on this list view.
 	 */
 	public void activateDpadSearch() {
 		keyMan.activate(KeypadDpadSearch.class);
 	}
 }