/*
    * Copyright 2004 Carlos Sanchez.
    * 
    * Licensed 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 net.sf.oness.common.webapp.controller.action;
  
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.ResourceBundle;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  import org.apache.struts.action.DynaActionForm;
  import org.apache.struts.actions.LookupDispatchAction;
  
  /***
   * An abstract Action that dispatches to a method based in the start of the
   * action path.
   * 
   * @author Carlos Sanchez
   * @author <a href="mailto:matt@raibledesigns.com">Matt Raible </a>
   * @version $Revision: 1.4 $
   */
  public abstract class AutoDispatchAction extends LookupDispatchAction {
  
      private Map keyMethodMap = null;
  
      private SpringActionSupport springActionSupport = null;
  
      /***
       * Gets a bean from Spring configuration
       * 
       * @param name
       *            bean name
       * @return the bean
       */
      public Object getBean(String name) {
          if (springActionSupport == null)
              springActionSupport = new SpringActionSupport(servlet);
          return springActionSupport.getBean(name);
      }
  
      /***
       * Provides the mapping from resource key to method name.
       * 
       * Reads the values form the ResourceBundle LookupMethods
       * 
       * @return Resource key / method name map.
       */
      public Map getKeyMethodMap() {
          if (keyMethodMap == null) {
  
              Map map = new HashMap();
  
              ResourceBundle methods = ResourceBundle
                      .getBundle(AutoDispatchAction.class.getPackage().getName()
                              + ".LookupMethods");
  
              Enumeration keys = methods.getKeys();
              while (keys.hasMoreElements()) {
                  String key = (String) keys.nextElement();
                  map.put(key, methods.getString(key));
              }
  
              keyMethodMap = map;
          }
  
          return keyMethodMap;
      }
  
      /***
       * Override the execute method in LookupDispatchAction to parse URLs and
       * forward to methods without parameters.
       * 
       * If the action mapping parameter is present it will be used.
       * 
       * If not, it will check if the action path contains any of the values from
       * the Map returned by getKeyMethodMap() and will forward to the method
       * called after that value. If more that one match the result is not
       * specified.
       * 
       * Also will forward to unspecified method when no parameter is present.
      * 
      * For example if the values from getKeyMethodMap() are edit=edit
      * update=update view=view create=create other=another
      * 
      * The following map between paths and methods will be used
      * 
      * <ul>
      * <li>edit*.do -> edit method</li>
      * <li>update*.do -> update method</li>
      * <li>view*.do -> view method</li>
      * <li>create*.do -> create method</li>
      * <li>find*.do -> find method</li>
      * <li>other*.do -> another method</li>
      * </ul>
      * 
      * @param mapping
      *            The ActionMapping used to select this instance
      * @param request
      *            The HTTP request we are processing
      * @param response
      *            The HTTP response we are creating
      * @param form
      *            The optional ActionForm bean for this request (if any)
      * @return Describes where and how control should be forwarded.
      * @exception Exception
      *                if an error occurs
      */
     public ActionForward execute(ActionMapping mapping, ActionForm form,
             HttpServletRequest request, HttpServletResponse response)
             throws Exception {
 
         if (isCancelled(request)) {
             ActionForward af = cancelled(mapping, form, request, response);
             if (af != null) {
                 return af;
             }
         }
 
         /* Identify the request parameter containing the method name */
         String parameter = mapping.getParameter();
 
         String keyName = (parameter == null) ? null : request
                 .getParameter(parameter);
 
         /*
          * If there is no parameter set in the action mapping get the dispatcher
          * method from the name of the action path
          */
         if ((keyName == null) || (keyName.length() == 0)) {
             Map map = getKeyMethodMap();
             Iterator iter = map.keySet().iterator();
             while (iter.hasNext()) {
                 String element = (String) iter.next();
 
                 /* If it matches call the corresponding method */
                 if (mapping.getPath().indexOf(element) > -1) {
                     return dispatchMethod(mapping, form, request, response,
                             (String) map.get(element));
                 }
             }
 
             return this.unspecified(mapping, form, request, response);
         }
 
         // Identify the string to lookup
         String methodName = getMethodName(mapping, form, request, response,
                 parameter);
 
         return dispatchMethod(mapping, form, request, response, methodName);
     }
 
     /***
      * Get a property value from a DynaActionForm
      * 
      * @param actionForm
      *            a DynaActionForm
      * @param name
      *            name of the property
      * @return
      */
     protected Object getDynaProperty(ActionForm actionForm, String name) {
         return ((DynaActionForm) actionForm).get(name);
     }
 
 }