/*
    * Replica is published under the terms
    * of the Apache Software License.
    */
   package replica.database.commands;
   
   import java.sql.Connection;
   import java.sql.DriverManager;
   import java.sql.SQLException;
  import java.sql.Statement;
  
  import javax.sql.DataSource;
  
  import replica.command.Command;
  import replica.core.ApplicationCommandProcessor;
  import replica.core.ApplicationMessage;
  import replica.session.Session;
  import replica.session.SessionManager;
  
  /***
   * It extends the application standart processor, to provide some
   * database specific services.
   *  
   * @author Pedro Costa
   * @author Helder Silva
   * @since 20/Jan/2004
   */
  public class DatabaseCommandProcessor extends ApplicationCommandProcessor {
  
  	private DataSource dataSource;
  	private SessionManager sessionManager;
  	
  	final static String CONNECTION = "CONNECTION";
  	
  	/***
  	 * 
  	 */
  	public DatabaseCommandProcessor() {
  		super();
  	}
  
  	protected Object executeCommand(Command command, ApplicationMessage appMsg){
  		
  		if( command instanceof DatabaseCommand )
  			return executeCommand( (DatabaseCommand)command, appMsg);
  
  		return super.executeCommand( command, appMsg);		
  	}
  	
  	protected Object executeCommand(DatabaseCommand command, ApplicationMessage appMsg){
  		
  		Statement st = null;
  		Connection connection = null;
  		
  		try{
  			
  			connection = getConnection(appMsg.getSessionID());
  			
  			return command.execute( 
  				new DatabaseCommandVO(connection,appMsg.getBody().toString()) );		
  		}
  		catch(SQLException e){
  			if( connection != null )
  				destroyConnection( connection , appMsg.getSessionID() );
  			throw new RuntimeException(e);
  		}
  	}
  
  	private void destroyConnection( Connection connection, String userSessionID ){
  		
  		sessionManager.getSession( userSessionID ).removeObject( connection );
  		
  		try{
  			connection.close();
  		}
  		catch(SQLException e){
  			e.printStackTrace();
  		}
  	}
  	
  	/***
  	 * It tries to get a connection from the user session. If it can find one, a
  	 * new one is created and put on session.
  	 * 
  	 * @param sessionId
  	 * @return a connection for the user.
  	 */
  	Connection getConnection(String sessionId) throws SQLException{
  		
  		Session session = sessionManager.getSession(sessionId);
  		
  		Connection connection = (Connection)session.getObject(CONNECTION);
  		
  		if( connection == null ){
  			
  			connection = getConnection(session.getUserId(), session.getUserPassword());
  			
  			session.putObject(CONNECTION, connection);
  		}
 		
 		return connection;
 	}
 	
 	/***
 	 * Returns a connection from the data source for the given user
 	 * and password.
 	 * 
 	 * If user is null or empty, DataSource.getConnection is used,
 	 * otherwise, DataSource.getConnection(String user, String password)
 	 * is called.
 	 * 
 	 * IMPLEMENTATION NOTE: the jakarta commons dbcp BasicDataSource does
 	 * note support the getConnection(String user, String password).
 	 * Use the Spring provided DriverManagerDataSource
 	 * witch does not provide a connection pool service.
 	 * 
 	 * @param userId
 	 * @param password
 	 * @return
 	 * @throws SQLException if something goes wrong!
 	 */
 	Connection getConnection(String userId, String password) throws SQLException{
 		
 		Connection c = null;
 		
 		// TODO re-think this to provide a connection pool.
 		//  the jakarta commons dbcp does not support getConnection(user,pwd).
 		
 		if( userId == null || userId.trim().length() == 0 )
 			c = getDataSource().getConnection();
 		else
 			c = getDataSource().getConnection(userId, password);
 			
 		if( !c.getAutoCommit() )
 			c.setAutoCommit(true);
 			
 		return c;
 	}
 	
 	Connection getNewConnectionFromDriverManager(String driverName, 
 		String url, String user, String pwd) throws SQLException{
 		
 		try{
 			Class.forName ( driverName );
 		}
 		catch(ClassNotFoundException e){
 			throw new RuntimeException(e);		
 		}
 		
 		if( pwd == null )
 			pwd = "";
 
 		return DriverManager.getConnection (url, user, pwd); 
 	}
 
 	/***
 	 * @return
 	 */
 	public DataSource getDataSource() {
 		return dataSource;
 	}
 
 	/***
 	 * @return
 	 */
 	public SessionManager getSessionManager() {
 		return sessionManager;
 	}
 
 	/***
 	 * @param source
 	 */
 	public void setDataSource(DataSource source) {
 		dataSource = source;
 	}
 
 	/***
 	 * @param manager
 	 */
 	public void setSessionManager(SessionManager manager) {
 		sessionManager = manager;
 	}
 
 }