/* ModuleHttpServlet.java - Awaiting description
    *
    * Copyright (c)2005 Roscopeco Open Technologies & Contributors
    *
    * 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.
   *
   * File version: $Revision: 1.1 $ $Date: 2005/08/17 23:44:00 $
   * Originated: 11-Jul-2005
   * Author: Ross Bamford (rosco<at>roscopeco.co.uk)
   */
  
  package org.roscopeco.janno.util;
  
  import java.io.IOException;
  
  import javax.servlet.Servlet;
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletException;
  import javax.servlet.GenericServlet;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import static org.roscopeco.janno.core.CoreConstants.LOG_SEPARATOR;
  import static org.roscopeco.janno.util.UtilityConstants.SERVLET_KEY_PARAM;
  import static org.roscopeco.janno.util.UtilityConstants.SERVLET_MODULE_PARAM;
  import static org.roscopeco.janno.util.WrapperUtils.*;
  
  /*** 
   * Utility class that allows <code>Servlet</code> implementations supplied
   * by Moxy modules to be mapped into <code>web.xml</code>. This is a simple 
   * class that just obtains the servlet implementation registered in the named
   * module with the specified key. This information is supplied in context-
   * parameters:
   * <p/>
   * <ul>
   *    <li><strong>janno.servlet.context</strong> - full path to the context within
   *    which the {@link javax.servlet.Servlet} implementation is registered.</li><br/>
   *    
   *    <li><strong>janno.servlet.key</strong> - Public key class for this servlet.
   *    This is the key by which the implementation is registered in the root module
   *    context.</li><br/>
   * </ul>
   * <p/>
   * Note that servlets supplied by modules are directly fetched from the module
   * context, rather than being injected directly. This allows multiple modules
   * to supply the same servlet or use the same key (e.g. the <code>Servlet</code>
   * class) without any clashes. When registering Servlet implementations in
   * modules you should register the facade adapter in <code>parent</code> rather
   * than exporting it to the root context. You will also need to use an
   * implementation hiding adapter around that one if you're not exporting your
   * Servlet class itself.
   * <p/>
   * Note also that the supplied key doesn't <i>have</i> to be a class, but it is 
   * always looked up as a class first. If this results in an exception then it will
   * be tried as a straight String key. Class lookups are done in the module's realm,
   * so you don't have to have exported your key class.
   * <p/>
   * This class is compatible with any <code>Servlet</code> implementation, not 
   * just <code>HttpServlet</code>. The instantiated object must be 
   * assignment-compatible with the {@link javax.servlet.Servlet} class. The 
   * wrapped servlet is fetched <strong>once only</strong> from the specified 
   * context (during <code>init(ServletConfig)</code>), and lifecycle is managed
   * by the wrapper. This, in combination with the Servlet specification's
   * requirement for a null constructor, should enable any servlet to be used
   * with the wrapper with no modification.
   *
   * @author Ross Bamford (rosco&lt;at&gt;roscopeco.co.uk)
   * @version $Revision: 1.1 $ $Date: 2005/08/17 23:44:00 $ 
   */
  public class ServletWrapper extends GenericServlet implements WrapperImpl
  {
    static Log log = LogFactory.getLog(ServletWrapper.class); /* hide */
    
    private Servlet delegate = null;
    Servlet delegate() {                // for testmodel
      return delegate;
    }
    
    /* Testmodel constructor */
    ServletWrapper(Servlet testDelegate) {
      this.delegate = testDelegate;
    }
    
    /* Real constructor */
    public ServletWrapper() {
      super();
   }
    
   /***
    * Initializes the wrapper, obtains the delegate instance, and passes the
    * call through it it's <code>init(ServletConfig)</code> method, after
    * which point initialization continues in the regular Servlets manner.
    */
   @Override
   public void init(ServletConfig config) throws ServletException {
     super.init(config);
     log.info(LOG_SEPARATOR);
     log.info("ServletWrapper init begins...");
     
     try {
       delegate = (Servlet)getWrappedImpl(this,SERVLET_MODULE_PARAM,SERVLET_KEY_PARAM);
     } catch (ClassCastException e) {
       log.error("Specified component is not a valid implementation of javax.servlet.Servlet");
     }
     
     // init delegate
     log.debug("Initialising delegate...");
     delegate.init(config);
     log.info("Wrapper initialisation complete");
   }
   
   /***
    * Passes the request and response to the delegate's <code>service</code> 
    * method.
    */
   @Override
   public void service(ServletRequest request, ServletResponse response)
   throws ServletException, IOException {
     if (delegate == null) throw(new ServletException("ServletWrapper not initialized!"));
     delegate.service(request,response);   
   }
   
   /***
    * Calls the delegate's destroy method and performs wrapper cleanup.
    */
   public void destroy() {
     log.debug("Destroying delegate...");
     if (delegate != null) {
       delegate.destroy();
     } else {
       log.warn("Cannot destroy() uninitialised delegate Servlet");
     }
     log.info("ServletWrapper finished");
   }
   
   /* WrapperImpl - allows common code to log as this class */
   public Log log() { return log; }
 }