package org.musicontroller.streaming;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.OutputStream;
   import java.net.SocketException;
  import java.util.Map;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.log4j.Logger;
  import org.apache.tapestry.IRequestCycle;
  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.hibernate.HibernateException;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.Transaction;
  import org.musicontroller.DJ;
  import org.musicontroller.MusiControllerException;
  import org.musicontroller.core.Song;
  import org.musicontroller.security.IUser;
  import org.springframework.orm.hibernate3.SessionHolder;
  import org.springframework.transaction.support.TransactionSynchronizationManager;
  
  public class StreamService implements IEngineService {
  	private static final Logger log = Logger.getLogger(StreamService.class);
  
  	HttpServletRequest _req = null;
  	public HttpServletRequest getServletRequest() {
  		return _req;
  	}
  	public void setServletRequest(HttpServletRequest req) {
  		_req = req;
  	}
  
  	public static final String SERVICE_NAME = "stream";
  
  	/**
  	 * Indicates the metadata-interval in bytes. After every interval, the metadata
  	 * is copied to the stream.<br>This value is (mis)used for the buffersize of the
  	 * streaming-mechanism too.
  	 */
  	private static final int BUFFER_SIZE = 16384;
  
      private LinkFactory _linkFactory;
      private WebResponse _response;
  	
  	@SuppressWarnings("unchecked")
  	public ILink getLink(boolean post, Object parameter) {
          Map<String,String> parameters = (Map<String,String>) parameter;
          parameters.put(ServiceConstants.SERVICE, getName());
          
          return _linkFactory.constructLink(this, false, parameters, true);
  	}
  	
  	/*
  	 * Our NoOSIVFForStreamServiceFilter prevents us from getting a
  	 * DB-connection. This is good, because we would not want to have a
  	 * connection for each stream. There can be many streams, but we only have
  	 * so many parallel connections. Therefore, we do 'manual'
  	 * connection-handling in this method.
  	 *  
  	 * (non-Javadoc)
  	 * @see org.apache.tapestry.engine.IEngineService#service(org.apache.tapestry.IRequestCycle)
  	 */
  	public void service(IRequestCycle cycle) throws IOException {
  		boolean outputMetaData = "1".equals(cycle.getInfrastructure().getRequest().getHeader("Icy-MetaData"));
  		long userid = Long.parseLong(cycle.getParameter("userid"));
  		String passhash = cycle.getParameter("passhash");
  		
  		final DJ dj = StreamMaster.getDJByUser(userid);
  		if (dj==null) {
  			//Someone tries to open a stream without logging on to the application: No music for you!
  			log.error("User-ID: "+userid+" has not logged on, ignoring stream-request");
  			return;
  		}
  		
  		IUser user = dj.getUser();
  		if (passhash==null || !passhash.equals(user.getPassword())) {
  			log.debug("False credentials provided, ignoring stream-request.");
  		} else {
  			if (log.isDebugEnabled()) {
  				log.debug("Stream started for: "+getServletRequest().getRemoteAddr());
  				log.debug("Metadata requested: "+ (outputMetaData ? "yes" : "no"));
  				log.debug("User ID: "+userid);
  				log.debug("Metadata interval and buffer size: "+BUFFER_SIZE);
  			}
  			
  			Song song = null;
  			
  	        try {
 				ShoutcastOutputStream sout = new ShoutcastOutputStream(
 								initOutputStream(outputMetaData),
 								BUFFER_SIZE,
 								outputMetaData
 				);
 				MpegOutputStream out = new MpegOutputStream(sout);
 				
 				boolean doStream = true;
 				while (doStream) {
 					song = chooseSong(dj);
 					if (song!=null) {
 						log.debug("Selected new song for User ID: "+userid);
 						try {
 							dj.setPlaying(true);
 							long startTime = System.currentTimeMillis();
 							
 							sout.setMetadata(song.getBand().getName() +	" - " +	song.getName(),"");
 							streamSong(out,song,dj);
 							
 							long endTime = System.currentTimeMillis();
 							long songDuration = endTime - startTime;
 							if(song.getLength()>songDuration*2) {
 								log.error("The song played in less than half its real length. Synchronization lost.");
 							} else {
 								dj.confirmPlay();
 							}
 						} catch (SkipException ske) {
 							dj.confirmSkip();
 						} catch (MusiControllerException mce) {
 							//Do nothing, just select a new file.
 							//TODO When no file exists, this will cause MC to try all files in the database
 							//TODO Maybe it is better to stop after 10 missing files, and to reset
 							//TODO this counter after one succesful streamSong()-call
 							log.error(mce.getMessage());
 						} catch (SocketException se) {
 							doStream = false;
 							//TODO Mark song as played if user listened more than 70% of it
 						}
 					}
 				}
 	        } catch (Exception e) { //User aborted the stream(?)
 				log.error(e);
 			}
 	
 			log.debug("Stream ended for User ID: "+userid);	
 			dj.setPlaying(false);
 		}
 	}
 	
 	/**
 	 * Surrounds the song-choosing with a Session.
 	 * @param dj The DJ.
 	 * @return The chosen Song.
 	 */
 	private Song chooseSong(final DJ dj) {
 		Song song = null;
 		SessionFactory factory = dj.getMusiController().getDao().getSessionFactory2();
 		Session session = factory.openSession();
 	    TransactionSynchronizationManager.bindResource(factory, new SessionHolder(session));
 		Transaction tx = session.beginTransaction();
 		try {
 			song=dj.choose();
 			File tmp = song.getLink().getFile(); //Nasty method to initialize the otherwise lazy property
 			log.debug(tmp.getAbsolutePath());
 			tx.commit();
 		} catch (HibernateException e) {
 			log.error(e.getMessage());
 			tx.rollback();
 		} finally {
 			session.close();
 			TransactionSynchronizationManager.unbindResource(factory);
 		}
 		return song;
 	}
 	
 	private OutputStream initOutputStream(boolean metadata) throws IOException {
 		OutputStream out = _response.getOutputStream(new ContentType("audio/mpeg"));
 		
 		//Spit out Shoutcast-headers.
 		_response.setHeader("icy-notice1","<BR>This stream requires <a href=\"http://www.winamp.com/\">Winamp</a><BR>");
 		_response.setHeader("icy-notice1","MusiController SHOUTcast-implementation<BR>");
 		_response.setHeader("icy-name","MusiController");
 		_response.setHeader("icy-genre","All sorts");
 		_response.setHeader("icy-url","http://musicontroller.sourceforge.net");
 		_response.setHeader("icy-pub","0");
 		if (metadata) _response.setIntHeader("icy-metaint",BUFFER_SIZE);
 		_response.setHeader("icy-br","192");
 		
 		log.debug("Outputstream initialized");
 		
 		return out;
 	}
 
 	private void streamSong(MpegOutputStream out, Song song, final DJ dj) throws IOException, SkipException, MusiControllerException {
 		InputStream in = null;
 		File songfile = song.getLink().getFile();
 		try {
 			in = new FileInputStream(songfile);
 			out.reset();
 			copy(in,out,
 				new IStreamController() {
 					public boolean mustSkip() {
 						return dj.mustSkip();
 					}
 					
 					public void setPlayingTime(int millis) {
 						dj.setPlayingTime(millis);
 					}
 				}
 			);
 		} catch (FileNotFoundException e) {
 			//ignore, so the next song will be played
 			String s = "File not found! "+songfile.getAbsolutePath();
 			log.fatal(s);
 			throw new MusiControllerException(s);
 		} finally {
 			if (in!=null) {
 				in.close();
 			}
 		}
 	}
 	
 	public String getName() {
 		return SERVICE_NAME;
 	}
 
     public void setLinkFactory(LinkFactory linkFactory) {
         _linkFactory = linkFactory;
     }
 
     public void setResponse(WebResponse response) {
         _response = response;
     }	
     
     /**
      * Copy method that can be interrupted by a DJ
      * @param in The inputstream
      * @param out The outputstream
      * @param controller The controller that can interrupt the copy-process
      * @throws IOException When something really goes wrong ;-)
      * @throws SkipException When an interrupt occured
      */
 	public void copy(InputStream in, MpegOutputStream out, IStreamController controller) throws IOException, SkipException {
 		log.debug("Streaming from inputstream...");
 		
 		int read;
 		byte[] buf = new byte[16384];
 
 		while ((read=in.read(buf,0,buf.length))!=-1) {
 			out.write(buf,0,read);
 			if (controller.mustSkip()) {
 				log.debug("Skiprequest received");
 				throw new SkipException();
 			}
 			controller.setPlayingTime(out.getStreamedLengthInMillis());
 		}
 		log.debug("Streaming from inputstream done.");
 	}
 	
 }