/*
    * 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.pluto.container.driver;
  
  import java.io.IOException;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.portlet.ActionRequest;
  import javax.portlet.ActionResponse;
  import javax.portlet.EventPortlet;
  import javax.portlet.EventRequest;
  import javax.portlet.EventResponse;
  import javax.portlet.Portlet;
  import javax.portlet.PortletConfig;
  import javax.portlet.PortletException;
  import javax.portlet.PortletRequest;
  import javax.portlet.PortletResponse;
  import javax.portlet.RenderRequest;
  import javax.portlet.RenderResponse;
  import javax.portlet.ResourceRequest;
  import javax.portlet.ResourceResponse;
  import javax.portlet.ResourceServingPortlet;
  import javax.portlet.UnavailableException;
  import javax.servlet.ServletConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.pluto.container.FilterManager;
  import org.apache.pluto.container.PortletContainerException;
  import org.apache.pluto.container.PortletInvokerService;
  import org.apache.pluto.container.PortletRequestContext;
  import org.apache.pluto.container.PortletResponseContext;
  import org.apache.pluto.container.PortletWindow;
  import org.apache.pluto.container.om.portlet.PortletDefinition;
  
  /**
   * Portlet Invocation Servlet. This servlet recieves cross context requests from
   * the the container and services the portlet request for the specified method.
   *
   * @version 1.1
   * @since 09/22/2004
   */
  public class PortletServlet extends HttpServlet
  {
      private static final long serialVersionUID = -5096339022539360365L;
  
      static class NullPortlet implements EventPortlet, ResourceServingPortlet, Portlet
      {
          public void processEvent(EventRequest arg0, EventResponse arg1)
          throws PortletException, IOException
          {
          }
  
          public void serveResource(ResourceRequest arg0, ResourceResponse arg1)
          throws PortletException, IOException
          {
          }
  
          public void destroy()
          {
          }
  
          public void init(PortletConfig arg0) throws PortletException
          {
          }
  
          public void processAction(ActionRequest arg0, ActionResponse arg1)
          throws PortletException, IOException
          {
          }
  
          public void render(RenderRequest arg0, RenderResponse arg1)
          throws PortletException, IOException
          {
          }
      }
  
      // Private Member Variables ------------------------------------------------
      /**
       * The portlet name as defined in the portlet app descriptor.
       */
     private String portletName;
 
     /**
      * The portlet instance wrapped by this servlet.
      */
     private Portlet portlet;
 
     /**
      * The internal portlet context instance.
      */
     private DriverPortletContext portletContext;
 
     /**
      * The internal portlet config instance.
      */
     private DriverPortletConfig portletConfig;
 
     /**
      * The Event Portlet instance (the same object as portlet) wrapped by this
      * servlet.
      */
     private EventPortlet eventPortlet;
 
     /** The resource serving portlet instance wrapped by this servlet. */
     private ResourceServingPortlet resourceServingPortlet;
 
     private PortletContextService contextService;
 
     private boolean started = false;
     Timer   startTimer;
 
     // HttpServlet Impl --------------------------------------------------------
 
     public String getServletInfo()
     {
         return "Pluto PortletServlet [" + portletName + "]";
     }
 
     /**
      * Initialize the portlet invocation servlet.
      *
      * @throws ServletException
      *             if an error occurs while loading portlet.
      */
     public void init(ServletConfig config) throws ServletException
     {
 
         // Call the super initialization method.
         super.init(config);
 
         // Retrieve portlet name as defined as an initialization parameter.
         portletName = getInitParameter("portlet-name");
 
         started = false;
 
         startTimer = new Timer(true);
         final ServletContext servletContext = getServletContext();
         final ClassLoader paClassLoader = Thread.currentThread().getContextClassLoader();
         startTimer.schedule(new TimerTask()
         {
             public void run()
             {
                 synchronized(servletContext)
                 {
                     if (startTimer != null)
                     {
                         if (attemptRegistration(servletContext, paClassLoader ))
                         {
                             startTimer.cancel();
                             startTimer = null;
                         }
                     }
                 }
             }
         }, 1, 1);
     }
 
     protected boolean attemptRegistration(ServletContext context, ClassLoader paClassLoader)
     {
         if (PlutoServices.getServices() != null)
         {
             contextService = PlutoServices.getServices().getPortletContextService();
             try
             {
                 ServletConfig sConfig = getServletConfig();
                 if (sConfig == null)
                 {
                     String msg = "Problem obtaining servlet configuration(getServletConfig() returns null).";
                     context.log(msg);
                     return true;
                 }
 
                 String applicationName = contextService.register(sConfig);
                 started = true;
                 portletContext = contextService.getPortletContext(applicationName);
                 portletConfig = contextService.getPortletConfig(applicationName, portletName);
 
             }
             catch (PortletContainerException ex)
             {
                 context.log(ex.getMessage(),ex);
                 return true;
             }
 
             PortletDefinition portletDD = portletConfig.getPortletDefinition();
 
             //          Create and initialize the portlet wrapped in the servlet.
             try
             {
                 Class<?> clazz = paClassLoader.loadClass((portletDD.getPortletClass()));
                 portlet = (Portlet) clazz.newInstance();
                 portlet.init(portletConfig);
                 initializeEventPortlet();
                 initializeResourceServingPortlet();
                 return true;
             }
             catch (Exception ex)
             {
                 context.log(ex.getMessage(),ex);
                 // take out of service
                 portlet = null;
                 portletConfig = null;
                 return true;
             }
         }
         return false;
     }
 
     public void destroy()
     {
         synchronized(getServletContext())
         {
             if ( startTimer != null )
             {
                 startTimer.cancel();
                 startTimer = null;
             }
             else if ( started && portletContext != null)
             {
                 started = false;
                 contextService.unregister(portletContext);
                 if (portlet != null)
                 {
                     try
                     {
                         portlet.destroy();
                     }
                     catch (Exception e)
                     {
                         // ignore
                     }
                     portlet = null;
                 }
             }
             super.destroy();
         }
     }
 
     protected void doGet(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
             {
         dispatch(request, response);
             }
 
     protected void doPost(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
             {
         dispatch(request, response);
             }
 
     protected void doPut(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
             {
         dispatch(request, response);
             }
 
     // Private Methods ---------------------------------------------------------
 
     /**
      * Dispatch the request to the appropriate portlet methods. This method
      * assumes that the following attributes are set in the servlet request
      * scope:
      * <ul>
      * <li>METHOD_ID: indicating which method to dispatch.</li>
      * <li>PORTLET_REQUEST: the internal portlet request.</li>
      * <li>PORTLET_RESPONSE: the internal portlet response.</li>
      * </ul>
      *
      * @param request
      *            the servlet request.
      * @param response
      *            the servlet response.
      * @throws ServletException
      * @throws IOException
      */
     private void dispatch(HttpServletRequest request,
             HttpServletResponse response) throws ServletException, IOException
             {
         if (portlet == null)
         {
             throw new javax.servlet.UnavailableException("Portlet "+portletName+" unavailable");
         }
 
         // Retrieve attributes from the servlet request.
         Integer methodId = (Integer) request.getAttribute(PortletInvokerService.METHOD_ID);
 
         final PortletRequest portletRequest = (PortletRequest)request.getAttribute(PortletInvokerService.PORTLET_REQUEST);
 
         final PortletResponse portletResponse = (PortletResponse)request.getAttribute(PortletInvokerService.PORTLET_RESPONSE);
 
         final PortletRequestContext requestContext = (PortletRequestContext)portletRequest.getAttribute(PortletInvokerService.REQUEST_CONTEXT);
         final PortletResponseContext responseContext = (PortletResponseContext)portletRequest.getAttribute(PortletInvokerService.RESPONSE_CONTEXT);
 
         final FilterManager filterManager = (FilterManager)request.getAttribute(PortletInvokerService.FILTER_MANAGER);
 
         request.removeAttribute(PortletInvokerService.METHOD_ID);
         request.removeAttribute(PortletInvokerService.PORTLET_REQUEST);
         request.removeAttribute(PortletInvokerService.PORTLET_RESPONSE);
         request.removeAttribute(PortletInvokerService.FILTER_MANAGER);
 
         requestContext.init(portletConfig, getServletContext(), request, response);
         responseContext.init(request, response);
 
         PortletWindow window = requestContext.getPortletWindow();
 
         PortletInvocationEvent event = new PortletInvocationEvent(portletRequest, window, methodId.intValue());
 
         notify(event, true, null);
 
         // FilterManager filtermanager = (FilterManager) request.getAttribute(
         // "filter-manager");
 
         try
         {
 
             // The requested method is RENDER: call Portlet.render(..)
             if (methodId == PortletInvokerService.METHOD_RENDER)
             {
                 RenderRequest renderRequest = (RenderRequest) portletRequest;
                 RenderResponse renderResponse = (RenderResponse) portletResponse;
                 filterManager.processFilter(renderRequest, renderResponse,
                         portlet, portletContext);
             }
 
             // The requested method is RESOURCE: call
             // ResourceServingPortlet.serveResource(..)
             else if (methodId == PortletInvokerService.METHOD_RESOURCE)
             {
                 ResourceRequest resourceRequest = (ResourceRequest) portletRequest;
                 ResourceResponse resourceResponse = (ResourceResponse) portletResponse;
                 filterManager.processFilter(resourceRequest, resourceResponse,
                         resourceServingPortlet, portletContext);
             }
 
             // The requested method is ACTION: call Portlet.processAction(..)
             else if (methodId == PortletInvokerService.METHOD_ACTION)
             {
                 ActionRequest actionRequest = (ActionRequest) portletRequest;
                 ActionResponse actionResponse = (ActionResponse) portletResponse;
                 filterManager.processFilter(actionRequest, actionResponse,
                         portlet, portletContext);
             }
 
             // The request methode is Event: call Portlet.processEvent(..)
             else if (methodId == PortletInvokerService.METHOD_EVENT)
             {
                 EventRequest eventRequest = (EventRequest) portletRequest;
                 EventResponse eventResponse = (EventResponse) portletResponse;
                 filterManager.processFilter(eventRequest, eventResponse,
                         eventPortlet, portletContext);
             }
             // The requested method is ADMIN: call handlers.
             else if (methodId == PortletInvokerService.METHOD_ADMIN)
             {
                 PortalAdministrationService pas = PlutoServices.getServices().getPortalAdministrationService();
 
                 for (AdministrativeRequestListener l : pas.getAdministrativeRequestListeners())
                 {
                     l.administer(portletRequest, portletResponse);
                 }
             }
 
             // The requested method is LOAD: do nothing.
             else if (methodId == PortletInvokerService.METHOD_LOAD)
             {
                 // Do nothing.
             }
 
             notify(event, false, null);
 
         }
         catch (UnavailableException ex)
         {
             //
             // if (e.isPermanent()) { throw new
             // UnavailableException(e.getMessage()); } else { throw new
             // UnavailableException(e.getMessage(), e.getUnavailableSeconds());
             // }
             //
 
             // Portlet.destroy() isn't called by Tomcat, so we have to fix it.
             try
             {
                 portlet.destroy();
             }
             catch (Throwable th)
             {
                 // Don't care for Exception
                 this.getServletContext().log("Error during portlet destroy.", th);
             }
             // take portlet out of service
             portlet = null;
 
             // TODO: Handle everything as permanently for now.
             throw new javax.servlet.UnavailableException(ex.getMessage());
 
         }
         catch (PortletException ex)
         {
             notify(event, false, ex);
             throw new ServletException(ex);
 
         }
             }
 
     protected void notify(PortletInvocationEvent event, boolean pre, Throwable e)
     {
         PortalAdministrationService pas = PlutoServices.getServices().getPortalAdministrationService();
 
         for (PortletInvocationListener listener : pas.getPortletInvocationListeners())
         {
             if (pre)
             {
                 listener.onBegin(event);
             }
             else if (e == null)
             {
                 listener.onEnd(event);
             }
             else
             {
                 listener.onError(event, e);
             }
         }
     }
 
     private void initializeEventPortlet()
     {
         if (portlet instanceof EventPortlet)
         {
             eventPortlet = (EventPortlet) portlet;
         }
         else
         {
             eventPortlet = new NullPortlet();
         }
     }
 
     private void initializeResourceServingPortlet()
     {
         if (portlet instanceof ResourceServingPortlet)
         {
             resourceServingPortlet = (ResourceServingPortlet) portlet;
         }
         else
         {
             resourceServingPortlet = new NullPortlet();
         }
     }
 }