/*
    * Replica is published under the terms
    * of the Apache Software License.
    */
   package replica.server;
   
   import java.io.BufferedReader;
   import java.io.BufferedWriter;
   import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.net.Socket;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import replica.command.*;
  import replica.core.ApplicationMessage;
  import replica.session.SessionManager;
  
  /***
   * @author Pedro Costa
   * @author Helder Silva
   * @since 15/Jan/2004
   */
  public class ServerProcess implements Runnable {
  	
  	static Logger logger = Logger.getLogger(ServerProcess.class.getName());
  	
  	private Socket socket;
  	private boolean alive = true;
  	private CommandProcessor commandProcessor;
  	private SessionManager sessionManager;
  	private BufferedWriter writer;
  	
  	String sessionId;
  	
  	private final static char RETURN = '\r';
  	private final static char NEW_LINE = '\n';
  	private final static char SPACE = ' ';
  	private char endOfCommand = ';';
  	
  	/***
  	 * Default constructor.
  	 *
  	 */
  	public ServerProcess(){
  		super();
  	}
  	
  	/***
  	 * Start a new session connected to the process.
  	 *
  	 */
  	void initSession(){
  		sessionId = sessionManager.createSession(null, null);
  		sessionManager.getSession(sessionId).putObject("SERVER_PROCESS", this);
  		
  		logger.log(Level.INFO,"Created session id:[" + sessionId + "] for " + remoteAddressToString() + ".");
  	}
  	
  	/***
  	 * Constructor that receives the socket to be used by this server process.
  	 * 
  	 * @param socket
  	 */
  	public ServerProcess( Socket socket ){
  		this();
  		setSocket( socket );
  	}
  
  	/* (non-Javadoc)
  	 * @see java.lang.Runnable#run()
  	 */
  	public void run() {
  		try{
  			initSession();
  			processStream( getSocket().getInputStream() );
  		}
  		catch(IOException e){
  			e.printStackTrace();
  		}
  		finally{
  			logger.log(Level.INFO,"Lost connection to " + remoteAddressToString() + ".");
  			
  			if( getSocket() != null ){
  				try{ getSocket().close(); }catch(IOException e){ }
  			}
  			destroySession();
  		}
  	}
  	
  	/***
  	 * Process commands from the given input stream.
  	 */
  	void processStream(InputStream stream) throws IOException{
  		
  		BufferedReader reader = null;
  		
 		try{
 			
 			reader = new BufferedReader( new InputStreamReader( stream ) );
 			
 			int read = -1;
 			StringBuffer buffer = new StringBuffer();
 			while( ( read = reader.read() ) != -1 ){
 				if( read != NEW_LINE && read != RETURN ){
 					if( read == endOfCommand ){
 						buffer.append(SPACE).append((char)read);
 						logger.info("Received from "
 							+remoteAddressToString()+" msg ["
 							+buffer.toString()+"].");
 						ApplicationMessage msg = new ApplicationMessage(
 							sessionId, buffer.toString() );
 						msg.setOriginator(ApplicationMessage.SERVER_MODULE);
 						Object res = getCommandProcessor().process( msg );
 						if( res != null && res.toString().trim().length() > 0 )
 							sendResponse( res.toString() );
 						buffer = new StringBuffer();
 					}
 					else{
 						buffer.append((char)read);
 					}
 				}
 				else{
 					buffer.append( SPACE );
 				}
 			}
 			
 			// Connection Lost
 		}
 		finally{
 			if( reader != null ){
 				try{ reader.close(); }catch(Throwable t){ }
 			}
 		}
 	}
 	
 	public void sendResponse(String response){
 		
 		logger.info("Received response : [" + response + "].");
 		
 		try{
 			if( writer == null )
 				writer = new BufferedWriter( new OutputStreamWriter( 
 					getSocket().getOutputStream() ) );
 				
 			writer.write(response);
 			if(!response.endsWith("\n"));
 			writer.write("\n");
 			writer.flush();
 		}
 		catch(IOException e){
 			logger.log(
 				Level.SEVERE, "Problem sending message to user. msg:["+response+"], addr:" + remoteAddressToString(), e);
 		}
 	}
 	
 	public void destroySession(){
 		sessionManager.destroySession(sessionId);
 		logger.log(Level.INFO,"Removed session id:[" + sessionId + "] for " + remoteAddressToString() + ".");
 	}
 
 	/***
 	 * @return
 	 */
 	public Socket getSocket() {
 		return socket;
 	}
 
 	/***
 	 * @param socket
 	 */
 	public void setSocket(Socket socket) {
 		this.socket = socket;
 	}
 
 	/***
 	 * @return
 	 */
 	public synchronized boolean isAlive() {
 		return alive;
 	}
 
 	/***
 	 * @param b
 	 */
 	public synchronized void setAlive(boolean b) {
 		alive = b;
 	}
 	/***
 	 * @return
 	 */
 	public CommandProcessor getCommandProcessor() {
 		return commandProcessor;
 	}
 
 	/***
 	 * @param processor
 	 */
 	public void setCommandProcessor(CommandProcessor processor) {
 		commandProcessor = processor;
 	}
 	
 	/***
 	 * Returns the connected remote address as a string.
 	 * Mostly used for logging.
 	 * @return
 	 */
 	private String remoteAddressToString(){
 		if(getSocket() == null)
 			return "[]";
 			
 		return "[" + getSocket().getInetAddress() + ":" + getSocket().getPort() + "]"; 
 	}
 
 	/***
 	 * @return
 	 */
 	public SessionManager getSessionManager() {
 		return sessionManager;
 	}
 
 	/***
 	 * @param manager
 	 */
 	public void setSessionManager(SessionManager manager) {
 		sessionManager = manager;
 	}
 
 }