/***
    *     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.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Set;
  import java.util.zip.GZIPInputStream;
  
  import javax.xml.parsers.FactoryConfigurationError;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.SAXException;
  import org.xml.sax.helpers.DefaultHandler;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.NotifyingInputStream;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.collection.TrackMetadataBean.Builder;
  import sk.baka.ambient.commons.IOUtils;
  import sk.baka.ambient.commons.MiscUtils;
  import android.content.Context;
  import android.content.SharedPreferences;
  import android.content.SharedPreferences.Editor;
  import android.view.Gravity;
  import android.widget.Toast;
  
  /***
   * Scans the Magnatune store.
   * 
   * @author Martin Vysny
   */
  public class MagnatuneScanner implements IFileScanner {
  	private Library library = null;
  	private GenreCache genreCache;
  	/***
  	 * The location of a gzipped xml file containing the Magnatune collection.
  	 */
  	private final static URL COLLECTION_URL;
  	/***
  	 * Timestamp of last collection update.
  	 */
  	private final static URL TIMESTAMP_URL;
  	static {
  		try {
  			COLLECTION_URL = new URL(
  					"http://magnatune.com/info/song_info2_xml.gz");
  			TIMESTAMP_URL = new URL(
  					"http://magnatune.com/info/last_update_timestamp");
  		} catch (MalformedURLException e) {
  			throw new RuntimeException(e);
  		}
  	}
  
  	private long getCurrentTimestamp() throws IOException {
  		final InputStream in = TIMESTAMP_URL.openStream();
  		try {
  			final String str = IOUtils.readLine(in);
  			return Long.parseLong(str);
  		} finally {
  			MiscUtils.closeQuietly(in);
  		}
  	}
  
  	public void init(Library library, GenreCache genreCache) {
  		this.library = library;
  		this.genreCache = genreCache;
  	}
  
  	public void run() {
  		try {
  			// check the timestamp
  			final long timestamp = checkTimestamp();
  			if (timestamp < 0) {
  				return;
  			}
  			checkInterrupted();
  			// clean the database
  			library.backend.clean(getOrigin());
 			// parse the XML file
 			parseMagnatuneXML();
 			// remember new timestamp
 			if (!Thread.currentThread().isInterrupted()) {
 				final Editor e = getPrefs().edit();
 				e.putLong("timestamp", timestamp);
 				e.commit();
 			}
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	private SharedPreferences getPrefs() {
 		return AmbientApplication.getInstance().getSharedPreferences(
 				"magnatune", Context.MODE_PRIVATE);
 	}
 
 	/***
 	 * Checks current magnatune timestamp.
 	 * 
 	 * @return positive long when the rescan is needed (the value of the new
 	 *         timestamp), negative long if rescan is not needed.
 	 * @throws IOException
 	 */
 	private long checkTimestamp() throws IOException {
 		final long currentTimestamp = getCurrentTimestamp();
 		final SharedPreferences prefs = getPrefs();
 		final long lastTimestamp = prefs.getLong("timestamp", 0);
 		if (lastTimestamp >= currentTimestamp) {
 			AmbientApplication.getHandler().post(new Runnable() {
 				public void run() {
 					final Toast toast = Toast.makeText(AmbientApplication
 							.getInstance(),
 							R.string.magnatuneRescanUnnecessary,
 							Toast.LENGTH_LONG);
 					toast.setGravity(Gravity.CENTER, 0, 0);
 					toast.show();
 				}
 			});
 			userNotified = true;
 			return -1;
 		}
 		return currentTimestamp;
 	}
 
 	private final String caption = AmbientApplication.getInstance().getString(
 			R.string.magnatune_rescanning);
 	
 	private void parseMagnatuneXML() throws FactoryConfigurationError,
 			SAXException, IOException {
 		final InputStream in = new GZIPInputStream(NotifyingInputStream
 				.fromURL(COLLECTION_URL, 50, caption));
 		IOUtils.parseXML(in, new Handler());
 	}
 
 	private void checkInterrupted() {
 		if (Thread.currentThread().isInterrupted()) {
 			throw new RuntimeException("Interrupted");
 		}
 	}
 
 	/***
 	 * Handles elements from the magnatune collection xml.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private final class Handler extends DefaultHandler {
 		private boolean wasAllSongs = false;
 
 		@Override
 		public void endDocument() {
 			wasAllSongs = false;
 		}
 
 		@Override
 		public void startDocument() {
 			checkInterrupted();
 			wasAllSongs = false;
 		}
 
 		@Override
 		public void startElement(String uri, String localName, String name,
 				Attributes attributes) throws SAXException {
 			checkInterrupted();
 			if (localName.equals("AllSongs")) {
 				wasAllSongs = true;
 			} else if (localName.equals("Track")) {
 				if (!wasAllSongs) {
 					throw new SAXException("AllSongs element not found");
 				}
 				handleTrack(attributes);
 			} else {
 				throw new SAXException("Unknown element " + localName);
 			}
 		}
 	}
 
 	public TrackOriginEnum getOrigin() {
 		return TrackOriginEnum.Magnatune;
 	}
 
 	/***
 	 * Stores the tag into the db.
 	 * 
 	 * @param tag
 	 *            the tag to store.
 	 */
 	private void storeTag(TrackMetadataBean tag) {
 		// get genre ids
 		final Set<Long> genreIds = genreCache.register(tag.getGenre());
 		// register the track
 		library.backend.registerNewTrack(tag, genreIds);
 	}
 
 	private void handleTrack(Attributes attributes) {
 		final Builder track = TrackMetadataBean.newBuilder();
 		track.artist = MiscUtils.fixArtistAlbumName(attributes
 				.getValue("",
 				"artist"));
 		track.album = MiscUtils
 				.fixArtistAlbumName(attributes.getValue("album"));
 		track.title = attributes.getValue("title");
 		track.trackNumber = attributes.getValue("tracknum");
 		track.yearReleased = attributes.getValue("year");
 		track.genre = attributes.getValue("genre");
 		track.length = Integer.parseInt(attributes.getValue("seconds"));
 		track.location = attributes.getValue("url");
 		track.origin = TrackOriginEnum.Magnatune;
 		// use ogg - we cannot use ogg because of
 		// http://code.google.com/p/android/issues/detail?id=734
 		// if (location.endsWith(".mp3")) {
 		// location = location.substring(0, location.length() - 4) + ".ogg";
 		// }
 		track.buyURL = attributes.getValue("buy");
 		track.artistDesc = attributes.getValue("artistdesc");
 		track.artistURL = attributes.getValue("home");
 		track.license = attributes.getValue("license");
 		final TrackMetadataBean bean = track.build(-1);
 		storeTag(bean);
 	}
 
 	private boolean userNotified = false;
 	
 	public boolean isUserNotified() {
 		return userNotified;
 	}
 }