/***
    *     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.activity.main;
  
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.List;
  
  import sk.baka.ambient.ConfigurationBean;
  import sk.baka.ambient.I18n;
  import sk.baka.ambient.IApplicationListener;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.TagFormatter;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  import sk.baka.ambient.views.gesturelist.MutableListAdapter;
  import android.app.Activity;
  import android.graphics.Typeface;
  import android.text.SpannableStringBuilder;
  import android.text.Spanned;
  import android.text.style.StyleSpan;
  import android.view.View;
  import android.widget.ImageView;
  import android.widget.TextView;
  
  /***
   * Groups functionality for a controller managing a playlist.
   * 
   * @author Martin Vysny
   */
  public abstract class AbstractPlaylistController extends AbstractListController
  		implements IApplicationListener {
  	/***
  	 * The playlist view id.
  	 */
  	public static final int PLAYLIST_VIEW_ID = android.R.id.list;
  
  	/***
  	 * <p>
  	 * Creates new controller.
  	 * </p>
  	 * <p>
  	 * The contract: the extending class MUST invoke the {@link #initialize()}
  	 * after it is done initializing.
  	 * </p>
  	 * 
  	 * @param mainViewId
  	 *            the view whose visibility is controlled.
  	 * @param listViewId
  	 *            the id of the {@link GesturesListView}
  	 * @param mainActivity
  	 */
  	public AbstractPlaylistController(final int mainViewId, int listViewId,
  			Activity mainActivity) {
  		super(mainViewId, listViewId, mainActivity);
  		try {
  			formatter = new TagFormatter(
  					app.getStateHandler().getConfig().playlistFormat);
  		} catch (ParseException e) {
  			throw new RuntimeException(e);
  		}
  		listView.dragDropViews.clear();
  		listView.dragDropViews.add(listView);
  		model = listView.getModel().getModel();
  	}
  
  	/***
  	 * Overriding classes must invoke this method at the end of their
  	 * constructors.
  	 */
  	protected final void initialize() {
  		update(Interval.EMPTY);
  	}
  
  	/***
  	 * The contract: when overriding this method, be sure to call this super
  	 * method after you are done deleting items. The adapter must be
  	 * invalidated, to prevent drawing old data.
  	 * 
  	 * @param remove
  	 *            the interval to remove
  	 */
  	@Override
 	public void removeItems(Interval remove) {
 		update(Interval.EMPTY);
 	}
 
 	/***
 	 * Formats playlist items.
 	 */
 	private TagFormatter formatter;
 
 	/***
 	 * The model, containing Strings - formatted track names.
 	 */
 	private final List<Object> model;
 
 	/***
 	 * Retrieves a track from given position.
 	 * 
 	 * @param index
 	 *            the index
 	 * @return the track instance, never <code>null</code>.
 	 */
 	protected abstract TrackMetadataBean getTrack(final int index);
 
 	@Override
 	protected void recomputeListItems() {
 		final boolean nullEqualFields = app.getStateHandler().getConfig().dontRepeatSameTag;
 		model.clear();
 		final int playlistSize = getPlaylistSize();
 		for (int i = 0; i < playlistSize; i++) {
 			final TrackMetadataBean row = getTrack(i);
 			final TrackMetadataBean prevRow = i == 0 ? TrackMetadataBean.EMPTY
 					: getTrack(i - 1);
 			final TrackMetadataBean diff = nullEqualFields ? row
 					.nullsEqualFields(prevRow, true) : row;
 			final String track = formatter.format(diff);
 			model.add(track);
 		}
 	}
 
 	/***
 	 * Returns the underlying playlist size.
 	 * 
 	 * @return the playlist size.
 	 */
 	protected abstract int getPlaylistSize();
 
 	private final int currentTrackColor = mainActivity.getResources().getColor(
 			R.color.playlist_currenttrack);
 
 	private final int currentHighlightedColor = mainActivity.getResources()
 			.getColor(R.color.currenttrack_highlight);
 
 	private final int textColor = mainActivity.getResources().getColor(
 			R.color.textcolor);
 
 	private final int textTranslucentColor = mainActivity.getResources()
 			.getColor(R.color.texttranslucent);
 
 	private final int historyTrackColor = mainActivity.getResources().getColor(
 			R.color.dynamicplaylist_history);
 	
 	private final String eop = mainActivity.getString(R.string.eop);
 
 	private final String playlistEmpty = mainActivity
 			.getString(R.string.playlist_empty);
 
 	public final void update(GesturesListView listView, View itemView,
 			int index, Object model) {
 		final boolean isEOP = model == MutableListAdapter.EOP_MODEL_MARKER;
 		final boolean currentlyPlayed = isEOP ? false
 				: isCurrentlyPlayedTrack(index);
 		final boolean isHistoryTrack = isEOP ? false : isHistoryTrack(index);
 		if (isEOP) {
 			itemView.setBackgroundColor(0);
 		} else {
 			// draw selections
 			final boolean highlighted = listView.getHighlight().contains(index);
 			final int bgColor;
 			if (currentlyPlayed && highlighted) {
 				bgColor = currentHighlightedColor;
 			} else if (currentlyPlayed) {
 				bgColor = currentTrackColor;
 			} else if (highlighted) {
 				bgColor = highlightColor;
 			} else {
 				bgColor = 0;
 			}
 			itemView.setBackgroundColor(bgColor);
 		}
 		// draw the track meta info
 		final TextView text = (TextView) itemView
 				.findViewById(R.id.playlist_item_text);
 		final String caption;
 		if (isEOP) {
 			caption = listView.getCount() > 1 ? eop : playlistEmpty;
 		} else {
 			caption = (String) model;
 		}
 		if (currentlyPlayed) {
 			final SpannableStringBuilder b = new SpannableStringBuilder(caption);
 			b.setSpan(new StyleSpan(Typeface.ITALIC), 0, caption.length(),
 					Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 			text.setText(b);
 		} else {
 			text.setText(caption);
 		}
 		text.setTextColor(isEOP ? textTranslucentColor
 				: isHistoryTrack ? historyTrackColor : textColor);
 		// update the queue info
 		final int queue = isEOP ? 0 : getQueueNumber(index);
 		final TextView queueView = (TextView) itemView
 				.findViewById(R.id.playlist_item_queue);
 		queueView.setVisibility(queue == 0 ? View.GONE : View.VISIBLE);
 		if (queue != 0) {
 			queueView.setText(String.valueOf(queue));
 		}
 		// update the track icon
 		final ImageView trackIcon = (ImageView) itemView
 				.findViewById(R.id.playlist_item_trackicon);
 		final TrackMetadataBean track = isEOP ? null : getTrack(index);
 		if (isEOP || track.isLocal()) {
 			trackIcon.setVisibility(View.GONE);
 		} else {
 			trackIcon.setVisibility(View.VISIBLE);
 			switch (track.getOrigin()) {
 			case Magnatune:
 				trackIcon.setImageResource(R.drawable.trackicon_magnatune);
 				break;
 			case Shoutcast:
 				trackIcon.setImageResource(R.drawable.trackicon_shoutcast);
 				break;
 			case SkreemR:
 			case Ampache:
 				trackIcon.setImageResource(R.drawable.trackicon_http);
 				break;
 			case LocalFs:
 				// should be handled
 			}
 		}
 	}
 
 	/***
 	 * Checks if this track is a track from a dynamic playlist history.
 	 * 
 	 * @param index
 	 *            the track index.
 	 * @return <code>true</code> if history track, <code>false</code> otherwise.
 	 */
 	protected abstract boolean isHistoryTrack(int index);
 
 	/***
 	 * Returns queue status of given track.
 	 * 
 	 * @param index
 	 *            the track index
 	 * @return queue number or 0 if the track is not queued.
 	 */
 	protected abstract int getQueueNumber(int index);
 
 	/***
 	 * Checks if the track at given index is currently being played.
 	 * 
 	 * @param index
 	 *            the track index
 	 * @return <code>true</code> if it is being played, <code>false</code>
 	 *         otherwise.
 	 */
 	protected abstract boolean isCurrentlyPlayedTrack(int index);
 
 	@Override
 	public final boolean canComputeItems() {
 		return true;
 	}
 
 	@Override
 	public boolean isComputeTracksLong(Interval interval) {
 		return false;
 	}
 
 	@Override
 	public boolean isComputeTracksOnlineOp(Interval interval) {
 		return false;
 	}
 
 	@Override
 	public boolean isReadOnly() {
 		return false;
 	}
 
 	public void configChanged(ConfigurationBean config) {
 		try {
 			formatter = new TagFormatter(
 					app.getStateHandler().getConfig().playlistFormat);
 		} catch (ParseException e) {
 			throw new RuntimeException(e);
 		}
 		update(null);
 	}
 
 	@Override
 	public List<TrackMetadataBean> computeTracks(Interval highlight) {
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>(
 				highlight.length);
 		for (int i = highlight.start; i <= highlight.end; i++) {
 			result.add(getTrack(i));
 		}
 		return result;
 	}
 
 	public void clipboardChanged() {
 		listView.clipboardChanged();
 	}
 
 	public void offline(boolean offline) {
 		// by default do nothing
 	}
 
 	@Override
 	public String getHint(Interval highlight) {
 		return I18n.format(I18n.newTracks(highlight.length));
 	}
 
 	public String toString(Object model) {
 		// should not be called as a list of strings is shown.
 		throw new Error();
 	}
 }