/**
    * Copyright 2005-2007 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.control.action;
  
  import org.figure8.join.util.LogUtil;
  import org.figure8.join.control.JoinAction;
  import org.figure8.join.control.form.SetupForm;
  import org.figure8.join.core.InfrastructureException;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.core.setup.BootstrapUtil;
  import org.figure8.join.core.setup.DatabaseDetails;
  import org.figure8.join.core.setup.BootstrapManager;
  import org.figure8.join.core.setup.ApplicationConfig;
  import org.figure8.join.core.persistence.ObjectDao;
  import org.figure8.join.core.persistence.XmlDatabinder;
  import org.figure8.join.businessobjects.security.Role;
  import org.figure8.join.businessobjects.security.User;
  import org.figure8.join.businessobjects.security.Permission;
  import org.figure8.join.businessfacades.security.UserManager;
  import org.figure8.join.businessfacades.security.PermissionManager;
  import org.figure8.join.view.UserView;
  
  import org.apache.commons.logging.Log;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  import org.apache.struts.action.ActionErrors;
  import org.apache.struts.action.ActionMessage;
  import org.apache.struts.Globals;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.io.InputStream;
  import java.io.IOException;
  import java.util.Collection;
  import java.util.Iterator;
  /**
   * Struts action used for setting up Join application
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @author <a href="mailto:vincent.huynen@gmail.com">Vincent Huynen</a>
   * @version $Revision: 1.3 $
   *
   * @struts.action path="/setup" name="setupForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/validationfailurepage.jsp"
   * @struts.action-forward name="Setup" path="/jsp/setup/setup.jsp"
   * @struts.action-forward name="Custom" path="/jsp/setup/setupcustom.jsp"
   * @struts.action-forward name="Standard" path="/jsp/setup/setupstandard.jsp"
   * @struts.action-forward name="Dissociated" path="/jsp/setup/setupsynchro.jsp"
   * @struts.action-forward name="OtherSideAccess" path="/jsp/setup/setupotherside.jsp"
   * @struts.action-forward name="DatabaseChoice" path="/jsp/setup/setupdatabasechoice.jsp"
   * @struts.action-forward name="Database" path="/jsp/setup/setupdatabase.jsp"
   * @struts.action-forward name="CustomAdmin" path="/jsp/setup/setupcustomadmin.jsp"
   * @struts.action-forward name="Failure" path="/jsp/servicefailure.jsp"
   */
  public class SetupActions extends JoinAction{
   
     // Static -------------------------------------------------------------------
     
     /** Get a commons logger. */
     private static Log log = LogUtil.getLog(SetupActions.class);
  
     /** Operation code for setting setup type */
     public static final String SETUP_TYPE_OP = "setType";
     /** Operation code for setting simple or dissociated installation */
     public static final String SETUP_MODE_OP = "setupMode";
     /** Operation code for setting synchronous property of installation */
     public static final String SETUP_SYNCH_OP = "setupSynch";
     /** Operation code for setting application other side properties */
     public static final String SETUP_OTHERSIDE_OP = "setupOtherSide";
     /** Operation code for setting administrator */
     public static final String SETUP_ADMIN_OP = "setupAdmin";
     /** Operation code for setting embedded database */
     public static final String SETUP_EMBED_OP = "setupEmbedded";
     /** Operation code for setting up external database */
     public static final String SETUP_EXTERN_OP = "setupExternal";
     /** Operation code for setting database details */
     public static final String SETUP_DATAB_OP = "setupDatabase";
     /** Operation code for setting datasource details */
     public static final String SETUP_DATAS_OP = "setupDatasource";
     /** Operation code for finishing setup process */
     public static final String SETUP_FINISH_OP = "finish";
  
  
     // Attributes ---------------------------------------------------------------
  
    /** Choosen setup type (first step of setup) */
    protected String setupType;
    /** Application bootstrap manager. */
    protected BootstrapManager bootstrapManager;
    /** Application configuration manager. */
    protected ApplicationConfig appConfiguration;
    /** Generic object dao for saving default entities */
    protected ObjectDao genericDao;
    /** Xml databinder for importing default entities from Xml */
    protected XmlDatabinder dataBinder;
    /** Join application user manager. */
    protected UserManager userManager;
    /** Join security permissions manager. */
    protected PermissionManager permissionManager;
 
 
    // Constructors -------------------------------------------------------------
    
    /** Creates a new instance of SetupActions */
    public SetupActions(){
    }
    
    
    // Public -------------------------------------------------------------------
    
    /** @param manager <code>BoostrapManager</code> instance */
    public void setBootstrapManager(BootstrapManager manager){
       this.bootstrapManager = manager;
    }
    /** @param config <code>ApplicationConfig</code> instance */
    public void setApplicationConfig(ApplicationConfig config){
       this.appConfiguration = config;
    }
    /** @param genericDao <code>ObjectDao</code> implementation instance */
    public void setObjectDao(ObjectDao genericDao){
       this.genericDao = genericDao;
    }
    /** @param dataBinder <code>XmlDatabinder</code> implementation instance */
    public void setXmlDatabinder(XmlDatabinder dataBinder){
       this.dataBinder = dataBinder;
    }
    /** @param manager <code>UserManager</code> implementation instance */
    public void setUserManager(UserManager manager){
       this.userManager = manager;
    }
    /** @param manager <code>PermissionManager</code> implementation instance */
    public void setPermissionManager(PermissionManager manager){
       this.permissionManager = manager;
    }
 
 
    // Override of JoinAction ---------------------------------------------------
    
    /**
     * Execute the requested operation within action.s
     * @param operation String representing the operation to invoke on Action
     * @param mapping Mapping between forwards name and path for this action
     * @param form The form object containing request parameters
     * @param request The servlet container request wrapper
     * @param response The servlet container response wrapper
     * @return A forward to the next view to render and display
     * @throws Exception is something wrong occurs
     */
    public ActionForward doExecute(String operation, ActionMapping mapping, ActionForm form,
                                   HttpServletRequest request, HttpServletResponse response) throws Exception{
       // Trace operation to execute.
       log.debug("doExecute() called for '" + operation + "' operation");
 
       if (SETUP_TYPE_OP.equals(operation)){
          return setupType(mapping, form, request, response);
       }
       else if (SETUP_MODE_OP.equals(operation)){
          return setupDissociation(mapping, form, request, response);
       }
       else if (SETUP_SYNCH_OP.equals(operation)){
          return setupSynchronisation(mapping, form, request, response);
       }
       else if (SETUP_OTHERSIDE_OP.equals(operation)){
          return setupOtherSideAccess(mapping, form, request, response);
       }
       else if (SETUP_ADMIN_OP.equals(operation)){
          return setupAdministrator(mapping, form, request, response);
       }
       else if (SETUP_EMBED_OP.equals(operation)){
          return setupEmbedded(mapping, form, request, response);
       }
       else if (SETUP_EXTERN_OP.equals(operation)){
          return mapping.findForward("Database");
       }
       else if (SETUP_DATAB_OP.equals(operation)){
          return setupDatabase(mapping, form, request, response);
       }
       else if (SETUP_DATAS_OP.equals(operation)){
          return setupDatasource(mapping, form, request, response);
       }
       else if (SETUP_FINISH_OP.equals(operation)){
          return finishSetup(mapping, form, request, response);
       }
       // This should not happen...
       return null;
    }
    
    
    // Protected ----------------------------------------------------------------
 
    /**
     * Save choosen setup type and forward according to this type.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupType(ActionMapping mapping, ActionForm form,
                                      HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       if (form instanceof SetupForm){
          // Retrieve BootstrapManager from util class.
          // This is necessary because Spring services are not already launched !
          setBootstrapManager(BootstrapUtil.getBootstrapManager());
 
          // Save setup type into application properties.
          setupType = ((SetupForm)form).getSetupType();
          bootstrapManager.setProperty(ApplicationConfig.SETUP_TYPE, setupType);
          log.info("Current setup type is now: '" + setupType + "'");
 
          // Before going further, ensure we have a db in standard mode.
          // Ensure also that we bootstrap the embedded messaging system.
          if (isStandardSetup()){
             log.info("Setup is standard. Bootstrap message broker and embedded database before registering admin...");
             bootstrapManager.bootstrapMessaging(null, true);
             log.info("Embedded messaging system has been bootstrapped.");
             DatabaseDetails details = DatabaseDetails.getDefault("hsqldb");
             bootstrapManager.bootstrapDatabase(details, true);
             log.info("Embedded database has been bootstrapped.");
          }
 
          return forward(mapping);
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save the installation dissociation mode : the setup is whether simple or dissociated
     * applications sides (one for synchronous services, one for asynchronous services)
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupDissociation(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                              HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          SetupForm sForm = (SetupForm)form;
          String isDissociated = ("Dissociated".equals(sForm.getSetupMode()) ? "true" : "false");
          // Record result into boostrap manager.
          bootstrapManager.setProperty(ApplicationConfig.DISSOCIATED, isDissociated);
 
          if (bootstrapManager.isDissociatedSetup()){
             // We now have to choose between synchronous or asynchronous side.
             log.info("Setup is custom & dissociated. Choose now the side of installation...");
             return mapping.findForward("Dissociated");
          }
          else{
             // We can now bootstrap the embedded messaging system.
             log.info("Setup is custom & simple mode. Bootstrap message broker before registering database and admin.");
             bootstrapManager.bootstrapMessaging(null, true);
             return mapping.findForward("DatabaseChoice");
          }
       }
       // This shoud not happen...
       return null;
    }
 
    /**
     * Save configuration of synchronous or asynchronous side.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupSynchronisation(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                                 HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          SetupForm sForm = (SetupForm)form;
          String isSynchronousSide = ("Synchronous".equals(sForm.getSetupSynch()) ? "true" : "false");
          // Record result into boostrap manager.
          bootstrapManager.setProperty(ApplicationConfig.SYNCH_SIDE, isSynchronousSide);
          // Forward to the page for configuring access to over side.
          return mapping.findForward("OtherSideAccess");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save configuration on how to access application other side
     * @return A forward to the next view to render and display
    */
   protected ActionForward setupOtherSideAccess(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                               HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          SetupForm sForm = (SetupForm)form;
          // Depending on setup mode, bootstrap message with different options.
          if (!bootstrapManager.isAsynchronousSide()){
             // We can now bootstrap the messaging connection factory.
             log.info("Setup is Custom, Dissociated & Synchronous. Bootstrap message broker connection...");
             bootstrapManager.bootstrapMessaging(sForm.getBrokerUrl(), false);
             bootstrapManager.setProperty(ApplicationConfig.OTHER_SIDE_URL, sForm.getHttpUrl());
             return mapping.findForward("DatabaseChoice");
          }
          else{
             // Compose a broker url using the port.
             String brokerUrl = "tcp://localhost:" + sForm.getBrokerPort();
             log.info("Setup is Custom, Dissociated & Asynchronous. Bootstrap message broker using URL: " + brokerUrl);
             bootstrapManager.bootstrapMessaging(brokerUrl, true);
             log.info("Embedded messaging system has been bootstrapped on port " + sForm.getBrokerPort());
             DatabaseDetails details = DatabaseDetails.getDefault("hsqldb");
             bootstrapManager.bootstrapDatabase(details, true);
             log.info("Embedded database has been bootstrapped (mandatory for registring Administrator).");
             return mapping.findForward("CustomAdmin");
          }
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Register administrator user into datastore. If setup type is standard,
     * the embedded database should first be boostrapped.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupAdministrator(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                               HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          // Context may have been refreshed and this action may be provided by Spring.
          // If we are in this case, we have to reload setup type for future forwards.
          if (setupType == null){
             log.info("Current setup type is null. Refreshing it from boostrap manager.");
             setupType = bootstrapManager.getProperty(ApplicationConfig.SETUP_TYPE);
             log.info("Current setup type is now: '" + setupType + "'");
          }
 
          // We can now create administrator.
          SetupForm sForm = (SetupForm)form;
          User admin = new User(sForm.getAdminName(), sForm.getAdminPassword(),
                                           sForm.getAdminLastname(), sForm.getAdminFirstname());
 
          try {userManager.saveUser(admin);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute("duplicate", dee.getOriginalEntity());
             return forward(mapping);
          }
 
          // Create default roles and permissions.
          createDefaultRolesAndPermissions(admin);
          // Import default entities into database.
          importDefaultEntitiesIntoDatabase();
          // Login administrator.
          UserView view = userManager.login(admin.getLogin(), sForm.getAdminPassword());
          getUserContainer(request).setView(view);
 
          // This is the end of the setup process. Just call the finishSetup() method.
          return finishSetup(mapping, form, request, response);
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Setup the embedded database and bootstrap Hibernate.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupEmbedded(ActionMapping mapping, ActionForm form,
                                          HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          log.info("Setup is Custom with embedded database. Bootstrapping it.");
          DatabaseDetails details = DatabaseDetails.getDefault("hsqldb");
          bootstrapManager.bootstrapDatabase(details, true);
          log.info("Embedded database has been bootstrapped.");
          // Forward to admin cutomisation.
          return mapping.findForward("CustomAdmin");
       }
       // This should not happen...
       return null;
    }
    
    /**
     * Setup the database access properties and bootstrap Hibernate.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupDatabase(ActionMapping mapping, ActionForm form,
                                          HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          // Create database details from form.
          SetupForm sForm = (SetupForm)form;
          DatabaseDetails details = new DatabaseDetails();
          // Fill in details.
          details.setUsername(sForm.getUserName());
          details.setPassword(sForm.getUserPassword());
          details.setDatabaseUrl(sForm.getDatabaseUrl());
          details.setDriverClassname(sForm.getDriverClassname());
          details.setDialect(sForm.getDialect());
          details.setPoolSize(sForm.getPoolSize());
          log.info("Setup is Custom with external database. Bootstrapping it on URL: " + details.getDatabaseUrl());
          try {bootstrapManager.bootstrapDatabase(details, false);}
          catch (Exception e){
             // Create error message using Struts mechanism.
             ActionErrors errors = new ActionErrors();
             ActionMessage msg = new ActionMessage(e.getMessage());
             errors.add(ActionErrors.GLOBAL_MESSAGE, msg);
             // Save our error messages and return to the input form if possible
             request.setAttribute(Globals.ERROR_KEY, errors);
             return mapping.findForward("Database");
          }
          // Forward to admin customisation.
          return mapping.findForward("CustomAdmin");
       }
       // This should not happen...
       return null;
    }
    
    /**
     * Setup the database access properties through datasource and bootstrap Hibernate.
     * @return A forward to the next view to render and display
     */
    protected ActionForward setupDatasource(ActionMapping mapping, ActionForm form,
                                            HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          // Get datasource details from form.
          SetupForm sForm = (SetupForm)form;
          String datasourceName = sForm.getDatasource();
          // Bottstrap on datasource.
          log.info("Setup is Custom with external datasource. Bootstrapping it on JNDI ds: " + datasourceName);
          try {bootstrapManager.bootstrapDatasource(datasourceName, sForm.getDialect());}
          catch (Exception e){
             // Create error message using Struts mechanism.
             ActionErrors errors = new ActionErrors();
             ActionMessage msg = new ActionMessage(e.getMessage());
             errors.add(ActionErrors.GLOBAL_MESSAGE, msg);
             // Save our error messages and return to the input form if possible
             request.setAttribute(Globals.ERROR_KEY, errors);
             return mapping.findForward("Database");
          }
          // Forward to admin customisation.
          return mapping.findForward("CustomAdmin");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Finish the setup process by telling the configuration manager that setup is
     * now complete. Save configuration and put context & request attributes telling
     * so before forwarding.
     * @return A forward to the next view to render and display
     */
    protected ActionForward finishSetup(ActionMapping mapping, ActionForm form,
                                        HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof SetupForm){
          log.info("Setup is complete. Saving application configuration...");
          // Tell the configuration that setup is complete and save it.
          appConfiguration.setSetupComplete(true);
          appConfiguration.save();
          log.info("Application configuration has been saved.");
 
          // Put context & request attributes before forwarding.
          servlet.getServletContext().setAttribute(ApplicationConfig.SETUP_COMPLETE, "true");
          request.setAttribute("step", "finish");
          return forward(mapping);
       }
       // This should not happen...
       return null;
    }
 
    /** @return True if the current setup type is a custom one */
    protected boolean isCustomSetup(){
       return (setupType != null && setupType.equals(ApplicationConfig.CUSTOM_TYPE));
    }
 
    /** @return True if the current setup type is a standard one */
    protected boolean isStandardSetup(){
       return (setupType != null && setupType.equals(ApplicationConfig.STANDARD_TYPE));
    }
 
 
    // Private ------------------------------------------------------------------
 
    /**
     * @param mapping The action mapping repository
     * @return An ActionForward corresponding to current setup type
     */
    private ActionForward forward(ActionMapping mapping){
       if (isCustomSetup())
          return mapping.findForward("Custom");
       else if (isStandardSetup())
          return mapping.findForward("Standard");
       else
          return mapping.findForward("Setup");
    }
 
    /**
     * Creates the Join default security roles and permission for admin
     * @param admin The newly created administration user.
     */
    private void createDefaultRolesAndPermissions(User admin) throws DuplicateEntityException{
       // Create defaults roles.
       permissionManager.saveRole(new Role(Role.DEFAULT_JOINER_ROLE, "Integration Team Member"));
       permissionManager.saveRole(new Role(Role.DEFAULT_ARCHITECT_ROLE, "Software Project Architect"));
 
       // Create administrator role and permission.
       Role administrator = new Role(Role.DEFAULT_ADMIN_ROLE, "Join Application Administrator");
       permissionManager.saveRole(administrator);
       permissionManager.savePermission(new Permission(administrator, admin.getLogin()));
    }
 
    /**
     * Import the default entities contained into an Xml file
     * @throws InfrastructureException if those entities cannot be created
     */
    private void importDefaultEntitiesIntoDatabase() throws InfrastructureException{
       try{
          InputStream is = getClass().getResourceAsStream("/join-entities.xml");
          Collection entities = dataBinder.loadFromXml(is);
          // Try replicating each objects.
          Iterator iterator = entities.iterator();
          while (iterator.hasNext()){
             Object entity = iterator.next();
             genericDao.replicate(entity);
          }
       }
       catch (IOException ioe){
          // Log and wrap into InfrastructureException.
          log.error("IOException while importing entities from /join-entities.xml");
          log.error("Here's the detailed message: " + ioe.getMessage());
          throw new InfrastructureException("IOException while importing default entities into database", ioe);
       }
    }
 }