/***
    *     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.library;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.jajuk.util.DownloadManager;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.CategoryEnum;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.AbstractFileStorage;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.commons.SimpleBus;
  import sk.baka.ambient.lrc.lyrdb.LyrdbTrack;
  import android.database.Cursor;
  import android.graphics.Bitmap;
  import android.graphics.BitmapFactory;
  import android.widget.ImageView;
  
  /***
   * Provides covers and manages cover cache. Thread-safe. Essentially a
   * singleton, there must be at most one instance.
   * 
   * @author Martin Vysny
   */
  public final class CoverCache extends AbstractFileStorage implements
  		ILibraryListener {
  	private final Library library;
  
  	/***
  	 * Creates new cache.
  	 */
  	public CoverCache() {
  		super(AmbientApplication.getInstance().getString(R.string.covers),
  				".png", ".jpg", ".gif");
  		this.library = AmbientApplication.getInstance().getLibrary();
  	}
  
  	/***
  	 * If <code>true</code> then new covers will not be downloaded. If
  	 * <code>false</code> then old covers will be purged.
  	 */
  	private boolean dontDownloadOnCacheFull = true;
  
  	/***
  	 * Sets the cache behavior when the cache is full.
  	 * 
  	 * @param dontDownload
  	 *            if <code>true</code> then new covers will not be downloaded.
  	 *            If <code>false</code> then old covers will be purged.
  	 */
  	public synchronized void setCacheOverflowBehavior(final boolean dontDownload) {
  		this.dontDownloadOnCacheFull = dontDownload;
  	}
  
  	/***
  	 * Fetches a cover. Attempts to fetch it from the internet if a cover is not
  	 * found and we are online - in this case a background thread is run and the
  	 * method returns <code>null</code>.
  	 * 
  	 * @param track
  	 *            the track.
  	 * @return cover or <code>null</code> if we are unable to provide any cover.
  	 */
  	private File getCover(final TrackMetadataBean track) {
  		return getFile(track);
  	}
  
  	@Override
  	protected boolean isProceedWithDownload(Object fetchInfo) {
  		removeObsoleteAlbums();
  		final boolean proceed = !(dontDownloadOnCacheFull && isFull());
  		if (proceed) {
  			removeOldestCovers();
 		}
 		return proceed;
 	}
 
 	@Override
 	protected String[] getFilenameAndExt(URL url, Object fetchInfo) {
 		final TrackMetadataBean track = (TrackMetadataBean) fetchInfo;
 		if (MiscUtils.isEmptyOrWhitespace(track.getAlbum()))
 			return null;
 		final String ext = url == null ? null : "."
 				+ DownloadManager.getExtension(url);
 		final String name = track.getAlbum();
 		return new String[] { name, ext };
 	}
 
 	@Override
 	protected void onFileDownloaded(URL url, Object fetchInfo,
 			final boolean success) {
 		if (!success) {
 			return;
 		}
 		final SimpleBus bus = AmbientApplication.getInstance().getBus();
 		bus.getInvocator(ILibraryListener.class, true).coverLoaded(
 				(TrackMetadataBean) fetchInfo);
 	}
 
 	@Override
 	protected URL toURL(Object fetchInfo) throws IOException {
 		final TrackMetadataBean track = (TrackMetadataBean) fetchInfo;
 		// try to fetch from the internet
 		final List<URL> covers = DownloadManager.getRemoteCoversList(track
 				.getArtist()
 				+ " " + track.getAlbum());
 		if (covers.isEmpty())
 			return null;
 		if (Thread.currentThread().isInterrupted())
 			return null;
 		final URL cover = findSupported(covers);
 		return cover;
 	}
 
 	private URL findSupported(final List<URL> covers) {
 		for (final URL cover : covers) {
 			final String ext = "." + DownloadManager.getExtension(cover);
 			if (supportsExtension(ext))
 				return cover;
 		}
 		return null;
 	}
 
 	/***
 	 * Fetches a cover for a track and sets it into given view. If the cover is
 	 * not present in the cache and we are not offline the cover is fetched in a
 	 * worker thread and {@link ILibraryListener#coverLoaded(TrackMetadataBean)}
 	 * is emitted.
 	 * 
 	 * @param track
 	 *            the track.
 	 * @param view
 	 *            set the image to this view.
 	 * @return loaded bitmap instance. The bitmap should be recycled when not
 	 *         needed.
 	 */
 	public Bitmap setCover(final TrackMetadataBean track, final ImageView view) {
 		final File file = getCover(track);
 		if (file == null) {
 			view.setImageResource(R.drawable.cover);
 			return null;
 		} else {
 			final Bitmap bitmap = BitmapFactory.decodeFile(file
 					.getAbsolutePath());
 			view.setImageBitmap(bitmap);
 			return bitmap;
 		}
 	}
 
 	@Override
 	public void cleanup() {
 		removeObsoleteAlbums();
 		removeOldestCovers();
 	}
 
 	private synchronized void removeOldestCovers() {
 		if (!isFull())
 			return;
 		final List<File> files = new ArrayList<File>(theCache.values());
 		// sort - oldest files first
 		Collections.sort(files, new Comparator<File>() {
 			public int compare(File object1, File object2) {
 				if (object1.lastModified() < object2.lastModified())
 					return -1;
 				if (object1.lastModified() > object2.lastModified())
 					return 1;
 				return 0;
 			}
 		});
 		for (final File coverFile : files) {
 			removeFile(coverFile);
 			if (!isFull())
 				return;
 		}
 	}
 
 	private synchronized void removeObsoleteAlbums() {
 		if (!isFull())
 			return;
 		if (!libraryUpdated)
 			return;
 		libraryUpdated = false;
 		final Set<String> obsoleteCovers = new HashSet<String>(theCache
 				.keySet());
 		final Cursor c = library.getBackend().getCriteriaList(
 				new CategoryEnum[] { CategoryEnum.Album }, null);
 		while (c.moveToNext()) {
 			final String album = c.getString(0);
 			obsoleteCovers.remove(album);
 		}
 		c.close();
 		// remove all obsolete covers
 		for (final String album : obsoleteCovers) {
 			final File coverFile = getCacheFile(album);
 			removeFile(coverFile);
 		}
 	}
 
 	public void coverLoaded(TrackMetadataBean track) {
 		// do nothing
 	}
 
 	private volatile boolean libraryUpdated = false;
 
 	public void libraryUpdate(boolean updateStarted, boolean interrupted,
 			boolean userNotified) {
 		if (!updateStarted) {
 			libraryUpdated = true;
 		}
 	}
 
 	public void lyricsLoaded(TrackMetadataBean track, List<LyrdbTrack> lyrics) {
 		// do nothing
 	}
 }