package org.opensync.engine.server.connector;
   
   import java.sql.Connection;
   import java.sql.SQLException;
   
   import org.apache.commons.dbcp.BasicDataSource;
   import org.opensync.engine.server.DefaultConnector;
   import org.opensync.engine.server.OpenSync;
   import org.opensync.engine.server.OpenSyncException;
  import org.opensync.tools.ConnectionPool;
  import org.opensync.tools.PoolManager;
  import org.opensync.tools.Utils;
  
  /***
   * The connector used to connect to a database server
   */
  
  public class BDConnector extends DefaultConnector{
  	
  	BasicDataSource dataSource;
  	
    /***
     * The user login
     *
     */
    protected String user;
    /***
     * The jdbc driver
     *
     */
    protected String driver;
    /****/
    /***
     * The source
     *
     */
    protected String source;
    /***
     * The user password
     *
     *
     */
    protected String password;
    /***
     * The maximum of the opened connection
     *
     */
    protected int max;
    /***
     * The minimum of the opened connection
     *
     */
    protected int init;
    /***
     * The time out
     *
     */
    protected int timeout;
    /***
     * The operator for concatenation
     *
     */
    protected String operatorConcat;
  
    /***
     * The operator for conversion
     *
     */
    protected String conversion_function;
    private int windowSize;
  
    public BDConnector() {
    }
    
    /***
     * Construct a FileConnetor object
     *
     * @param source the source name
     */
    public BDConnector(String source) {
      this.source = source;
      this.type = BD;
    }
    /***
     * Set the user login used to connect to the database server
     *
     * @param user
     */
    public void setUser(String user) {
      this.user = user;
    }
    /***
     * Get the user login used to connect to the database server
     *
     */
    public String getUser() {
      return user;
    }
    /***
    * @param pwd
    */
   /****/
   /***
    * Set the jdbc driver
    *
    * @param driver
    */
   public void setDriver(String driver) {
     this.driver = driver;
   }
   /***
    * Get the jdbc driver
    *
    */
   public String getDriver() {
     return driver;
   }
   /***
    * @param url
    */
   /****/
   /***
    * Get the connection pool
    *
    * @exception SQLException
    */
   public ConnectionPool getConnectionPool()throws SQLException{
     try {
       if (Utils.debug) System.out.println("BDConnector::getConnectionPool - operatorConcat="+operatorConcat);
       //System.out.println("BDConnector::getConnectionPool source="+source);
       PoolManager poolManager = OpenSync.getInstance().getPoolManager();
       ConnectionPool pool = poolManager.getConnectionPool(source);
       if(pool == null){
          //System.out.println("BDConnector::getConnectionPool url="+url);
          //System.out.println("BDConnector::getConnectionPool driver="+driver);
          pool = poolManager.createPool(
           source,driver,url,user,password,max,init,timeout,null,operatorConcat, conversion_function
         );
       }
       // See the synchronized public String adaptOutputView(String xml,View view)throws IOException{
       // in BDAdapter
       pool.setAutocommit(false);
       // Set to false since we have not yet manage
       // in batch mode how to try an insert if an update fail !
       pool.setBatchmode(false);
       return pool;
     }
     catch (Exception ex) {
       throw new SQLException(ex.getMessage());
     }
   }
   /***
    * Set the user password used to connect to the file server
    *
    * @param password the password
    */
   public void setPassword(String password) {
     this.password = password;
   }
   /***
    * Get the user password used to connect to the database server
    *
    */
   public String getPassword() {
     return password;
   }
   /***
    * Set the maximum of the opened connection
    *
    * @param max the maximum
    */
   public void setMax(int max) {
     this.max = max;
   }
   /***
    * Get the maximum of the opened connection
    *
    */
   public int getMax() {
     return max;
   }
   /***
    * Set the minimum of the opened connection
    *
    * @param init
    */
   public void setInit(int init) {
     this.init = init;
   }
   /***
    * Get the minimum of the opened connection
    *
    */
   public int getInit() {
     return init;
   }
   /***
    * Set time-out
    *
    * @param timeout the timeout
    */
   public void setTimeout(int timeout) {
     this.timeout = timeout;
   }
   /***
    * Get the time out
    *
    */
   public int getTimeout() {
     return timeout;
   }
 
   public void validate() throws OpenSyncException {
     try {
       Connection conn = getConnectionPool().getConnection();
       getConnectionPool().freeConnection(conn);
     } catch (SQLException sqlex) {
       throw new OpenSyncException(sqlex.getMessage()+":\n\r"+this.toString());
     }
   }
 
   /***
    *
    * @return
    */
   public void release() throws SQLException {
     getConnectionPool().release();
     this.getAdapter().release();
   }
 
   /***
    *
    * @return
    */
   public void releaseWithException() throws SQLException {
     getConnectionPool().releaseWithException();
     this.getAdapter().releaseWithException();
   }
 
   /***
    * Use for debug only
    *
    */
   public String toString(){
     StringBuffer buffer = new StringBuffer();
     buffer.append("BDConnector{\n");
     buffer.append("\ttype : ").append(type).append("\n");
     buffer.append("\tsource : ").append(source).append("\n");
     buffer.append("\tuser : ").append(user).append("\n");
     buffer.append("\tpassword : ").append(password).append("\n");
     buffer.append("\tdriver : ").append(driver).append("\n");
     buffer.append("\turl : ").append(url).append("\n");
     buffer.append("\tmax : ").append(max).append("\n");
     buffer.append("\tinit : ").append(init).append("\n");
     buffer.append("\ttimeout : ").append(timeout).append("\n");
     buffer.append("\toperatorConcat : ").append(operatorConcat).append("\n");
     buffer.append("}\n");
     return buffer.toString();
   }
 
   /***
    * Set the operator for concatenation
    *
    * @param operatorConcat the operator
    */
   public void setOperatorConcat(String operatorConcat) {
     this.operatorConcat = operatorConcat;
   }
   /***
    * Get the operator for concatenation
    *
    */
   public String getOperatorConcat() {
     return operatorConcat;
   }
 
   /***
    * Set the conversion function
    *
    * @param operatorConcat conversion function
    */
   public void setConversionFunction(String sConversionFunction) {
     this.conversion_function = sConversionFunction;
   }
 
   /***
    * Get the conversion function
    *
    */
   public String getConversionFunction() {
     return conversion_function;
   }
   public int getWindowSize() {
     return windowSize;
   }
   public void setWindowSize(int windowSize) {
     this.windowSize = windowSize;
   }
 
 	/***
 	 * @param datasource The datasource to set.
 	 */
 	public void setDataSource(BasicDataSource dataSource) {
 		this.dataSource = dataSource;
 	}
 }