package org.musicontroller.streaming;
   
   import java.io.BufferedOutputStream;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.io.PrintStream;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.zip.Adler32;
  import java.util.zip.CheckedOutputStream;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipOutputStream;
  
  import org.apache.log4j.Logger;
  import org.apache.tapestry.IRequestCycle;
  import org.apache.tapestry.engine.ExternalService;
  import org.apache.tapestry.engine.IEngineService;
  import org.apache.tapestry.engine.ILink;
  import org.apache.tapestry.services.LinkFactory;
  import org.apache.tapestry.services.ServiceConstants;
  import org.apache.tapestry.util.ContentType;
  import org.apache.tapestry.web.WebResponse;
  import org.musicontroller.core.Contract_PS;
  import org.musicontroller.core.Event;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.Dao;
  import org.musicontroller.security.IUser;
  import org.varienaja.util.FileOperations;
  
  public class Downloader extends ExternalService implements IEngineService {
  	private static final Logger log = Logger.getLogger(Downloader.class);
  
  	public static final String SERVICE_NAME = "download";
      private LinkFactory _linkFactory;
      private WebResponse _response;
  	private Dao _dao;
  	
  	/*
  	 * A DownloadLink must be constructed with 4 parameters:
  	 * Kind (S Song or P Playlist)
  	 * Id The id of the Song or Playlist
  	 * Userid, the id of the user requesting to download this Song or Playlist
  	 * Passhash, the hash of the pass of the User.
  	 * When passhash and userid match, the Song or Playlist is transferred. 
  	 * (non-Javadoc)
  	 * @see org.apache.tapestry.engine.ExternalService#getLink(boolean, java.lang.Object)
  	 */
  	public ILink getLink(boolean post, Object parameter) {
  		//The parameter is an array
  		Object[] params = (Object[]) parameter;
  		
  		String kind = params[0]==null ? "P" : params[0].toString();
  		Long id = params[1]==null ? 0 : (Long) params[1];
  		Long userid = params[2]==null ? 0 : (Long) params[2];
  		String passhash = params[3].toString();
  		
          Map<String,String> parameters = new HashMap<String,String>();
          parameters.put(ServiceConstants.SERVICE, getName());
          parameters.put("userid",userid.toString());
          parameters.put("passhash", passhash);
          parameters.put("id", id.toString());
          parameters.put("kind", kind);
          
          return _linkFactory.constructLink(this, false, parameters, true);
  	}
  	
  	/*
  	 * (non-Javadoc)
  	 * @see org.apache.tapestry.engine.ExternalService#service(org.apache.tapestry.IRequestCycle)
  	 */
  	public void service(IRequestCycle cycle) {
  		String kind = cycle.getParameter("kind");
  		long userid = Long.parseLong(cycle.getParameter("userid"));
  		String passhash = cycle.getParameter("passhash");
  		long id = Long.parseLong(cycle.getParameter("id"));
  		if ("P".equals(kind)) {
  			servePlaylist(userid, passhash, id);
  		} else {
  			serveSong(userid, passhash, id);
  		}
  	}
  
  	/**
  	 * Copies the musical contents of a Song to the response, if userid and
  	 * passhash match. After the complete transfer of the song, a
  	 * Downloaded-Event is added to the Song.
  	 * @param userid The user
  	 * @param passhash The passhash of the user.
  	 * @param songid The id of the Song to download.
  	 */
  	private void serveSong(long userid, String passhash, long songid) {
  		log.debug("Transferring song "+songid+" to client.");
 		
 		IUser user = _dao.getUserById(userid);
 		if (passhash!=null && passhash.equals(user.getPassword())) { //Check MD5-sum
 			Song song = _dao.getSongById(songid);
 			File songfile = song.getLink().getFile();
 			String songlink = songfile.getAbsolutePath();
 			String namePart = songlink.substring(songlink.lastIndexOf(File.separator)+1);
         	_response.setHeader("Content-Disposition","attachment; filename="+namePart.replaceAll(" ","_"));
 			
         	OutputStream out = null;
 			try {
 				out = _response.getOutputStream(new ContentType("audio/mpeg"));
 				InputStream in = null;
 				try {
 					in = new FileInputStream(songfile);
 					FileOperations.copyStream(in,out);
 					StreamMaster.getDJByUser(userid).getMusiController().
 					saveSongEvent(songid,Event.downloaded,userid,new Date());
 				} catch (IOException e) {
 					log.error("Error copying file to downloadstream. "+e);
 				} finally {
 					try {
 						if (in!=null) in.close();
 					} catch(IOException e) {
 						log.error("Error closing inputstream. "+e);
 					}
 				}
 			} catch (Exception e) {
 				log.fatal("Error while transferring song to client.");
 			} finally {
 				try {
 					if (out!=null) out.close();
 				} catch (IOException e) {
 					log.error("Error closing outputstream "+e);
 				}
 			}
 		} else {
 			log.debug("False credentials provided, ignoring download-request.");
 		}
 	}
 
 	/**
 	 * Copies the musical contents of a Playlist to the response, if userid and
 	 * passhash match AND the user is logged on. After the complete transfer of
 	 * the Playlist, a Downloaded-Event is added to each of its Songs.
 	 * @param userid The user
 	 * @param passhash The passhash of the user.
 	 * @param playlistid The id of the Playlist to download.
 	 */
 	private void servePlaylist(long userid, String passhash, long playlistid) {
 		log.debug("Transferring playlist "+playlistid+" to client.");
 		
 		if (StreamMaster.getDJByUser(userid)!=null) { //User is logged on
 			IUser user = _dao.getUserById(userid);
 			if (passhash!=null && passhash.equals(user.getPassword())) { //Check MD5-sum
 	        	//Copy playlist contents to a songlist, so we use the Playlist-object
 	        	//as short as possible. This way, we prevent concurrentmodificationerrors
 	        	//and such when downloading and editting the same playlist at the same time.
 	        	Playlist playlist = _dao.getPlaylistById(playlistid, user);
 	        	Map<Long,Date> songidset = new HashMap<Long,Date>();
 	        	List<Long> songidlist = new LinkedList<Long>();
 	        	for (Contract_PS psc : playlist.getSongs()) {
 	        		songidset.put(psc.getSong().getId(),null);
 	        		songidlist.add(psc.getSong().getId());
 	        	}
 	        	
 	        	_response.setHeader("Content-Disposition","attachment; filename="+playlist.getName().replaceAll(" ","_")+".zip");
 	        	OutputStream out = null;
 				try {
 					out = _response.getOutputStream(new ContentType("application/zip"));
 					
 					outputPlaylist(playlist.getName(), out,songidlist,songidset);
 					//Save the songevents all at once (if the download was aborted (exception thrown!), no download-events are written)
 					
 					for (Map.Entry<Long,Date> es : songidset.entrySet()) {
 						StreamMaster.getDJByUser(userid).getMusiController().
 							saveSongEvent(es.getKey(),Event.downloaded,userid,es.getValue());
 					}
 				} catch (Exception e) {
 					log.fatal("Error while transferring playlist to client.");
 				} finally {
 					try {
 						if (out!=null) out.close();
 					} catch (IOException e) {
 						log.error("Error closing outputstream "+e);
 					}
 				}
 			} else {
 				log.debug("False credentials provided, ignoring download-request.");
 			}
 		} else {
 			log.debug("This user has not logged on, ignoring download-request.");
 		}
 	}
 	
 	public String getName() {
 		return SERVICE_NAME;
 	}
 
     public void setLinkFactory(LinkFactory linkFactory) {
         _linkFactory = linkFactory;
     }
 
     public void setResponse(WebResponse response) {
         _response = response;
     }
     
     public void setDao(Dao dao) {
         _dao = dao;
     }
     
     /**
      * Outputs all songs in the songidlist as one zip-archive to the OutputStream.
      * A m3u-file, containing the Playlist is added as well. Songs that appear
      * more than once in the playlist are listed likewise in the m3u-file, but
      * the corresponding mp3-file is only contained once in the .zip-file.
      * This method modifies the songidlist such, that afterwards all Entries have
      * a Date, which is the moment that the streaming finished.
      * @param playlistname The name of the playlist
      * @param out The stream to write the songs to
      * @param songidlist All id's of the songs in the playlist, in order of appearence
      * @param songidset The map of (songid,downloaddate) pairs
      */
     private void outputPlaylist(String playlistname, OutputStream out, List<Long> songidlist, Map<Long,Date> songidset) {
     	//TODO output the albumcover as well
     	List<String> m3uContents = new LinkedList<String>();
     	m3uContents.add("#EXTM3U");
 		ZipOutputStream zout = null;
 		
 		try {
 			CheckedOutputStream checksum = new CheckedOutputStream(out, new Adler32());
 			zout = new ZipOutputStream(new BufferedOutputStream(checksum));
 
 			for (Long songId : songidlist) {
 				Song song = _dao.getSongById(songId);
 				File songfile = song.getLink().getFile();
 				String songlink = songfile.getAbsolutePath();
 				String ext = songlink.substring(songlink.lastIndexOf("."));
 				String name = FileOperations.translateIllegalFileChars(song.getBand().getName() +" - " +song.getName());
 				String filename = name+ext;
 				
 				m3uContents.add("#EXTINF:" + song.getLength()/1000 + "," + name);
 				m3uContents.add(filename);
 				
 				if (songidset.get(songId)==null) { // Output the song itself only once even if it is contained multiple times within the playlist.
 					ZipEntry ze = new ZipEntry(filename);
 					zout.putNextEntry(ze);
 					InputStream in = null;
 					try {
 						in = new FileInputStream(songfile);
 						FileOperations.copyStream(in,zout);
 						songidset.put(songId ,new Date());
 					} catch (IOException e) {
 						log.error("Error copying file to downloadstream. "+e);
 					} finally {
 						try {
 							if (in!=null) in.close();
 						} catch(IOException e) {
 							log.error("Error closing inputstream. "+e);
 						}
 					}
 				}
 				_dao.evict(song);
 			}
 			ZipEntry ze = new ZipEntry(playlistname+".m3u");
 			zout.putNextEntry(ze);
 			PrintStream ps = new PrintStream(zout);
 			for (String m3uLine : m3uContents) {
 				ps.println(m3uLine);
 			}
 			ps.flush();
 			
 			zout.close();
 		} catch (IOException e) {
 			log.error("Error streaming playlist: "+e);
 			songidset.clear(); //Do not save download-events.
 		}
     }
     
 }