/***
    *     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.Collections;
  import java.util.List;
  
  import sk.baka.ambient.commons.Interval;
  import android.view.View;
  
  /***
   * <p>
   * Manages the model for the {@link GesturesListView}.
   * </p>
   * <p>
   * Handles special End Of Playlist item - this item allows us to insert tracks
   * at the end of the playlist (and into an empty playlist) using keypad
   * gestures. The special item is shown only when the list view:
   * </p>
   * <ul>
   * <li>is modifiable</li>
   * <li>has focus (this property however does not alter the return value of the
   * function, i.e. the function can return <code>true</code> even if the list
   * view does not have focus)</li>
   * <li>is not in the {@link View#isInTouchMode() touch mode}</li>
   * <li>the clipboard is not empty</li>
   * </ul>
   * 
   * @author Martin Vysny
   */
  public final class ModelHolder {
  	/***
  	 * The owner.
  	 */
  	private final GesturesListView owner;
  
  	/***
  	 * Creates new instance.
  	 * 
  	 * @param owner
  	 *            owner listview.
  	 */
  	ModelHolder(final GesturesListView owner) {
  		super();
  		this.owner = owner;
  		// We need to remember this adapter -
  		// we cannot get it simply from the ListView for it will scroll to
  		// the first item (WTF?).
  		adapter = new MutableListAdapter(owner, this);
  	}
  
  	/***
  	 * The backing array of item data. In the MVC terminology, this is a model
  	 * for all items. This list will never contain the EOP object - this object
  	 * is factored by the {@link MutableListAdapter}.
  	 */
  	private final List<Object> model = new ArrayList<Object>();
  
  	/***
  	 * The backing adapter.
  	 */
  	final MutableListAdapter adapter;
  
  	/***
  	 * The model as string representation, converted by invoking
  	 * {@link IGestureListViewListener#toString(Object)}.
  	 */
  	private final ArrayList<String> modelAsString = new ArrayList<String>();
  
  	/***
  	 * <p>
  	 * Returns a list of items. The backing array of item data. In the MVC
  	 * terminology, this is a model for all items. If you plan to modify this
  	 * list, do not forget to call {@link #notifyModified()} after all
  	 * modifications are made.
  	 * </p>
  	 * <p>
  	 * This model must never contain the
  	 * {@link MutableListAdapter#EOP_MODEL_MARKER} object!
  	 * </p>
  	 * 
  	 * @return a live list of item data.
 	 */
 	public List<Object> getModel() {
 		return model;
 	}
 
 	/***
 	 * Returns model as a string representation. Updated automatically when
 	 * {@link #notifyModified()} is invoked. Unmodifiable.
 	 * 
 	 * @return list representation of each item in a model, converted by
 	 *         invoking {@link IGestureListViewListener#toString(Object)}.
 	 */
 	public List<String> getModelAsString() {
 		return Collections.unmodifiableList(modelAsString);
 	}
 	
 	/***
 	 * Redraws items and reflects changes made to the {@link #getModel()} list.
 	 */
 	public void notifyModified() {
 		// recompute the string model
 		modelAsString.clear();
 		modelAsString.ensureCapacity(model.size());
 		for (final Object modelItem : model) {
 			if (modelItem instanceof String) {
 				modelAsString.add(((String) modelItem).toLowerCase());
 			} else {
 				modelAsString.add(owner.listener.toString(modelItem)
 						.toLowerCase());
 			}
 		}
 		adapter.notifyModified();
 	}
 
 	/***
 	 * These items are highlighted.
 	 */
 	private Interval highlight = Interval.EMPTY;
 
 	/***
 	 * Highlight given items. Does not update the view - you need to call
 	 * {@link #notifyModified()} to force the redraw.
 	 * 
 	 * @param highlight
 	 *            items to highlight. May be <code>null</code> - equal to an
 	 *            empty interval.
 	 */
 	public void highlight(final Interval highlight) {
 		Interval newHighlight = highlight == null ? Interval.EMPTY : highlight;
 		if (newHighlight.end >= model.size()) {
 			newHighlight = new Interval(newHighlight.start, model.size());
 		}
 		if (newHighlight.equals(this.highlight)) {
 			return;
 		}
 		this.highlight = newHighlight;
 		owner.listener.highlightChanged(this.highlight);
 	}
 
 	/***
 	 * Returns current highlight.
 	 * 
 	 * @return current highlight, never <code>null</code>.
 	 */
 	public Interval getHighlight() {
 		return highlight;
 	}
 
 	/***
 	 * Returns current highlight. If no items are highlighted, optionally return
 	 * current selection.
 	 * 
 	 * @param returnSelectionOnEmptyHighlight
 	 *            if <code>true</code> and no items are currently being
 	 *            highlighted, return current selection.
 	 * 
 	 * @return current highlight, never <code>null</code>.
 	 */
 	public Interval getHighlight(final boolean returnSelectionOnEmptyHighlight) {
 		if (highlight.isEmpty() && returnSelectionOnEmptyHighlight) {
 			final int sel = owner.getSelectedItemPosition();
 			return (sel < 0) || (sel >= model.size()) ? Interval.EMPTY
 					: Interval.fromItem(sel);
 		}
 		return getHighlight();
 	}
 
 	/***
 	 * Returns current highlight. If no items are highlighted, optionally return
 	 * given item.
 	 * 
 	 * @param returnSelectionOnEmptyHighlight
 	 *            if not negative and no items are currently being highlighted,
 	 *            return selection consisting of a single item.
 	 * 
 	 * @return current highlight, never <code>null</code>.
 	 */
 	public Interval getHighlight(final int returnSelectionOnEmptyHighlight) {
 		if (highlight.isEmpty() && (returnSelectionOnEmptyHighlight >= 0)
 				&& (returnSelectionOnEmptyHighlight < model.size())) {
 			return Interval.fromItem(returnSelectionOnEmptyHighlight);
 		}
 		return getHighlight();
 	}
 
 	/***
 	 * Returns interval containing all items.
 	 * 
 	 * @return non-<code>null</code> interval.
 	 */
 	public Interval getAllItems() {
 		return new Interval(0, model.size());
 	}
 }