/***
    *     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.Arrays;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.CategoryEnum;
  import sk.baka.ambient.collection.CategoryItem;
  import sk.baka.ambient.collection.CollectionException;
  import sk.baka.ambient.collection.CollectionUtils;
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  
  /***
   * Performs the criteria selection.
   * 
   * @author Martin Vysny
   */
  final class CategoryManager implements IContentManager {
  	/***
  	 * Browse through these categories. First item in the list is the category
  	 * currently being browsed.
  	 */
  	private final List<CategoryEnum> categoriesToShow;
  
  	/***
  	 * The parent category to display the data from. May be <code>null</code>
  	 * if no category item has yet been selected.
  	 */
  	private final CategoryItem parent;
  
  	/***
  	 * Previous category manager. If <code>null</code> then
  	 * {@link GroupingManager} is the previous one.
  	 */
  	private final CategoryManager previous;
  
  	/***
  	 * Creates new manager.
  	 * 
  	 * @param categories
  	 *            browse through these categories.
  	 */
  	CategoryManager(final CategoryEnum[] categories) {
  		super();
  		this.categoriesToShow = Arrays.asList(categories);
  		previous = null;
  		parent = null;
  	}
  
  	/***
  	 * Creates new manager.
  	 * 
  	 * @param previous
  	 *            Previous category manager. If <code>null</code> then
  	 *            {@link GroupingManager} is the previous one.
  	 * @param parent
  	 *            The parent category to display the data from. May be
  	 *            <code>null</code> if no category item has yet been selected.
  	 * @param categoriesToShow
  	 *            Browse through these categories. First item in the list is the
  	 *            category currently being browsed.
  	 */
  	private CategoryManager(final CategoryManager previous,
  			final CategoryItem parent, final List<CategoryEnum> categoriesToShow) {
  		super();
  		this.categoriesToShow = categoriesToShow;
  		this.previous = previous;
  		this.parent = parent;
  	}
  
  	public boolean canReturnTracks() {
  		return true;
  	}
 
 	public List<String> getDisplayableContent() {
 		return displayableCategoriesShown;
 	}
 
 	/***
 	 * The manager is currently showing these categories.
 	 */
 	private volatile List<CategoryItem> categoriesShown;
 
 	/***
 	 * The manager is currently showing these categories.
 	 */
 	private volatile List<String> displayableCategoriesShown;
 
 	public List<TrackMetadataBean> getTracks(Interval highlight)
 			throws CollectionException, InterruptedException {
 		// if multiple genres are selected, we may need to filter out
 		// multiple track instances
 		final Set<TrackMetadataBean> presentTracks = new HashSet<TrackMetadataBean>();
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 		final List<CategoryItem> categories = categoriesShown.subList(
 				highlight.start, highlight.end + 1);
 		for (final CategoryItem ci : categories) {
 			if (Thread.currentThread().isInterrupted()) {
 				return null;
 			}
 			final List<TrackMetadataBean> tracks = collection.getTracks(ci);
 			tracks.removeAll(presentTracks);
 			presentTracks.addAll(tracks);
 			result.addAll(tracks);
 		}
 		CollectionUtils.sortByAlbumOrder(result);
 		return result;
 	}
 
 	public void uninitialize() {
 		categoriesShown = null;
 		displayableCategoriesShown = null;
 	}
 
 	public IContentManager goBack() {
 		if (previous != null) {
 			return previous;
 		}
 		return new GroupingManager();
 	}
 
 	private volatile ICollection collection;
 
 	private volatile boolean isYear = false;
 
 	public boolean initialize(boolean isYear, final ICollection collection)
 			throws CollectionException, InterruptedException {
 		previouslyActivated = null;
 		if ((categoriesShown != null) && (getCurrent() != CategoryEnum.Album)) {
 			return false;
 		}
 		this.isYear = isYear;
 		this.collection = collection;
 		final List<CategoryItem> list = collection.getCategoryList(
 				getCurrent(), parent, null, isYear);
 		categoriesShown = new CopyOnWriteArrayList<CategoryItem>(list);
 		final boolean albumYear = isYear
 				&& (getCurrent() == CategoryEnum.Album);
 		final List<String> displayableList = new ArrayList<String>();
 		for (final CategoryItem item : list) {
 			final String caption = albumYear ? item.getDisplayableYear() + "-"
 					+ item.getDisplayableName() : item.getDisplayableName();
 			displayableList.add(caption);
 		}
 		displayableCategoriesShown = Collections
 				.unmodifiableList(new CopyOnWriteArrayList<String>(
 						displayableList));
 		return true;
 	}
 
 	private CategoryItem previouslyActivated;
 
 	public IContentManager itemActivated(int i) {
 		previouslyActivated = categoriesShown.get(i);
 		if (categoriesToShow.size() > 1) {
 			final CategoryManager clone = new CategoryManager(previous, parent,
 					categoriesToShow);
 			return new CategoryManager(clone, previouslyActivated,
 					categoriesToShow.subList(1, categoriesToShow.size()));
 		}
 		return new TrackManager(this, previouslyActivated);
 	}
 
 	/***
 	 * Returns currently shown category.
 	 * 
 	 * @return the category being currently shown.
 	 */
 	public CategoryEnum getCurrent() {
 		return categoriesToShow.get(0);
 	}
 
 	public int getIndexOfPreviouslyActivatedItem(IContentManager contentManager) {
 		final CategoryItem prev = ((CategoryManager) contentManager).previouslyActivated;
 		return categoriesShown.indexOf(prev);
 	}
 
 	public String getSelectedItemName() {
 		if (previouslyActivated != null) {
 			return previouslyActivated.getDisplayableName();
 		}
 		final CategoryEnum cat = getCurrent();
 		final StringBuilder builder = new StringBuilder();
 		if ((cat == CategoryEnum.Album) && isYear) {
 			builder.append(AmbientApplication.getInstance().getString(
 					R.string.year));
 			builder.append('-');
 		}
 		builder.append(AmbientApplication.getInstance().getString(
 				cat.displayableNameId));
 		return builder.toString();
 	}
 }