/***
    *     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.collection.sync;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.text.ParseException;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;
  
  import android.media.MediaScannerConnection;
  
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.file.AbstractAudio;
  import sk.baka.ambient.commons.IOUtils;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.commons.TagFormatter;
  
  /***
   * Utility class.
   * 
   * @author Martin Vysny
   */
  public final class SyncUtils {
  	/***
  	 * produces a relative path where the music file should be stored. Must
  	 * produce valid paths! Paths are created automatically.
  	 */
  	public final TagFormatter pathFormatter;
  	/***
  	 * This is the reference collection, i.e. tracks which are not to be
  	 * synchronized.
  	 */
  	public final ICollection reference;
  	/***
  	 * Download excess tracks from this collection.
  	 */
  	public final ICollection downloadFrom;
  
  	/***
  	 * Connection to the media scanner.
  	 */
  	public final MediaScannerConnection msc;
  	
  	/***
  	 * Returns a new instance of a default tag formatter. It outputs strings in
  	 * the following form:
  	 * <code>sync/artist/year album/tracknum title.ext</code>.
  	 * 
  	 * @return non-<code>null</code> formatter instance.
  	 */
  	public static TagFormatter newPathFormatter() {
  		try {
  			return new TagFormatter(
  					"sync/{%artist/}{{%year }%album/}{%track }%title");
  		} catch (ParseException e) {
  			throw new RuntimeException(e);
  		}
  	}
  
  	/***
  	 * @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 msc
  	 *            after a successful track download the track will be reported
  	 *            to Android scanner.
  	 */
  	public SyncUtils(final ICollection reference,
  			final ICollection downloadFrom, final TagFormatter pathFormatter, final MediaScannerConnection msc) {
  		this.reference = reference;
  		this.downloadFrom = downloadFrom;
  		this.pathFormatter = pathFormatter;
 		this.msc = msc;
 	}
 
 	/***
 	 * Removes local tracks from given collection.
 	 * 
 	 * @param tracks
 	 *            the track list. Removes local tracks from this collection.
 	 * @param localTracks
 	 *            a list of local tracks.
 	 */
 	public static void removeLocalTracks(Collection<TrackMetadataBean> tracks,
 			Collection<? extends TrackMetadataBean> localTracks) {
 		final Set<SameTrack> local = new HashSet<SameTrack>(localTracks.size());
 		for (final TrackMetadataBean track : localTracks) {
 			local.add(new SameTrack(track));
 		}
 		for (final Iterator<TrackMetadataBean> download = tracks.iterator(); download
 				.hasNext();) {
 			final SameTrack track = new SameTrack(download.next());
 			if (local.contains(track)) {
 				download.remove();
 			}
 		}
 	}
 
 	private static final class SameTrack {
 		private final TrackMetadataBean track;
 
 		/***
 		 * Creates the comparator.
 		 * 
 		 * @param track
 		 *            the track.
 		 */
 		public SameTrack(final TrackMetadataBean track) {
 			this.track = track;
 		}
 
 		@Override
 		public boolean equals(Object o) {
 			if (o == this) {
 				return true;
 			}
 			if (!(o instanceof SameTrack)) {
 				return false;
 			}
 			final TrackMetadataBean other = ((SameTrack) o).track;
 			return MiscUtils.nullEquals(track.getDisplayableName(), other
 					.getDisplayableName())
 					&& MiscUtils.nullEquals(track.getAlbum(), other.getAlbum())
 					&& MiscUtils.nullEquals(track.getArtist(), other
 							.getArtist());
 		}
 
 		@Override
 		public int hashCode() {
 			int result = MiscUtils.hashCode(track.getDisplayableName());
 			result = result * 1001 + MiscUtils.hashCode(track.getAlbum());
 			result = result * 1001 + MiscUtils.hashCode(track.getArtist());
 			return result;
 		}
 	}
 
 	/***
 	 * Creates a new track with invalid characters removed from title, album
 	 * name, artist name, genre, year released and track number.
 	 * 
 	 * @param track
 	 *            the track to fix
 	 * @return fixed track.
 	 */
 	public static TrackMetadataBean removeSlashes(final TrackMetadataBean track) {
 		final TrackMetadataBean.Builder b = new TrackMetadataBean.Builder();
 		b.getData(track);
 		b.title = removeSlashes(b.title);
 		b.album = removeSlashes(b.album);
 		b.artist = removeSlashes(b.artist);
 		b.genre = removeSlashes(b.genre);
 		b.yearReleased = removeSlashes(b.yearReleased);
 		b.trackNumber = removeSlashes(b.trackNumber);
 		return b.build(-1);
 	}
 
 	/***
 	 * Since /sdcard is most probably a fat32 drive, we have to remove several
 	 * characters beside slash.
 	 * 
 	 * @param str
 	 *            the string to remove invalid characters from.
 	 * @return string having all invalid characters replaced by _
 	 */
 	public static String removeSlashes(final String str) {
 		if (str == null) {
 			return null;
 		}
 		String result = str;
 		for (final char c : INVALID_CHARS) {
 			result = result.replace(c, '_');
 		}
 		return result;
 	}
 
 	private final static char[] INVALID_CHARS = "///:*?<>|".toCharArray();
 
 	/***
 	 * Downloads given track.
 	 * @param rootPath prepend the formatted name with this path. Must not end with a slash.
 	 * @param track the track. Slashes are removed automatically.
 	 * @throws IOException
 	 */
 	public void downloadTrack(final String rootPath, final TrackMetadataBean track) throws IOException {
 		final TrackMetadataBean t = removeSlashes(track);
 		final AbstractAudio source = AbstractAudio.fromUri(track.getLocation());
 		final String targetFileName = rootPath + "/"
 				+ pathFormatter.format(t)
 				+ IOUtils.getExt(t.getLocation()).toLowerCase();
 		final File target = new File(targetFileName);
 		if (target.exists()) {
 			// the track already exists... skip
 			msc.scanFile(targetFileName, null);
 			return;
 		}
 		final File parentDir = target.getParentFile();
 		if (!parentDir.exists()) {
 			if (!parentDir.mkdirs()) {
 				throw new IOException("Failed to create directory "
 						+ parentDir.toString());
 			}
 		}
 		try {
 			IOUtils.copy(source.openInputStream(), new FileOutputStream(target),
 					8192);
 			msc.scanFile(targetFileName, null);
 			// register the track in the android collection manager
 		} catch (RuntimeException ex) {
 			target.delete();
 			throw ex;
 		} catch (IOException ex) {
 			target.delete();
 			throw ex;
 		}
 	}
 }