/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic License, Version 2.0 (the
    * "License"); you may not use this file except in compliance with
    * the License. You may obtain a copy of the License at
    *
    *      http://www.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.core.setup;
  
  import org.figure8.join.util.LogUtil;
  import org.figure8.join.util.ConnectionKeeperLauncher;
  
  import org.apache.commons.logging.Log;
  
  import javax.sql.DataSource;
  import javax.naming.InitialContext;
  
  import java.io.File;
  import java.net.URI;
  import java.net.Socket;
  import java.net.ServerSocket;
  import java.net.InetAddress;
  import java.sql.Connection;
  import java.sql.DriverManager;
  /**
   * Manager object responsible of Join application bootstrapping.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   */
  public class BootstrapManager{
    
     // Static -------------------------------------------------------------------
     
     /** Get a commons logger. */
     protected static Log log = LogUtil.getLog(BootstrapManager.class);
     
     
     // Attributes ---------------------------------------------------------------
     
     /** Flag telling if bootstrap has succeed. */
     private boolean bootstrapped = false;
     /** Join application home locator. */
     private JoinHomeLocator homeLocator = null;
     /** Application configuration wrapper. */
     private ApplicationConfig appConfig = null;
     /** ActiveMQ configuration wrapper. */
     private ActiveMQConfigurator amqConfigurator = null;
     /** Hibernate configurator wrapper. */
     private HibernateConfigurator hbnConfigurator = null;
  
  
     // Constructors -------------------------------------------------------------
     
     /** Creates a new instance of BootstrapManager */
     public BootstrapManager(){
     }
     
     
     // Public -------------------------------------------------------------------
     
     /** @param locator <code>JoinHomeLocator</code> instance */
     public void setHomeLocator(JoinHomeLocator locator){
        this.homeLocator = locator;
     }
     /** @param config <code>ApplicationConfig</code> instance */
     public void setApplicationConfig(ApplicationConfig config){
        this.appConfig = config;
     }
     /** @param configurator <code>ActiveMQConfigurator</code> instance */
     public void setMessagingConfigurator(ActiveMQConfigurator configurator){
        this.amqConfigurator = configurator;
     }
     /** @param configurator <code>HibernateConfigurator</code> instance */
     public void setHibernateConfigurator(HibernateConfigurator configurator){
        this.hbnConfigurator = configurator;
     }
     
     
     // Spring lifecycle method --------------------------------------------------
     
     /**
      * Bootstrap the Join application ! First step is to try locating Join
      * home path. Then load application configuration.
      * @throws BootstrapException if Join home cannot be located or if parsing
      * the application configuration file failed.
      */
     public void bootstrap() throws BootstrapException{
        // First, check home path.
        if (homeLocator.getHomePath() != null){
           appConfig.setApplicationHome(homeLocator.getHomePath());
           // Then load application config.
           if (appConfig.configurationFileExists())
             appConfig.load();
       }
       else{
          log.error("Unable to set up application config : no join home set");
          throw new BootstrapException("Unable to boot application : no join home set");
       }
       // Update flag.
       bootstrapped = true;
    }
    
    
    // Public -------------------------------------------------------------------
 
    /**
     * Tell if bootstrap phase has ran ok.
     * @return boostrapped flag.
     */
    public boolean isBootstrapped(){
       return bootstrapped;
    }
 
    /**
     * Convenient method for knowing if application setup is complete.
     * @return The corresponding flag on {@code ApplicationConfig}
     */
    public boolean isSetupComplete(){
       // Delegate call to application configuration.
       return appConfig.isSetupComplete();
    }
    /**
     * Convenient method for knowing if application setup is a custom setup.
     * @return The corresponding flag on {@code ApplicationConfig}
     */
    public boolean isCustomSetup(){
       // Delegate call to application configuration.
       return appConfig.isCustomSetup();
    }
    /**
     * Convenient method for knowing if application setup is a standard setup.
     * @return The corresponding flag on {@code ApplicationConfig}
     */
    public boolean isStandardSetup(){
       // Delegate call to application configuration.
       return appConfig.isStandardSetup();
    }
    /**
     * Convenient method for knowing it activeMQ setup is complete.
     * @return true if the setup is complete, false otherwise
     */
    public boolean isMessagingSetup(){
       String setup = appConfig.getProperty(ActiveMQConfigurator.AMQ_SETUP_PROPERTY);
       if (setup != null && setup.equalsIgnoreCase("true"))
          return true;
       return false;
    }
    /**
     * Convenient method for knowing if hibernate setup is complete.
     * @return true if the setup is complete, false otherwise
     */
    public boolean isHibernateSetup(){
       String setup = appConfig.getProperty(HibernateConfigurator.HBN_SETUP_PROPERTY);
       if (setup != null && setup.equalsIgnoreCase("true"))
          return true;
       return false;
    }
 
    /** @return true if this side of application is synchronous */
    public boolean isSynchronousSide(){
       // Delegate call to application configuration.
       return appConfig.isSynchronousSide();
    }
    /** @return true if this side of application is asynchronous */
    public boolean isAsynchronousSide(){
       // Delegate call to application configuration.
       return appConfig.isAsynchronousSide();
    }
    /** @return true if this setup is custom with dissociation of synch/asynch services */
    public boolean isDissociatedSetup(){
       // Delegate call to application configuration.
       return appConfig.isDissociatedSetup();
    }
    /**
     * Convenient method for knowing the Url of application other side.
     * This url only exists if application has a dissociated setup type.
     * @return The url of the other side of application, or null if it has no sense...
     */
    public String getOtherSideUrl(){
       // Use the adhos property from ApplicationConfig.
       return appConfig.getProperty(ApplicationConfig.OTHER_SIDE_URL);
    }
 
    /**
     * Retrieve Join home location onto filesystem.
     * @return String representing Join home location (or null if not defined)
     */
    public String getJoinHome(){
       String joinHome = appConfig.getApplicationHome();
       if (joinHome == null)
          log.fatal("${join.home} has not been configured. Please check your join home configuration");
       // Return joinHome in all cases.
       return joinHome;
    }
 
    /**
     * Convenient method for retrieving application configuration property.
     * @param property The name of the property of retrieve
     * @return The value of the corresponding application property.
     */
    public String getProperty(String property){
       // Delegate call to application configuration.
       return appConfig.getProperty(property);
    }
    /**
     * Convenient method for setting an application config property.
     * @param key Unique id of the application property
     * @param value Value associated to key
     * @see org.figure8.join.core.setup.ApplicationConfig#setProperty(String, Object)
     */
    public void setProperty(String key, Object value){
       // Delegate call to application configuration.
       appConfig.setProperty(key, value);
    }
 
    /**
     * Convenient method for getting a path property that may contain the
     * ${join.home} string. This latter will be replaced by its value.
     * @param key Unique id of the application property
     * @return The value of the corresponding application path property.
     */
    public String getPathProperty(String key){
       // Retrieve property.
       String path = getProperty(key);
       if (path == null) return null;
       // Replace join home by its value.
       StringBuffer prop = new StringBuffer(path);
       int length = "${join.home}".length();
       for (int i=prop.indexOf("${join.home}"); i!=-1; i=prop.indexOf("${join.home}"))
          prop.replace(i, i + length, getJoinHome());
 
       return prop.toString();
     }
 
    /**
     * Bootstrap the database access system. This method first test the access
     * to database and them launch its configuration process within Hibernate.
     * @param details Database security details wrapper
     * @param embedded Tells if the db is the default embedded one
     * @throws BootstrapException if database cannot be reached or configured
     */
    public void bootstrapDatabase(DatabaseDetails details, boolean embedded) throws BootstrapException{
       try{
          // Ensure database directory is existing.
          // It is always used : if embedded or if on asycnhronous side.
          File database = new File(getJoinHome(), "database");
          if (!database.isDirectory()) database.mkdir();
 
          if (embedded){
             // Assign the database a file Url.
             String databasePath = getJoinHome() + "/database/joindb";
             details.setDatabaseUrl("jdbc:hsqldb:" + databasePath);
             log.debug("Database is embedded. Setting its Url to: " + details.getDatabaseUrl());
          }
          // Test connection before configuring it in Hibernate.
          testDatabaseConnection(details);
          hbnConfigurator.configureDatabase(details, embedded);
       }
       catch (Exception e){
          log.fatal("Unable to bootstrap database: \n db: " + details + " \n embedded: " + embedded);
          log.fatal("The exception message is: " + e.getMessage());
          throw new BootstrapException("Unable to bootstrap database !");
       }
       launchConnectionKeeper();
    }
 
    /**
     * Bootstrap the database access system through JNDI datasource. This method first
     * test the access to datasource and them launch its configuration process within Hibernate.
     * @param datasourceName JNDI name of datasource to use for accessing database
     * @param dialect Dialect of database to access (as Hibernate dialect)
     * @throws BootstrapException if database cannot be reached or configured
     */
    public void bootstrapDatasource(String datasourceName, String dialect) throws BootstrapException{
       try{
          log.debug("Using a DataSource for connecting to database: " + datasourceName);
          // Test access before configuring it in Hibernate.
          testDatasourceAccess(datasourceName);
          hbnConfigurator.configureDatasource(datasourceName, dialect);
       }
       catch (Exception e){
          log.fatal("Unable to bootstrap on datasource: " + datasourceName + " with dialect " + dialect);
          log.fatal("The exception message is: " + e.getMessage());
          throw new BootstrapException("Unable to bootstrap on datasource !");
       }
    }
 
    /**
     * Bootstrap the messaging system. This method launches the configuration
     * process within AcitveMQ.
     * @param brokerUrl Messaging broker url
     * @param embedded Tells if the messaging broker is on this side of application
     * @throws BootstrapException if connection to messaging system cannot be configured
     */
    public void bootstrapMessaging(String brokerUrl, boolean embedded) throws BootstrapException{
       try{
          if (embedded && brokerUrl == null){
             // Find the port for the embedded broker.
             int port = 61626;
             boolean found = false;
             while (!found && port < 65635){
                brokerUrl = "tcp://localhost:" + port;
                // Test connection on this port ...
                try{
                   testBrokerConnection(new URI(brokerUrl));
                   found = true;
                }
                catch (Exception e) {port++;}
             }
             log.debug("Messaging broker is embedded. Setting its Url to: " + brokerUrl);
          }
          else{
             // Test the connection with brokerUrl as is...
             testBrokerConnection(new URI(brokerUrl));
          }
          // Configure messaging system in ActiveMQ.
          amqConfigurator.configureMessaging(brokerUrl);
       }
       catch (Exception e){
          log.fatal("Unable to bootstrap messaging system");
          log.fatal("The exception message is: " + e.getMessage());
          throw new BootstrapException("Unable to bootstrap messaging system !");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
    
    /**
     * Test the connection to configured database.
     * @param details Database details wrapper for connection params
     */
    protected void testDatabaseConnection(DatabaseDetails details) throws Exception{
       Connection conn = null;
       log.info("Testing the connection to database...");
       
       try{
          // Just try opening a connection to db.
          Class.forName(details.getDriverClassname());
          conn = DriverManager.getConnection(details.getDatabaseUrl(), details.getUsername(), details.getPassword());
          log.info("Test connection has succeed !");
       }
       catch (Exception e){
          // Log a message and print stack trace.
          log.error("Exception while testing database connection: " + e.getMessage());
          e.printStackTrace();
       }
       finally{
          try{
             // Just try closing the connection.
             conn.close();
          }
          catch (Exception e){
             // Log a message and propagates exception.
             log.error("The connection opened for testing database cannot be closed !");
             throw e;
          }
       }
    }
 
    /**
     * Test the access to configured datasource
     * @param datasourceName JNDI name of datasource to access
     */
    protected void testDatasourceAccess(String datasourceName) throws Exception{
       log.info("Testing the access to datasource...");
       // Retrieve object into JNDI context.
       InitialContext ctx = new InitialContext();
       Object obj = ctx.lookup(datasourceName);
       DataSource ds = (DataSource)obj;
       log.info("Test datasource has succeed ! (" + ds + ")");
    }
 
    /**
     * Test the connection to broker denoted by <b>brokerUri</b>. If URI denotes
     * localhost, we have to test broker from server side point of view (ie. using
     * a ServerSocket).
     * @param brokerUri The URI of broker to test connection to
     */
    protected void testBrokerConnection(URI brokerUri) throws Exception{
       Socket client = null;
       ServerSocket server = null;
       log.info("Testing the connection to broker...");
 
       try{
          // Determine if we are on client or server with host.
          String host = brokerUri.getHost();
          InetAddress addr = InetAddress.getByName(host);
          // We have to test the server side.
          if (host.trim().equals("localhost") || addr.equals(InetAddress.getByName("localhost"))){
             server = new ServerSocket(brokerUri.getPort());
             server.setReuseAddress(true);
          }
          // We are on the client side.
          else
             client = new Socket(brokerUri.getHost(), brokerUri.getPort());
       }
       catch (Exception e){
          // Log a message and print stack trace.
          log.error("Exception while testing broker connection: " + e.getMessage());
          e.printStackTrace();
       }
       finally{
          try{
             if (client != null) client.close();
             if (server != null) server.close();
          }
          catch (Exception e){
             // Log a message and propagates exception.
             log.error("The connection opened for testing broker cannot be closed !");
             throw e;}
       }
    }
 
    /** Launch the ConnectionKeeper daemon. */
    protected void launchConnectionKeeper(){
       ConnectionKeeperLauncher.startConnectionKeeperIfNecessary();
    }
 }