/***
    *     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.FileNotFoundException;
  import java.util.HashSet;
  import java.util.Set;
  import java.util.StringTokenizer;
  
  import junit.framework.Assert;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.Statistics;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import android.content.Context;
  import android.database.Cursor;
  
  /***
   * The music library. Emits {@link ILibraryListener} messages on events.
   * 
   * @author Martin Vysny
   */
  public final class Library {
  	/***
  	 * The database back-end.
  	 */
  	final DBStrategy backend;
  
  	/***
  	 * Creates new library. There should be at most one library instance.
  	 * 
  	 * @param ctx
  	 *            the context.
  	 * @throws FileNotFoundException
  	 *             if database fails to initialize
  	 */
  	public Library(Context ctx) throws FileNotFoundException {
  		super();
  		backend = new DBStrategy(ctx);
  	}
  
  	/***
  	 * List of watched directories. One directory should not be a subdirectory
  	 * of another.
  	 */
  	public Set<String> watchedDirectories = new HashSet<String>();
  
  	/***
  	 * Parses given directory list and sets {@link #watchedDirectories}
  	 * accordingly. Does not rescan the collection.
  	 * 
  	 * @param directoryList
  	 *            the list of directories, separated with ':'
  	 */
  	public void setWatchedDirectories(final String directoryList) {
  		watchedDirectories.clear();
  		final StringTokenizer tokenizer = new StringTokenizer(directoryList,
  				":");
  		for (; tokenizer.hasMoreTokens();) {
  			watchedDirectories.add(tokenizer.nextToken());
  		}
  	}
  
  	/***
  	 * Returns the {@link #watchedDirectories} set as a list of files.
  	 * 
  	 * @return the list of watched directories.
  	 */
  	public File[] getWatchedDirectories() {
  		final File[] result = new File[watchedDirectories.size()];
  		int i = 0;
  		for (final String dir : watchedDirectories) {
  			result[i++] = new File(dir);
  		}
  		return result;
  	}
  
  	/***
  	 * Rescans desired storage for music files and adds them to the library.
  	 * Asynchronous operation. Does nothing when the rescan is already running.
  	 * 
  	 * @param storage
  	 *            the storage type.
 	 */
 	public void queueScanner(final TrackOriginEnum storage) {
 		if (closing)
 			return;
 		final IFileScanner scanner;
 		switch (storage) {
 		case Magnatune:
 			scanner = new MagnatuneScanner();
 			break;
 		default:
 			throw new IllegalArgumentException("Cannot rescan " + storage);
 		}
 		final String caption = AmbientApplication.getInstance().getString(
 				R.string.magnatune_rescanning);
 		AmbientApplication.getInstance().getBackgroundTasks().schedule(
 				new Scanner(scanner), scanner.getClass(), storage.online,
 				caption);
 	}
 
 	/***
 	 * Scanner runnable.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private class Scanner implements Runnable {
 		private final IFileScanner scanner;
 
 		/***
 		 * Creates new scanner.
 		 * @param scanner
 		 */
 		public Scanner(final IFileScanner scanner) {
 			this.scanner = scanner;
 		}
 
 		public void run() {
 			final ILibraryListener invocator = AmbientApplication.getInstance()
 					.getBus().getInvocator(ILibraryListener.class, true);
 			invocator.libraryUpdate(true, false, false);
 			boolean userNotified = false;
 			try {
 				synchronized (Scanner.class) {
 					if (Thread.currentThread().isInterrupted())
 						return;
 					scanner.init(Library.this, new GenreCache(backend));
 					if (Thread.currentThread().isInterrupted())
 						return;
 					scanner.run();
 					userNotified = scanner.isUserNotified();
 				}
 			} finally {
 				invocator.libraryUpdate(false, Thread.currentThread()
 						.isInterrupted(), userNotified);
 			}
 		}
 	}
 
 	/***
 	 * Returns database backend object. Useful for selections.
 	 * 
 	 * @return db backend object.
 	 */
 	public DBStrategy getBackend() {
 		return backend;
 	}
 
 	private volatile boolean closing = false;
 
 	/***
 	 * Closes this instance of the library.
 	 */
 	public void close() {
 		closing = true;
 		backend.close();
 	}
 
 	@Override
 	protected void finalize() throws Throwable {
 		try {
 			close();
 		} finally {
 			super.finalize();
 		}
 	}
 
 	/***
 	 * Returns statistics for storage for given origin.
 	 * 
 	 * @param origin
 	 *            the track origin
 	 * @return statistics.
 	 */
 	public Statistics getStatistics(final TrackOriginEnum origin) {
 		final Statistics result = new Statistics();
 		{
 			final Cursor c = backend.getDb().rawQuery(
 					"select count(*), sum(length), sum(fileSize)"
 							+ " from tracks where origin=?",
 					new String[] { String.valueOf(origin.ordinal()) });
 			Assert.assertTrue(c.moveToFirst());
 			result.tracks = c.getInt(0);
 			result.length = c.getInt(1);
 			result.fileSize = c.getLong(2);
 			c.close();
 		}
 		{
 			final Cursor c = backend
 					.getDb()
 					.rawQuery(
 							"select count(*) from "
 									+ "(select distinct artist from tracks where origin=?)",
 							new String[] { String.valueOf(origin.ordinal()) });
 			Assert.assertTrue(c.moveToFirst());
 			result.artists = c.getInt(0);
 			c.close();
 		}
 		{
 			final Cursor c = backend
 					.getDb()
 					.rawQuery(
 							"select count(*) from "
 									+ "(select distinct album from tracks where origin=?)",
 							new String[] { String.valueOf(origin.ordinal()) });
 			Assert.assertTrue(c.moveToFirst());
 			result.albums = c.getInt(0);
 			c.close();
 		}
 		return result;
 	}
 
 	/***
 	 * Returns overall genre count.
 	 * 
 	 * @return known genre count.
 	 */
 	public int getGenreCount() {
 		final Cursor c = backend.getDb().rawQuery(
 				"select count(*) from genres", null);
 		Assert.assertTrue(c.moveToFirst());
 		final int result = c.getInt(0);
 		c.close();
 		return result;
 	}
 }