package sk.baka.ambient.collection.sync;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.List;
   import java.util.Map;
   import java.util.concurrent.Callable;
  
  import android.content.Context;
  import android.media.MediaScannerConnection;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.IBackgroundTask;
  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.ICollection;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.IOUtils;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.commons.TagFormatter;
  
  /***
   * Downloads tracks from given collection which are missing in the reference
   * collection. All work is done in the {@link #call()} method.
   * 
   * @author mvy
   */
  public class CollectionSynchronizer implements Callable<Void> {
  	/***
  	 * Download excess tracks from this collection.
  	 */
  	private final ICollection downloadFrom;
  	/***
  	 * This is the reference collection, i.e. tracks which are not to be
  	 * synchronized.
  	 */
  	private final ICollection reference;
  	/***
  	 * This path is automatically prepended to paths produced by the
  	 * <code>pathFormatter</code> formatter.
  	 */
  	private final String rootPath;
  	private final IBackgroundTask task;
  	private final SyncUtils utils;
  	private final MediaScannerConnection msc;
  
  	/***
  	 * Creates new synchronizer.
  	 * 
  	 * @param context
  	 *            owner's context.
  	 * @param reference
  	 *            This is the reference collection, i.e. tracks which are not to
  	 *            be synchronized.
  	 * @param downloadFrom
  	 *            Download excess tracks from this collection.
  	 * @param pathFormatter
  	 *            produces a relative path where the music file should be
  	 *            stored. Must produce valid paths! Paths are created
  	 *            automatically.
  	 * @param rootPath
  	 *            this path is automatically prepended to paths produced by the
  	 *            <code>pathFormatter</code> formatter.
  	 * @param task
  	 *            used for progress reporting, may be <code>null</code>.
  	 */
  	public CollectionSynchronizer(final Context context,
  			final ICollection reference, final ICollection downloadFrom,
  			final TagFormatter pathFormatter, final String rootPath,
  			final IBackgroundTask task) {
  		this.reference = reference;
  		this.downloadFrom = downloadFrom;
  		this.task = task;
  		this.rootPath = IOUtils.removeTrailingSlash(rootPath);
  		this.msc = new MediaScannerConnection(context, null);
  		this.utils = new SyncUtils(reference, downloadFrom, pathFormatter, msc);
  	}
  
  	private Collection<? extends TrackMetadataBean> tracksToDownload = null;
  
  	/***
  	 * Sets the synchronizer to download these tracks, instead of performing a
  	 * full synchronization.
  	 * 
  	 * @param tracks
  	 *            the tracks to download.
  	 */
  	public void setTracksToDownload(
  			final Collection<? extends TrackMetadataBean> tracks) {
  		if (tracksToDownload.isEmpty()) {
  			throw new IllegalArgumentException("items must not be empty");
  		}
  		tracksToDownload = tracks;
  		items = null;
  	}
 
 	private Collection<? extends CategoryItem> items;
 
 	/***
 	 * Sets the synchronizer to download tracks from these categories, instead
 	 * of performing a full synchronization.
 	 * 
 	 * @param items
 	 *            the items to download.
 	 */
 	public void setCategoriesToDownload(
 			final Collection<? extends CategoryItem> items) {
 		if (items.isEmpty()) {
 			throw new IllegalArgumentException("items must not be empty");
 		}
 		this.items = items;
 		tracksToDownload = null;
 	}
 
 	/***
 	 * Configures the synchronizer to download entire collection (the default).
 	 */
 	public void downloadEntireCollection() {
 		items = null;
 		tracksToDownload = null;
 	}
 
 	public Void call() throws Exception {
 		msc.connect();
 		try {
 			if (tracksToDownload != null) {
 				downloadTracks(tracksToDownload);
 				return null;
 			}
 			// these albums are to be downloaded. Maps to CategoryItem from the
 			// "downloadFrom" collection. Key is the album name.
 			final Map<String, CategoryItem> toSynchronize = new HashMap<String, CategoryItem>();
 			// a subset of the "toSynchronize" map, containing albums which
 			// already are partially present. Maps to CategoryItem from the
 			// "reference" collection. Key is the album name.
 			final Map<String, CategoryItem> missingTracks = new HashMap<String, CategoryItem>();
 			// get the list of albums to synchronize
 			final Collection<? extends CategoryItem> albums = getAlbums();
 			fetchAlbumsToSynchronize(albums, toSynchronize, missingTracks);
 			synchronize(toSynchronize, missingTracks);
 			return null;
 		} finally {
 			msc.disconnect();
 		}
 	}
 
 	private Collection<? extends CategoryItem> getAlbums()
 			throws CollectionException, InterruptedException {
 		if (items == null) {
 			return downloadFrom.getCategoryList(CategoryEnum.Album, null, null,
 					false);
 		}
 		// convert the "items" category list to a list of albums
 		final CategoryEnum itemsType = getCategoryType(items);
 		if (itemsType == CategoryEnum.Album) {
 			return items;
 		}
 		final List<CategoryItem> result = new ArrayList<CategoryItem>();
 		for (final CategoryItem item : items) {
 			final List<CategoryItem> albums = downloadFrom.getCategoryList(
 					CategoryEnum.Album, item, null, false);
 			result.addAll(albums);
 		}
 		return result;
 	}
 
 	private CategoryEnum getCategoryType(
 			final Collection<? extends CategoryItem> items) {
 		return items.iterator().next().category;
 	}
 
 	private void synchronize(final Map<String, CategoryItem> toSynchronize,
 			final Map<String, CategoryItem> missingTracks) throws Exception {
 		int synchronizedAlbums = 0;
 		final int maxProgress = 1 + toSynchronize.size();
 		for (final Map.Entry<String, CategoryItem> album : toSynchronize
 				.entrySet()) {
 			if (task != null) {
 				final String progressName = MiscUtils.format(
 						R.string.downloadingAlbum, album.getKey());
 				task.backgroundTask(0, progressName, ++synchronizedAlbums,
 						maxProgress);
 			}
 			final boolean downloadPartly = missingTracks.containsKey(album
 					.getKey());
 			final List<TrackMetadataBean> tracksToDownload = downloadFrom
 					.getTracks(album.getValue());
 			if (downloadPartly) {
 				final List<TrackMetadataBean> localTracks = reference
 						.getTracks(missingTracks.get(album.getKey()));
 				SyncUtils.removeLocalTracks(tracksToDownload, localTracks);
 			}
 			downloadTracks(tracksToDownload);
 		}
 	}
 
 	private void downloadTracks(
 			Collection<? extends TrackMetadataBean> tracksToDownload)
 			throws Exception {
 		for (final TrackMetadataBean track : tracksToDownload) {
 			try {
 				utils.downloadTrack(rootPath, track);
 			} catch (final Exception ex) {
 				if (Thread.currentThread().isInterrupted()) {
 					throw ex;
 				}
 				final String errorMsg = MiscUtils.format(
 						R.string.failedToDownload, track.getDisplayableName(),
 						ex.getMessage());
 				AmbientApplication.getInstance().error(
 						CollectionSynchronizer.class, true, errorMsg, ex);
 			}
 		}
 	}
 
 	/***
 	 * Fetches albums to be synchronized.
 	 * 
 	 * @param toSynchronize
 	 *            these albums are to be downloaded. Maps to
 	 *            {@link CategoryItem} from {@link #downloadFrom}. Key is the
 	 *            album name.
 	 * @param missingTracks
 	 *            a subset of <code>toSynchronize</code>, contains albums which
 	 *            already are partially present. Maps to {@link CategoryItem}
 	 *            from {@link #reference}. Key is the album name.
 	 * @throws InterruptedException
 	 * @throws CollectionException
 	 */
 	private void fetchAlbumsToSynchronize(
 			final Collection<? extends CategoryItem> remoteAlbumsToDownload,
 			Map<String, CategoryItem> toSynchronize,
 			Map<String, CategoryItem> missingTracks)
 			throws CollectionException, InterruptedException {
 		final Map<String, CategoryItem> localAlbums = getNames(reference
 				.getCategoryList(CategoryEnum.Album, null, null, false));
 		final Map<String, CategoryItem> remoteAlbums = getNames(remoteAlbumsToDownload);
 		missingTracks.putAll(localAlbums);
 		missingTracks.keySet().retainAll(remoteAlbums.keySet());
 		for (final Iterator<Map.Entry<String, CategoryItem>> entryIterator = missingTracks
 				.entrySet().iterator(); entryIterator.hasNext();) {
 			final Map.Entry<String, CategoryItem> entry = entryIterator.next();
 			int localTrackCount = entry.getValue().songs;
 			if (localTrackCount < 0) {
 				localTrackCount = reference.getTracks(entry.getValue()).size();
 			}
 			final CategoryItem remoteAlbum = remoteAlbums.get(entry.getKey());
 			int remoteTrackCount = remoteAlbum.songs;
 			if (remoteTrackCount < 0) {
 				remoteTrackCount = downloadFrom.getTracks(remoteAlbum).size();
 			}
 			if (localTrackCount >= remoteTrackCount) {
 				entryIterator.remove();
 			}
 		}
 		toSynchronize.putAll(remoteAlbums);
 		localAlbums.keySet().removeAll(missingTracks.keySet());
 		toSynchronize.keySet().removeAll(localAlbums.keySet());
 	}
 
 	private Map<String, CategoryItem> getNames(
 			final Collection<? extends CategoryItem> items) {
 		final Map<String, CategoryItem> result = new HashMap<String, CategoryItem>(
 				items.size());
 		for (final CategoryItem item : items) {
 			if (item.name != null) {
 				result.put(item.name, item);
 			}
 		}
 		return result;
 	}
 }