/*
    * $Id: TilesPlugin.java 471754 2006-11-06 14:55:09Z husted $
    *
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache 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.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package org.apache.struts.tiles;
  
  import java.util.Map;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.UnavailableException;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.struts.action.ActionServlet;
  import org.apache.struts.action.PlugIn;
  import org.apache.struts.action.RequestProcessor;
  import org.apache.struts.chain.ComposableRequestProcessor;
  import org.apache.struts.config.ControllerConfig;
  import org.apache.struts.config.ModuleConfig;
  import org.apache.struts.config.PlugInConfig;
  import org.apache.struts.util.RequestUtils;
  
  /**
   * Tiles Plugin used to initialize Tiles.
   * This plugin is to be used with Struts 1.1 in association with
   * {@link TilesRequestProcessor}.
   * <br>
   * This plugin creates one definition factory for each Struts-module. The definition factory
   * configuration is read first from 'web.xml' (backward compatibility), then it is
   * overloaded with values found in the plugin property values.
   * <br>
   * The plugin changes the Struts configuration by specifying a {@link TilesRequestProcessor} as
   * request processor. If you want to use your own RequestProcessor,
   * it should subclass TilesRequestProcessor.
   * <br>
   * This plugin can also be used to create one single factory for all modules.
   * This behavior is enabled by specifying <code>moduleAware=false</code> in each
   * plugin properties. In this case, the definition factory
   * configuration file is read by the first Tiles plugin to be initialized. The order is
   * determined by the order of modules declaration in web.xml. The first module
   * is always the default one if it exists.
   * The plugin should be declared in each struts-config.xml file in order to
   * properly initialize the request processor.
   * @since Struts 1.1
   */
  public class TilesPlugin implements PlugIn {
  
      /**
       * Commons Logging instance.
       */
      protected static Log log = LogFactory.getLog(TilesPlugin.class);
  
      /**
       * Is the factory module aware?
       */
      protected boolean moduleAware = false;
  
      /**
       * Tiles util implementation classname. This property can be set
       * by user in the plugin declaration.
       */
      protected String tilesUtilImplClassname = null;
  
      /**
       * Associated definition factory.
       */
      protected DefinitionsFactory definitionFactory = null;
  
      /**
       * The plugin config object provided by the ActionServlet initializing
       * this plugin.
       */
      protected PlugInConfig currentPlugInConfigObject=null;
  
      /**
       * Get the module aware flag.
       * @return <code>true</code>: user wants a single factory instance,
       * <code>false:</code> user wants multiple factory instances (one per module with Struts)
       */
      public boolean isModuleAware() {
          return moduleAware;
     }
 
     /**
      * Set the module aware flag.
      * This flag is only meaningful if the property <code>tilesUtilImplClassname</code> is not
      * set.
      * @param moduleAware <code>true</code>: user wants a single factory instance,
      * <code>false:</code> user wants multiple factory instances (one per module with Struts)
      */
     public void setModuleAware(boolean moduleAware) {
         this.moduleAware = moduleAware;
     }
 
     /**
      * <p>Receive notification that the specified module is being
      * started up.</p>
      *
      * @param servlet ActionServlet that is managing all the modules
      *  in this web application.
      * @param moduleConfig ModuleConfig for the module with which
      *  this plugin is associated.
      *
      * @exception ServletException if this <code>PlugIn</code> cannot
      *  be successfully initialized.
      */
     public void init(ActionServlet servlet, ModuleConfig moduleConfig)
         throws ServletException {
 
         // Create factory config object
         DefinitionsFactoryConfig factoryConfig =
             readFactoryConfig(servlet, moduleConfig);
 
         // Set the module name in the config. This name will be used to compute
         // the name under which the factory is stored.
         factoryConfig.setFactoryName(moduleConfig.getPrefix());
 
         // Set RequestProcessor class
         this.initRequestProcessorClass(moduleConfig);
 
         this.initTilesUtil();
 
         this.initDefinitionsFactory(servlet.getServletContext(), moduleConfig, factoryConfig);
     }
 
     /**
      * Set TilesUtil implementation according to properties 'tilesUtilImplClassname'
      * and 'moduleAware'.  These properties are taken into account only once. A
      * side effect is that only the values set in the first initialized plugin are
      * effectively taken into account.
      * @throws ServletException
      */
     private void initTilesUtil() throws ServletException {
 
         if (TilesUtil.isTilesUtilImplSet()) {
             return;
         }
 
         // Check if user has specified a TilesUtil implementation classname or not.
         // If no implementation is specified, check if user has specified one
         // shared single factory for all module, or one factory for each module.
 
         if (this.getTilesUtilImplClassname() == null) {
 
             if (isModuleAware()) {
                 TilesUtil.setTilesUtil(new TilesUtilStrutsModulesImpl());
             } else {
                 TilesUtil.setTilesUtil(new TilesUtilStrutsImpl());
             }
 
         } else { // A classname is specified for the tilesUtilImp, use it.
             try {
                 TilesUtilStrutsImpl impl =
                     (TilesUtilStrutsImpl) RequestUtils
                         .applicationClass(getTilesUtilImplClassname())
                         .newInstance();
                 TilesUtil.setTilesUtil(impl);
 
             } catch (ClassCastException ex) {
                 throw new ServletException(
                     "Can't set TilesUtil implementation to '"
                         + getTilesUtilImplClassname()
                         + "'. TilesUtil implementation should be a subclass of '"
                         + TilesUtilStrutsImpl.class.getName()
                         + "'");
 
             } catch (Exception ex) {
                 throw new ServletException(
                     "Can't set TilesUtil implementation.",
                     ex);
             }
         }
 
     }
 
     /**
      * Initialize the DefinitionsFactory this module will use.
      * @param servletContext
      * @param moduleConfig
      * @param factoryConfig
      * @throws ServletException
      */
     private void initDefinitionsFactory(
         ServletContext servletContext,
         ModuleConfig moduleConfig,
         DefinitionsFactoryConfig factoryConfig)
         throws ServletException {
 
         // Check if a factory already exist for this module
         definitionFactory =
             ((TilesUtilStrutsImpl) TilesUtil.getTilesUtil()).getDefinitionsFactory(
                 servletContext,
                 moduleConfig);
 
         if (definitionFactory != null) {
             log.info(
                 "Factory already exists for module '"
                     + moduleConfig.getPrefix()
                     + "'. The factory found is from module '"
                     + definitionFactory.getConfig().getFactoryName()
                     + "'. No new creation.");
 
             return;
         }
 
         // Create configurable factory
         try {
             definitionFactory =
                 TilesUtil.createDefinitionsFactory(
                     servletContext,
                     factoryConfig);
 
         } catch (DefinitionsFactoryException ex) {
             log.error(
                 "Can't create Tiles definition factory for module '"
                     + moduleConfig.getPrefix()
                     + "'.");
 
             throw new ServletException(ex);
         }
 
         log.info(
             "Tiles definition factory loaded for module '"
                 + moduleConfig.getPrefix()
                 + "'.");
     }
 
     /**
      * End plugin.
      */
     public void destroy() {
         definitionFactory.destroy();
         definitionFactory = null;
     }
 
     /**
      * Create FactoryConfig and initialize it from web.xml and struts-config.xml.
      *
      * @param servlet ActionServlet that is managing all the modules
      *  in this web application.
      * @param config ModuleConfig for the module with which
      *  this plugin is associated.
      * @exception ServletException if this <code>PlugIn</code> cannot
      *  be successfully initialized.
      */
     protected DefinitionsFactoryConfig readFactoryConfig(
         ActionServlet servlet,
         ModuleConfig config)
         throws ServletException {
 
         // Create tiles definitions config object
         DefinitionsFactoryConfig factoryConfig = new DefinitionsFactoryConfig();
         // Get init parameters from web.xml files
         try {
             DefinitionsUtil.populateDefinitionsFactoryConfig(
                 factoryConfig,
                 servlet.getServletConfig());
 
         } catch (Exception ex) {
             if (log.isDebugEnabled()){
                 log.debug("", ex);
             }
             ex.printStackTrace();
             throw new UnavailableException(
                 "Can't populate DefinitionsFactoryConfig class from 'web.xml': "
                     + ex.getMessage());
         }
 
         // Get init parameters from struts-config.xml
         try {
             Map strutsProperties = findStrutsPlugInConfigProperties(servlet, config);
             factoryConfig.populate(strutsProperties);
 
         } catch (Exception ex) {
             if (log.isDebugEnabled()) {
                 log.debug("", ex);
             }
 
             throw new UnavailableException(
                 "Can't populate DefinitionsFactoryConfig class from '"
                     + config.getPrefix()
                     + "/struts-config.xml':"
                     + ex.getMessage());
         }
 
         return factoryConfig;
     }
 
     /**
      * Find original properties set in the Struts PlugInConfig object.
      * First, we need to find the index of this plugin. Then we retrieve the array of configs
      * and then the object for this plugin.
      * @param servlet ActionServlet that is managing all the modules
      *  in this web application.
      * @param config ModuleConfig for the module with which
      *  this plug in is associated.
      *
      * @exception ServletException if this <code>PlugIn</code> cannot
      *  be successfully initialized.
      */
     protected Map findStrutsPlugInConfigProperties(
         ActionServlet servlet,
         ModuleConfig config)
         throws ServletException {
 
         return currentPlugInConfigObject.getProperties();
     }
 
     /**
      * Set RequestProcessor to appropriate Tiles {@link RequestProcessor}.
      * First, check if a RequestProcessor is specified. If yes, check if it extends
      * the appropriate {@link TilesRequestProcessor} class. If not, set processor class to
      * TilesRequestProcessor.
      *
      * @param config ModuleConfig for the module with which
      *  this plugin is associated.
      * @throws ServletException On errors.
      */
     protected void initRequestProcessorClass(ModuleConfig config)
         throws ServletException {
 
         String tilesProcessorClassname = TilesRequestProcessor.class.getName();
         ControllerConfig ctrlConfig = config.getControllerConfig();
         String configProcessorClassname = ctrlConfig.getProcessorClass();
 
         // Check if specified classname exist
         Class configProcessorClass;
         try {
             configProcessorClass =
                 RequestUtils.applicationClass(configProcessorClassname);
 
         } catch (ClassNotFoundException ex) {
             log.fatal(
                 "Can't set TilesRequestProcessor: bad class name '"
                     + configProcessorClassname
                     + "'.");
             throw new ServletException(ex);
         }
 
         // Check to see if request processor uses struts-chain.  If so,
         // no need to replace the request processor.
         if (ComposableRequestProcessor.class.isAssignableFrom(configProcessorClass)) {
             return;
         }
 
         // Check if it is the default request processor or Tiles one.
         // If true, replace by Tiles' one.
         if (configProcessorClassname.equals(RequestProcessor.class.getName())
             || configProcessorClassname.endsWith(tilesProcessorClassname)) {
 
             ctrlConfig.setProcessorClass(tilesProcessorClassname);
             return;
         }
 
         // Check if specified request processor is compatible with Tiles.
         Class tilesProcessorClass = TilesRequestProcessor.class;
         if (!tilesProcessorClass.isAssignableFrom(configProcessorClass)) {
             // Not compatible
             String msg =
                 "TilesPlugin : Specified RequestProcessor not compatible with TilesRequestProcessor";
             if (log.isFatalEnabled()) {
                 log.fatal(msg);
             }
             throw new ServletException(msg);
         }
     }
 
     /**
      * Set Tiles util implemention classname.
      * If this property is set, the flag <code>moduleAware</code> will not be used anymore.
      * @param tilesUtilImplClassname Classname.
      */
     public void setTilesUtilImplClassname(String tilesUtilImplClassname) {
         this.tilesUtilImplClassname = tilesUtilImplClassname;
     }
 
     /**
      * Get Tiles util implemention classname.
      * @return The classname or <code>null</code> if none is set.
      */
     public String getTilesUtilImplClassname() {
         return tilesUtilImplClassname;
     }
 
     /**
      * Method used by the ActionServlet initializing this plugin.
      * Set the plugin config object read from module config.
      * @param plugInConfigObject PlugInConfig.
      */
     public void setCurrentPlugInConfigObject(PlugInConfig plugInConfigObject) {
         this.currentPlugInConfigObject = plugInConfigObject;
     }
 
 }