package org.musicontroller.core.jobs;
   
   import java.io.File;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.net.URLConnection;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.apache.log4j.Logger;
  import org.hibernate.FlushMode;
  import org.hibernate.HibernateException;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.BagAndKeywordUtils;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.importer.ImporterException;
  import org.musicontroller.importer.ImporterImpl;
  import org.musicontroller.importer.MP3InspectorJID3Lib;
  import org.musicontroller.importer.MediafileInspector;
  import org.musicontroller.importer.MusicArchiveEntryBean;
  import org.musicontroller.rss.RssDAO;
  import org.springframework.orm.hibernate3.SessionHolder;
  import org.springframework.transaction.support.TransactionSynchronizationManager;
  import org.varienaja.util.FileOperations;
  
  /**
   * This class provides the functionality to import a Podcast-Playlist into the
   * database. It does so asynchronously. It's done when it's done :-)
   * <p>Since this Jon runs asynchronously, it cannot rely on the OpenSessionInView.
   * Therefore transaction-handling is explicitly implemented in this class.</p>
   * @author Varienaja
   */
  public class PodcastUpdateJob implements Runnable {
  	private static final Logger LOG = Logger.getLogger(PodcastUpdateJob.class);
  	
  	private String _podcasturl;
  	private static Dao _dao;
  	
  
  	public void setPodcastURL(String url) {
  		_podcasturl = url;
  	}
  	
  	public void setDao(Dao dao) {
  		_dao = dao;
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see java.lang.Runnable#run()
  	 */
  	public void run() {
  		if (_podcasturl==null) {
  			LOG.debug("null-podcast, nothing can be imported.");
  			return;
  		}
  		if (_dao==null) {
  			LOG.debug("Dao not set, nothing can be imported.");
  			return;
  		}
  		LOG.debug("Updating from: " + _podcasturl);
  		
  		SessionFactory factory = _dao.getSessionFactory2();
  		Session session = null;
  	    Transaction tx = null;
  		try {
  			session = factory.openSession();
  			// Because we're messing a lot with a Playlist here, we want manual
  			// flushes. Otherwise, Hibernate will sometimes issue an auto-flush
  			// in situations where the Playlist is not yet in a consistent
  			// state, generating SQL-errors. In the end, after our modifications
  			// we're sure that the Playlist is consistent, and we issue the
  			// flush manually.
  			session.setFlushMode(FlushMode.MANUAL);
  		    TransactionSynchronizationManager.bindResource(factory, new SessionHolder(session));
  		    
  			tx = session.beginTransaction();
  			Playlist playlist = extractPodcastInfo(_podcasturl);
  			
  			tx = session.beginTransaction();
  			if (playlist!=null) {
  				updatePodcastPlaylist(playlist);
  				session.flush();
  			}
  		} catch (HibernateException e) {
  			LOG.error(e.getMessage());
  			if (tx!=null) {
  				tx.rollback();
 			}
 		} catch (Exception e) {
 			e.printStackTrace();
 		} finally {
 			if (session!=null) {
 				session.close();
 				TransactionSynchronizationManager.unbindResource(factory);
 			}
 		}
 	}
 	
 	private Playlist extractPodcastInfo(String podcasturl) {
 		RssDAO rssdao = new RssDAO();
 		rssdao.setDao(_dao);
 		return rssdao.readPlaylistFromRss(podcasturl);
 	}
 
 	/**
 	 * Creates (if not already exists) or updates a Playlist.
 	 * @param Playlist A Playlist object. May be an entirely new Playlist or
 	 * a Playlist that is already to MusiController, with extra songs added to 
 	 * it. 
 	 */
 	private void updatePodcastPlaylist(Playlist playlist) {
 		for (Contract_PS contract : playlist.getSongs()) {
 			Song song = contract.getSong();
 			Band band = song.getBand();
 			if (band.getId()<0) {
 				_dao.save(band);
 				LOG.debug("Band " + band.getName() + " created...");
 			}
 			
 			if (song.getId()<0) {
 				Set<String> keywords = new HashSet<String>();
 				for (Keyword kw : song.getKeywordbag().getKeywords()) {
 					keywords.add(kw.getName());
 				}
 				
 				InputStream in = null;
 				try {
 					LOG.debug("Downloading song " + song.getName() + " from " + song.getLink() + " to a temporary location...");
 					URLConnection urlc = new URI(song.getLink().getUrl()).toURL().openConnection();
 					in = urlc.getInputStream();
 					String tmpName = FileOperations.tmpFile(in, "importingPodcastEntry");
 					//We do not trust the length reported from the rss, so we calculate it ourselves
 					MediafileInspector inspector = new MP3InspectorJID3Lib(new File(tmpName));
 					song.setLength(inspector.getSonglength());
 					LOG.debug("Download to " + tmpName + " complete.");
 					
 					//Construct a MusicArchiveBean in order to be able to reuse
 					//code to move it into the Library.
 					MusicArchiveEntryBean bean = new MusicArchiveEntryBean();
 					bean.setEntryName(tmpName);
 					bean.setBandName(band.getName());
 					bean.setSongName(song.getName());
 					String libraryName = ImporterImpl.moveMP3ToLibrary(bean);
 					song.getLink().setUrl(libraryName);
 					_dao.save(song.getLink());
 					LOG.debug("Moved song " + song.getName() + " to the MC library at: " + libraryName);
 
 					song.setKeywordbag(BagAndKeywordUtils.getKeywordBag(song.getKeywordbag().getKeywords()));
 					_dao.save(song);
 					
 					LOG.debug("Added song " + song.getName() + " to the playlist at position: " + contract.getRowno());
 				} catch (FileNotFoundException e) {
 					LOG.error("Error importing song " + song + ": " + e.getMessage());
 				} catch (IOException e) {
 					LOG.error("Error importing song " + song + ": " + e.getMessage());
 				} catch (URISyntaxException e) {
 					LOG.error("Error importing song " + song + ": " + e.getMessage());
 				} catch (ImporterException e) {
 					LOG.error("Error importing song " + song + ": " + e.getMessage());
 				} finally {
 					if (in!=null) {
 						try {
 							in.close();
 						} catch (IOException e) {
 							LOG.error("Error closing inputstream: " + e.getMessage());
 						}
 					}
 				}
 			}
 		}
 		if (playlist.getLink().getId()<0) {
 			_dao.save(playlist.getLink());
 		}
 		_dao.save(playlist);
 		LOG.debug("Importing podcast done!");
 	}
 	
 	/**
 	 * Executes the updating of all Podcasts. 
 	 */
 	@SuppressWarnings("unchecked")
 	public void execute() {
 		LOG.debug("Updating of Podcasts started...");
 		String hql = "select p.link.url from Playlist p where p.link is not null";
 		Collection<String> podcastURLs = _dao.search(hql, null, 0);
 		for (String podcastURL : podcastURLs) {
 			_podcasturl = podcastURL;
 			run();
 		}
 		LOG.debug("Updating of Podcasts done.");
 	}
 
 }