/***
    *     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.cb;
  
  import java.util.ArrayList;
  import java.util.Formattable;
  import java.util.List;
  import java.util.concurrent.Callable;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.I18n;
  import sk.baka.ambient.R;
  import sk.baka.ambient.activity.main.AbstractListController;
  import sk.baka.ambient.collection.CategoryEnum;
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.library.ILibraryListener;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  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.TextView;
  
  /***
   * <p>
   * Controller which displays a collection browser on given list view and allows
   * user to navigate it using gestures.
   * </p>
   * <p>
   * The controller listens on two actions:
   * </p>
   * <li>
   * <ul>
   * {@link ActionsEnum#Back} - go back in the menu hierarchy
   * </ul>
   * <ul>
   * {@link ActionsEnum#CollectionYear} to switch year being displayed
   * </ul>
   * </li>
   * 
   * @author Martin Vysny
   */
  public abstract class AbstractCollectionController extends
  		AbstractListController implements ILibraryListener {
  
  	/***
  	 * The collection to display the data from.
  	 */
  	protected final ICollection collection;
  
  	/***
  	 * the ID of {@link TextView} which will display current category path.
  	 */
  	private final int categoryPathId;
  
  	/***
  	 * Creates new controller instance. Subclasses should invoke
  	 * {@link #updateData()} in the constructor to update the display.
  	 * 
  	 * @param mainViewId
  	 *            the view whose visibility is controlled.
  	 * @param listViewId
  	 *            the id of the {@link GesturesListView}
  	 * @param mainActivity
  	 *            the main activity instance.
  	 * @param playlistView
  	 *            the playlist view - target of drag'n'drop operations.
  	 * @param collection
  	 *            the collection to display the data from.
  	 * @param categoryPathId
  	 *            the ID of {@link TextView} which will display current category
  	 *            path.
  	 */
  	public AbstractCollectionController(final int mainViewId, int listViewId,
  			Activity mainActivity, final GesturesListView playlistView,
  			final ICollection collection, final int categoryPathId) {
  		super(mainViewId, listViewId, mainActivity);
  		this.collection = collection;
 		this.categoryPathId = categoryPathId;
 		// register the drag'n'drop target.
 		listView.dragDropViews.clear();
 		listView.dragDropViews.add(playlistView);
 		reset();
 	}
 
 	@Override
 	public void destroy() {
 		for (final IContentManager man : managerChain) {
 			man.uninitialize();
 		}
 		managerChain.clear();
 		listView.dragDropViews.clear();
 		super.destroy();
 	}
 
 	/***
 	 * Resets the controller and shows the first manager, the
 	 * {@link GroupingManager}.
 	 */
 	protected final void reset() {
 		for (final IContentManager man : managerChain) {
 			man.uninitialize();
 		}
 		managerChain.clear();
 		final GroupingManager initialManager = new GroupingManager();
 		initialManager.initialize(false, collection);
 		manager = initialManager;
 		managerChain.add(manager);
 		updateData();
 	}
 
 	private volatile IContentManager manager;
 
 	private final List<IContentManager> managerChain = new ArrayList<IContentManager>();
 
 	@Override
 	public final boolean canHighlight() {
 		return manager.canReturnTracks();
 	}
 
 	public void itemActivated(final int index, final Object model) {
 		activateItem(index);
 	}
 
 	/***
 	 * If <code>true</code> then we cannot fetch new data, change manager etc.
 	 */
 	private volatile boolean fetchingData = false;
 
 	private void activateItem(int index) {
 		if (fetchingData) {
 			return;
 		}
 		final IContentManager newManager = manager.itemActivated(index);
 		if (newManager == null) {
 			return;
 		}
 		fetchData(newManager, 1);
 	}
 
 	/***
 	 * Fetches new data asynchronously. When the data is ready the listview is
 	 * updated.
 	 * 
 	 * @param newManager
 	 *            replace current manager with this one.
 	 * @param direction
 	 *            if -1 then going back. If 1 then going forward. If 0 then
 	 *            refreshing current manager.
 	 */
 	private void fetchData(final IContentManager newManager, final int direction) {
 		if (fetchingData) {
 			throw new IllegalStateException();
 		}
 		fetchingData = true;
 		final Callable<Void> fetcher = new Callable<Void>() {
 			public Void call() throws Exception {
 				try {
 					final boolean changed = newManager.initialize(year,
 							collection);
 					if (!changed) {
 						fetchingData = false;
 						return null;
 					}
 					if (Thread.currentThread().isInterrupted()) {
 						throw new InterruptedException();
 					}
 					final Runnable updater = new Runnable() {
 						public void run() {
 							if (manager != newManager) {
 								manager.uninitialize();
 								manager = newManager;
 							}
 							int prevIndex = -1;
 							if (direction > 0) {
 								managerChain.add(manager);
 							} else if (direction < 0) {
 								managerChain.remove(managerChain.size() - 1);
 								prevIndex = manager
 										.getIndexOfPreviouslyActivatedItem(managerChain
 												.get(managerChain.size() - 1));
 								managerChain.set(managerChain.size() - 1,
 										manager);
 							}
 							updateData();
 							if (prevIndex >= 0) {
 								listView.setSelection(prevIndex);
 							}
 							fetchingData = false;
 						}
 					};
 					AmbientApplication.getHandler().post(updater);
 				} catch (Exception ex) {
 					fetchingData = false;
 					throw ex;
 				}
 				return null;
 			}
 		};
 		final String caption = collection.getName() + ": "
 				+ app.getString(R.string.gettingData);
 		final boolean accepted = (app.getBackgroundTasks().schedule(fetcher,
 				getClass(), !collection.isLocal(), caption) != null);
 		if (!accepted) {
 			fetchingData = false;
 			return;
 		}
 	}
 
 	@Override
 	public void removeItems(Interval remove) {
 		goBack();
 	}
 
 	private void goBack() {
 		if (fetchingData) {
 			return;
 		}
 		final IContentManager newManager = manager.goBack();
 		if (newManager == null) {
 			return;
 		}
 		fetchData(newManager, -1);
 	}
 
 	/***
 	 * Updates the data which is currently being shown.
 	 */
 	protected final void refetchData() {
 		fetchData(manager, 0);
 	}
 
 	@Override
 	protected void onAction(ActionsEnum action) {
 		if (action == ActionsEnum.Back) {
 			goBack();
 			return;
 		}
 		if (action == ActionsEnum.CollectionYear) {
 			if (!fetchingData) {
 				year = !year;
 				yearChanged(year);
 				refetchData();
 			}
 		}
 		super.onAction(action);
 	}
 
 	/***
 	 * Notifies the subclass that the {@link #year} field was changed. By
 	 * default does nothing.
 	 * 
 	 * @param year
 	 *            the year value.
 	 */
 	protected void yearChanged(boolean year) {
 	}
 
 	/***
 	 * Returns displayable name of the current category.
 	 * 
 	 * @return displayable name.
 	 */
 	private CharSequence getPathName() {
 		final SpannableStringBuilder b = new SpannableStringBuilder();
 		if (managerChain.size() <= 1) {
 			b.append(managerChain.get(0).getSelectedItemName());
 			b.setSpan(new StyleSpan(Typeface.ITALIC), 0, b.length(),
 					Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 			return b;
 		}
 		boolean isFirst = true;
 		for (int i = 1; i < managerChain.size(); i++) {
 			if (isFirst) {
 				isFirst = false;
 			} else {
 				b.append('/');
 			}
 			final String manItem = managerChain.get(i).getSelectedItemName();
 			b.append(manItem);
 			final boolean lastMan = i == managerChain.size() - 1;
 			if (lastMan) {
 				b.setSpan(new StyleSpan(Typeface.ITALIC), b.length()
 						- manItem.length(), b.length(),
 						Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 			}
 		}
 		return b;
 	}
 
 	/***
 	 * Show year besides the album name?
 	 */
 	private volatile boolean year = false;
 
 	@Override
 	protected final void recomputeListItems() {
 		final List<Object> model = listView.getModel().getModel();
 		model.clear();
 		model.addAll(manager.getDisplayableContent());
 	}
 
 	public void update(GesturesListView listView, View itemView, int index,
 			Object model) {
 		final TextView view = (TextView) itemView;
 		if (listView.getHighlight().contains(index)) {
 			view.setBackgroundColor(highlightColor);
 		} else {
 			view.setBackgroundColor(0);
 		}
 		view.setText((String) model);
 	}
 
 	/***
 	 * Updates data shown in the controller.
 	 */
 	protected final void updateData() {
 		update(Interval.EMPTY);
 		final TextView text = (TextView) mainActivity
 				.findViewById(categoryPathId);
 		text.setText(getPathName());
 	}
 
 	@Override
 	public final List<TrackMetadataBean> computeTracks(Interval highlight) {
 		try {
 			return manager.getTracks(highlight);
 		} catch (final Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	@Override
 	public final boolean isComputeTracksLong(Interval interval) {
 		if (manager instanceof TrackManager) {
 			return false;
 		}
 		return !interval.isEmpty();
 	}
 
 	/***
 	 * Checks if the controller is currently showing a track list.
 	 * 
 	 * @return <code>true</code> if yes, <code>false</code> if it shows a
 	 *         category list.
 	 */
 	protected final boolean isShowingTracks() {
 		return manager instanceof TrackManager;
 	}
 
 	@Override
 	public boolean isComputeTracksOnlineOp(Interval interval) {
 		return !collection.isLocal();
 	}
 
 	@Override
 	public String getHint(Interval highlight) {
 		final Formattable f;
 		if (manager instanceof TrackManager) {
 			f = I18n.newTracks(highlight.length);
 		} else if (manager instanceof CategoryManager) {
 			final CategoryEnum cat = ((CategoryManager) manager).getCurrent();
 			switch (cat) {
 			case Album:
 				f = I18n.newAlbums(highlight.length);
 				break;
 			case Artist:
 				f = I18n.newArtists(highlight.length);
 				break;
 			case Genre:
 				f = I18n.newGenres(highlight.length);
 				break;
 			case Title:
 				f = I18n.newTracks(highlight.length);
 				break;
 			default:
 				throw new IllegalStateException();
 			}
 		} else {
 			throw new IllegalStateException();
 		}
 		return I18n.format(f);
 	}
 
 	@Override
 	public final boolean isReadOnly() {
 		return true;
 	}
 
 	@Override
 	public final boolean canComputeItems() {
 		return !(manager instanceof GroupingManager);
 	}
 
 	public void libraryUpdate(boolean updateStarted, boolean interrupted,
 			boolean userNotified) {
 		if (!updateStarted) {
 			updateData();
 		}
 	}
 
 	public String toString(Object model) {
 		// should not be called as strings are shown
 		throw new Error();
 	}
 
 	/***
 	 * Returns current content manager. Subclasses must not modify the manager.
 	 * 
 	 * @return non-<code>null</code> manager.
 	 */
 	protected final IContentManager getCurrentManager() {
 		return manager;
 	}
 }