/*
    * Replica is published under the terms
    * of the Apache Software License.
    */
   package replica.server;
   
   import java.io.IOException;
   import java.net.*;
   import java.util.List;
  import java.util.Vector;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import org.springframework.context.ApplicationContext;
  
  /***
   * @author Pedro Costa
   * @author Helder Silva
   * @since 15/Jan/2004
   */
  public class Listener implements Runnable {
  	
  	static Logger logger = Logger.getLogger(Listener.class.getName());
  	
  	private int port = 7654; 
  	private boolean alive = true;
  	private List serverProcesses = new Vector();
  	
  	private ApplicationContext context;
  	private String serverProcessBeanId = "serverProcess";
  
  	ServerSocket server;
  	
  	/***
  	 * Default Constructor. 
  	 */
  	public Listener() {
  		super();
  	}
  	
  	public Listener(ApplicationContext context){
  		this();
  		setContext(context);
  	}
  
  	/* (non-Javadoc)
  	 * @see java.lang.Runnable#run()
  	 */
  	public void run() {
  		while(isAlive()){
  			try{
  				logger.log( Level.INFO, "Starting listener on port " + getPort() + ".");
  				
  				server = new ServerSocket(getPort());
  				
  				while( isAlive() ){
  					createNewServerProcess( server.accept() );
  				}
  			}
  			catch(IOException e){
  				e.printStackTrace();
  			}
  			finally{
  				logger.log( Level.INFO, "Stoping listener on port " + getPort() + ".");
  				
  				if( server != null ){
  					try{ server.close(); }catch(Throwable t){ }
  				}
  			}
  		}
  	}
  	
  	/***
  	 *  Create a new socket process for a new connection.
  	 * 
  	 * @param socket new connection.
  	 */
  	protected void createNewServerProcess( Socket socket ){
  		logger.log( Level.INFO, "Received connection on port " + getPort() + " from [" + socket.getInetAddress() + ":"+ socket.getPort() + "].");
  		
  		Thread t = new Thread( getNewServerProcess(socket) );
  		t.start();
  		getServerProcesses().add( t );
  		new Thread( new Monitor( t ) ).start();
  	}
  	
  	protected ServerProcess getNewServerProcess( Socket socket ){
  		
  		ServerProcess serverProcess = (ServerProcess)getContext().getBean(getServerProcessBeanId());
  		serverProcess.setSocket( socket );
  		return serverProcess;
  	}
  
  	/***
  	 * @return
  	 */
  	public int getPort() {
  		return port;
  	}
 
 	/***
 	 * @param i
 	 */
 	public void setPort(int i) {
 		port = i;
 	}
 
 	/***
 	 * @return
 	 */
 	public synchronized  boolean isAlive() {
 		return alive;
 	}
 
 	/***
 	 * @param b
 	 */
 	public synchronized  void setAlive(boolean b) {
 		alive = b;
 	}
 	
 	/***
 	 * Stops the listener;
 	 *
 	 */
 	public synchronized void stop(){
 		if( isAlive() ){
 			setAlive( false );
 			Socket s = null;
 			try{
 				s = new Socket("localhost", getPort());
 			}
 			catch(IOException e){
 				logger.log( Level.WARNING, e.getMessage(), e );
 			}
 			finally{
 				if ( s != null ){ try{ s.close(); }catch(IOException e){} }
 			}
 		}
 	}
 
 	/***
 	 * @return
 	 */
 	public List getServerProcesses() {
 		return serverProcesses;
 	}
 
 	/***
 	 * @param list
 	 */
 	private void setServerProcesses(List list) {
 		serverProcesses = list;
 	}
 	
 	/***
 	 * Simple Monitor for when a Server Process ends,
 	 *  and remove it from the list of running processes.
 	 * 
 	 * @author Pedro Costa
 	 * @version 16/Jan/2004 - 23:58:07
 	 */
 	private class Monitor implements Runnable{
 		// the thread to be monitored
 		Thread master;
 		Monitor( Thread t ){
 			master = t;
 		}
 		
 		public void run(){
 			if( master != null ){
 				try{
 					master.join();
 				}
 				catch(InterruptedException e){
 				}
 				
 				getServerProcesses().remove( master );
 				
 				logger.log( Level.FINE, "Removed server process.");
 			}
 		}
 	}
 
 	/***
 	 * @return
 	 */
 	public ApplicationContext getContext() {
 		return context;
 	}
 
 	/***
 	 * @param context
 	 */
 	public void setContext(ApplicationContext context) {
 		this.context = context;
 	}
 
 	/***
 	 * @return
 	 */
 	public String getServerProcessBeanId() {
 		return serverProcessBeanId;
 	}
 
 	/***
 	 * @param string
 	 */
 	public void setServerProcessBeanId(String string) {
 		serverProcessBeanId = string;
 	}
 
 }