package org.musicontroller.rss;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.io.OutputStreamWriter;
   import java.io.UnsupportedEncodingException;
   import java.io.Writer;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URLConnection;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.sax.SAXTransformerFactory;
  import javax.xml.transform.sax.TransformerHandler;
  import javax.xml.transform.stream.StreamResult;
  
  import org.apache.log4j.Logger;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Link;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.BagAndKeywordUtils;
  import org.musicontroller.dao.Dao;
  import org.varienaja.util.DateTools;
  import org.xml.sax.Attributes;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.XMLReader;
  import org.xml.sax.helpers.AttributesImpl;
  import org.xml.sax.helpers.DefaultHandler;
  import org.xml.sax.helpers.XMLReaderFactory;
  
  /**
   * Class for reading and writing PodCast-RSS.
   * @author Varienaja
   */
  public class RssDAO {
  	private static final Logger LOG = Logger.getLogger(RssDAO.class);
  	private static Dao DAO;
  	private static final String ENCLOSURE = "enclosure";
  	private static final String AUTHOR = "itunes:author";
  	private static final String TITLE = "itunes:title";
  	private static final String ITEM = "item";
  	private static final String DURATION = "itunes:duration";
  	private static final String URL = "url";
  	private static final String KEYWORDS = "itunes:keywords";
  	private static final String PLTITLE = "title";
  	
  	/**
  	 * Class for handling PodCast RSS.
  	 * @author Varienaja
  	 */
  	class PodCastRSSHandler extends DefaultHandler {
  		private Playlist _playlist;
  		private StringBuilder _content;
  		private Map<String,String> _contentMap;
  		private boolean _playlistnameset;
  		private boolean _playlistkeywordsset;
  		private String _playlistKeywords;
  		private String _podcastAuthor;
  		private int _songidx;
  		
  		/**
  		 * Creates a new RSSHandler.
  		 */
  		public PodCastRSSHandler() {
  			_playlist = null;
  			_content = new StringBuilder();
  			_contentMap = new HashMap<String,String>();
  			_playlistnameset = false;
  			_playlistkeywordsset = false;
  			_playlistKeywords = null;
  			_podcastAuthor = null;
  			_songidx = 0;
  		}
  		
  		/**
  		 * Returns the Playlist. Caution: this property is only valid after a
  		 * rss-feed has been read.
  		 * @return The Playlist.
  		 */
  		protected Playlist getPlaylist() {
  			return _playlist;
  		}
  		
  		/*
  		 * (non-Javadoc)
  		 * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
  		 */
 		public void startElement(String uri, String name, String qName, Attributes atts) {
 			if (ITEM.equals(qName)) { //A new Song
 				_contentMap = new HashMap<String,String>();
 			}
 			if (ENCLOSURE.equals(qName)) { //Capture the URL separately.
 				_contentMap.put(URL, atts.getValue(URL));
 			}
 			_content = new StringBuilder();
 		}
 		
 		/*
 		 * (non-Javadoc)
 		 * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
 		 */
 		public void endElement(String uri, String name, String qName) {
 			//Capture all data into a HashMap.
 			_contentMap.put(qName, _content.toString());
 			//We should have the Playlist-title before we read the very first song.
 			if (PLTITLE.equals(qName) && !_playlistnameset) {
 				String playlistname = _contentMap.get(PLTITLE);
 				_playlist = DAO.getPlaylistByName(playlistname);
 				if (_playlist==null) {
 					_playlist = new Playlist();
 					_playlist.setName(playlistname);
 				}
 				_playlistnameset = true;
 			}
 			_content = new StringBuilder();
 			
 			if (AUTHOR.equals(qName)) {
 				if (_podcastAuthor==null) {
 					_podcastAuthor = _contentMap.get(AUTHOR);
 				}
 			}
 
 			if (KEYWORDS.equals(qName)) {
 				if (!_playlistkeywordsset) {
 					_playlistKeywords = _contentMap.get(KEYWORDS);
 					_playlistkeywordsset = true;
 				}
 			}
 
 			if (ITEM.equals(qName)) { //Song done, add to Playlist.
 				_songidx++;
 				String bandname = _contentMap.get(AUTHOR);
 				if (bandname==null) {
 					//Some Podcasts do not provide a per-item author. In that case we take the Podcasts author.
 					bandname = _podcastAuthor;
 				}
 				Band band = null;
 				if (bandname!=null) {
 					band = DAO.getBandByName(bandname);
 				}
 				if (band==null) {
 					//First try to se if we did already construct a new band with this name
 					for (Contract_PS contract : _playlist.getSongs()) {
 						Band candidate = contract.getSong().getBand(); 
 						if (candidate.getName().equals(bandname)) {
 							band = candidate;
 						}
 					}
 					if (band==null) { //Okay it really is a new band.
 						band = new Band();
 						band.setName(bandname);
 					}
 				}
 				
 				String songname = _contentMap.get(TITLE);
 				if (songname == null) {
 					//Fallback to other name-property if title==null.
 					songname = _contentMap.get(PLTITLE);
 				}
 				//Only search for a Song, if the Band is in the DB.
 				Song song = band.getId()==-1L ? null : DAO.getSong(band, songname);
 				if (song==null) {
 					song = new Song();
 					song.setName(songname);
 					song.setLength(_contentMap.get(DURATION));
 					song.setBand(band);
 
 					Link link = new Link();
 					link.setUrl(_contentMap.get(URL));
 					song.setLink(link);
 					
 					String allKeywords = _contentMap.get(KEYWORDS);
 					if (allKeywords==null || "".equals(allKeywords)) {
 						//If the Song itself has no keywords defined, take those
 						//from the Playlist.
 						allKeywords = _playlistKeywords; 
 					}
 					if (allKeywords!=null) {
 						Keywordbag bag = cachedGetKeywordbag(allKeywords);
 						song.setKeywordbag(bag);
 					}
 				}
 				
 				_playlist.addSongIfNew(song, _songidx);
 			}
 		}
 		
 
 		/*
 		 * (non-Javadoc)
 		 * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)
 		 */
 		public void characters(char ch[], int start, int length) {
 			_content.append(ch, start, length);
 		}
 	}
 
 	private HashMap<String, Keywordbag> _cache;
 
 	/**
 	 * Reads an InputStream (which has to contain a podcast-rss stream), converts
 	 * it into a Playlist.
 	 * @param in The inputstream to read the rss from.
 	 * @return The resulting Playlist, or null if this method could make no
 	 * sense of the input.
 	 */
 	public Playlist readPlaylistFromRss(InputStream in) {
 		_cache = new HashMap<String, Keywordbag>();
 		try {
 			XMLReader xr = XMLReaderFactory.createXMLReader();
 			PodCastRSSHandler handler = new PodCastRSSHandler();
 			xr.setContentHandler(handler);
 			xr.setErrorHandler(handler);
 			xr.parse(new InputSource(in));
 			Playlist playlist = handler.getPlaylist();
 			LOG.debug("Read "+playlist.getSongs().size()+" Songs from RSS-feed.");
 			return playlist;
 		} catch (SAXException e) {
 			LOG.error("Error parsing RSS: "+e);
 		} catch (IOException e) {
 			LOG.error("I/O Exception reading RSS: "+e);
 		} finally {
 			_cache = null;
 		}
 		return null;
 	}
 	
 	/**
 	 * Reads a Playlist from a URL, which contains a podcast-rss.
 	 * @param url The URL to read from.
 	 * @return The Playlist, or null if nothing could be read.
 	 */
 	public Playlist readPlaylistFromRss(String url) {
 		Playlist result = null;
 		InputStream in = null;
 		try {
 			URLConnection urlc = new URI(url).toURL().openConnection();
 			urlc.setRequestProperty("user-agent","Mozilla/5.0"); //Google wants a user-agent.
 			
 			in = urlc.getInputStream();
 			result = readPlaylistFromRss(in);
 			if (result.getLink()==null) {
 				Link link = new Link();
 				link.setUrl(url);
 				result.setLink(link);
 			}
 		} catch (URISyntaxException e) {
 			LOG.error(e);
 		} catch (MalformedURLException e) {
 			LOG.error(e);
 		} catch (IOException e) {
 			LOG.error(e);
 		} finally {
 			if (in!=null) {
 				try {
 					in.close();
 				} catch (IOException e) {
 					LOG.error(e);
 				}
 			}
 		}
 		return result;
 	}
 
 
 	/**
 	 * Writes a Playlist to an Outputstream as a Podcast-xml.
 	 * @param playlist The Playlist to export.
 	 * @param out The Stream to write the XML data to.
 	 * @param provider The Provider for metadata to this Playlist and its Songs.
 	 */
 	public void writePlaylistRSS(Playlist playlist, OutputStream out, MetadataProvider provider) {
     	Writer writer = null;
 		try {
 			try {
 				writer = new OutputStreamWriter(out, "UTF-8");
 			} catch (UnsupportedEncodingException e) {
 				LOG.error("Error setting output-charset to UTF-8! " + e);
 			}
 			StreamResult streamResult = new StreamResult(writer);
 			SAXTransformerFactory tf = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
 			TransformerHandler hd = tf.newTransformerHandler();
 			Transformer t = hd.getTransformer();
 			t.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 			t.setOutputProperty(OutputKeys.INDENT, "yes");
 			hd.setResult(streamResult);
 			hd.startDocument();
 			
 			AttributesImpl atts = new AttributesImpl();
 			atts.addAttribute("", "", "version", "CDATA", "2.0");
 			atts.addAttribute("", "", "xmlns:itunes", "CDATA", "http://www.itunes.com/dtds/podcast-1.0.dtd");
 			hd.startElement("", "", "rss", atts); //rss-tag
 			
 			atts.clear();
 			hd.startElement("", "", "channel", atts); //channel-tag
 			writeElement(PLTITLE, playlist.getName(), hd);
 			writeElement("link", provider.getUrl(playlist), hd);
 
 			writeElement("language", "en-us", hd);
 			writeElement("copyright", "todo", hd);
 			writeElement("itunes:subtitle", "The subtitle of " + playlist.getName(), hd);
 			writeElement(AUTHOR, playlist.getBandname(), hd);
 			writeElement("itunes:summary", "The summary of " + playlist.getName(), hd);
 			writeElement("description", "The description of " + playlist.getName(), hd);
 
 			atts.clear();
 			atts.addAttribute("", "", "href", "CDATA", provider.getCoverUrl(playlist));
 			hd.startElement("", "", "itunes:image", atts);
 			hd.endElement("", "", "itunes:image");
 
 			atts.clear();
 			hd.startElement("", "", "itunes:owner", atts);
 				writeElement("itunes:name", "Someone Else", hd);
 				writeElement("itunes:email", "someone@example.com", hd);
 			hd.endElement("", "", "itunes:owner");
 			
 			//It is music
 			atts.clear();
 			atts.addAttribute("", "", "text", "CDATA", "Music");
 			hd.startElement("", "", "itunes:category", atts);
 			hd.endElement("", "", "itunes:category");
 			
 			//default-value for explicit.
 			writeElement("itunes:explicit", "no", hd);
 			
 			//Self-link
 			atts.clear();
 			atts.addAttribute("", "", "rel", "CDATA", "self");
 			atts.addAttribute("", "", "type", "CDATA", "application/rss+xml");
 			atts.addAttribute("", "", "href", "CDATA", provider.getRssUrl(playlist));
 			
 			for (Contract_PS cps : playlist.getSongs()) {
 				atts.clear();
 				hd.startElement("", "", "item", atts);
 					writeElement(PLTITLE, cps.getSong().getBand().getName() + " - " + 
 							cps.getSong().getName(), hd);
 					writeElement("description", "A " + cps.getSong().getKeywordbag() + "song.", hd);
 					writeElement("link", provider.getUrl(cps.getSong()), hd);
 					
 					writeElement(TITLE, cps.getSong().getName(), hd);
 					writeElement(AUTHOR, cps.getSong().getBand().getName(), hd);
 					writeElement("itunes:album", playlist.getName(), hd);
 					writeElement("itunes:subtitle", "Subtitle of this song", hd);
 					writeElement("itunes:summary", "Summary of this song", hd);
 
 					atts.clear();
 					File file = cps.getSong().getLink().getFile();
 					atts.addAttribute("", "", "length", "CDATA",Long.toString(file.length()));
 					
 					String downloadurl = provider.getDownloadUrl(cps.getSong());
 					atts.addAttribute("", "", URL, "CDATA", downloadurl);
 					atts.addAttribute("", "", "type", "CDATA", "audio/mpeg");
 					hd.startElement("", "", ENCLOSURE, atts);
 					hd.endElement("", "", ENCLOSURE);
 					
 					writeElement("guid", downloadurl, hd);
 					//Wed, 15 Jun 2005 19:00:00 +0000
 					writeElement("pubDate", DateTools.formatDate(cps.getSong().getInserted(), "EEE, d MMM yyyy HH:mm:ss")+" +0000", hd);
 					writeElement(DURATION, cps.getSong().getFormattedLength(), hd);
 					writeElement(KEYWORDS, ""+cps.getSong().getKeywordbag(), hd);
 				hd.endElement("", "", "item");
 			}
 			
 			hd.endElement("", "", "channel");
 			hd.endElement("", "", "rss");
 			hd.endDocument();
 		} catch (TransformerConfigurationException e) {
 			LOG.error("TransformerConfigurationException during podcast creation: " + e);
 		} catch (SAXException e) {
 			LOG.error("SAXException during podcast creation: " + e);
 		} finally {
 			try {
 				if (writer!=null) writer.close();
 			} catch (IOException e) {
 				LOG.error("Error closing writer "+e);
 			}
 		}
 	}
 	
 	/**
 	 * Convenience method for writing an element with a text-attribute.
 	 * @param eltName Element name
 	 * @param content The attribute
 	 * @param hd The TransformerHandler
 	 * @throws SAXException When an error occurred
 	 */
 	private void writeElement(String eltName, String content, TransformerHandler hd) throws SAXException {
 		AttributesImpl atts = new AttributesImpl();
 		hd.startElement("", "", eltName, atts);
 		hd.characters(content.toCharArray(), 0, content.length());
 		hd.endElement("", "", eltName);
 	}
 
 	/**
 	 * Set the MusiController-dao, which is used for looking up songs and playlists.
 	 * @param dao The Dao.
 	 */
 	public void setDao(Dao dao) {
 		DAO = dao;
 	}
 
 	/**
 	 * Merges two Playlists. The original Playlist will be modified such, that
 	 * afterwards it has the same Songs in it as the fromrss-Playlist. Songs
 	 * in the fromrss-Playlist that were already known in the Dao, are reused.
 	 * This means, that the modified original Playlist can be safely persisted
 	 * to the Database. 
 	 * 
 	 * @param original The original-Playlist.
 	 * @param fromrss The Playlist that resulted from downloading a Podcast.
 	 */
 	public void merge(Playlist original, Playlist fromrss) {
 		//Reuse the existing contracts, so we do not create/delete records in
 		//the DB all the time
 		Iterator<Contract_PS> it = original.getSongs().iterator();
 		for (Contract_PS contract : fromrss.getSongs()) {
 			Contract_PS orig = it.hasNext() ? it.next() : null;
 			if (orig==null) {
 				original.addSong(contract.getSong(), contract.getRowno());
 			} else {
 				orig.setSong(contract.getSong());
 				orig.setRowno(contract.getRowno());
 			}
 		}
 		//Remove superfluous Songs in case fromrss was smaller than the original
 		while (it.hasNext()) { 
 			it.next();
 			it.remove();
 		}
 	}
 	
 	/**
 	 * Updates a Playlist with the latest info from the Podcast. This method
 	 * only succeeds when the parameter points to a Playlist that is a Podcast.
 	 * Playlists are Podcasts when their Link-property points to a valid URL.
 	 * @param playlistid The id of the Playlist to update.
 	 */
 	public void updatePlaylist(long playlistid) {
 		Playlist playlist = DAO.getPlaylistById(playlistid, null);
 		if (playlist.getLink()==null) {
 			LOG.debug("Playlist: " + playlist.getName() + " cannot be updated because it does not point to a URL.");
 			return;
 		}
 		String url = playlist.getLink().getUrl();
 		LOG.debug("Updating podcast: " + playlist.getName() + " from: " + url);
 		Playlist fromrss = readPlaylistFromRss(url);
 		if (fromrss!=null) {
 			merge(playlist, fromrss);
 			DAO.save(playlist);
 		} else {
 			LOG.debug("Could not read Playlist from: " + url);
 		}
 		LOG.debug("Done updating podcast.");
 	}
 	
 	/**
 	 * Because many RSS-feeds contain Song which all have the same Keywordbag,
 	 * we cache the result. This results in less DB-access.
 	 * @param allKeywords The keywords to get the Keywrdbag for as a comma-separated String.
 	 * @return The persistent Keywordbag.
 	 */
 	private Keywordbag cachedGetKeywordbag(String allKeywords) {
 		Keywordbag result = _cache.get(allKeywords);
 		if (result==null) {
 			result = BagAndKeywordUtils.getKeywordBag(allKeywords);
 			_cache.put(allKeywords, result);
 		}
 		return result;
 	}
 
 }