/*
    * 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.myfaces.application.jsp;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.myfaces.portlet.MyFacesGenericPortlet;
  import org.apache.myfaces.portlet.PortletUtil;
  import org.apache.myfaces.util.DebugUtils;
  import org.apache.myfaces.shared_impl.webapp.webxml.ServletMapping;
  import org.apache.myfaces.shared_impl.webapp.webxml.WebXml;
  
  import javax.faces.FacesException;
  import javax.faces.application.Application;
  import javax.faces.application.ViewHandler;
  import javax.faces.component.UIViewRoot;
  import javax.faces.context.ExternalContext;
  import javax.faces.context.FacesContext;
  import javax.faces.render.RenderKitFactory;
  import javax.portlet.PortletURL;
  import javax.portlet.RenderResponse;
  import javax.servlet.ServletResponse;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  import java.io.IOException;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Locale;
  
  /**
   * Implementation of the ViewHandler interface that knows how to use JSP pages
   * as the view templating mechanism, and either javax.servlet or javax.portlet API
   * as the request/response framework.
   * <p>
   * This implementation works tightly together with the various JSP TagHandler classes
   * to implement the behaviour mandated by the ViewHandler specification. 
   * <p>
   * Rendering of a view is done simply by invoking the servlet generated from the jsp
   * file that is named by the viewId of the view being rendered. Such servlets generate
   * all their output in one pass, writing text and invoking JSP taghandlers in the order
   * they are present in the jsp file.
   * <p>
   * On the first visit to a view, components are created when their taghandler is invoked
   * They must then be rendered immediately in order for their output to be generated in the
   * correct location relative to non-JSF text (and other non-jsf tags) within the same jsp
   * file. This means that components which are defined via tags later in the page do not
   * yet exist. This is particularly problematic for:
   * <ul>
   * <li>label components that want to refer to another component via a "for" attribute
   * <li>components that "render their children", ie which render themselves differently
   * depending upon the number and type of child nodes, or which want to wrap the output
   * of each child node in specific text.
   * </ul>
   * <p>
   * On later visits to the same view, the component tree already exists (has been restored).
   * Components can therefore reference others later in the page. When the JSP-generated
   * servlet invokes a taghandler, it "locates" the appropriate existing component in the
   * tree rather than creating a new one, and then invokes the appropriate rendering
   * methods on it.
   * <p>
   * @author Thomas Spiegl (latest modification by $Author: skitching $)
   * @version $Revision: 608647 $ $Date: 2008-01-03 16:57:10 -0500 (Thu, 03 Jan 2008) $
   */
  public class JspViewHandlerImpl
      extends ViewHandler {
      private static final Log log = LogFactory.getLog(JspViewHandlerImpl.class);
      public static final String FORM_STATE_MARKER = "<!--@@JSF_FORM_STATE_MARKER@@-->";
      public static final int FORM_STATE_MARKER_LEN = FORM_STATE_MARKER.length();
  
  
      public JspViewHandlerImpl() {
          if (log.isTraceEnabled()) log.trace("New ViewHandler instance created");
      }
  
      /**
       * Get the locales specified as acceptable by the original request, compare them to the
       * locales supported by this Application and return the best match.
       */
      public Locale calculateLocale(FacesContext facesContext) {
          Iterator locales = facesContext.getExternalContext().getRequestLocales();
          while (locales.hasNext()) {
              Locale locale = (Locale) locales.next();
             for (Iterator it = facesContext.getApplication().getSupportedLocales(); it.hasNext();) {
                 Locale supportLocale = (Locale) it.next();
                 // higher priority to a language match over an exact match
                 // that occures further down (see Jstl Reference 1.0 8.3.1)
                 if (locale.getLanguage().equals(supportLocale.getLanguage()) &&
                     (supportLocale.getCountry() == null ||
                         supportLocale.getCountry().length() == 0)) {
                     return supportLocale;
                 }
                 else if (supportLocale.equals(locale)) {
                     return supportLocale;
                 }
             }
         }
 
         Locale defaultLocale = facesContext.getApplication().getDefaultLocale();
         return defaultLocale != null ? defaultLocale : Locale.getDefault();
     }
 
     public String calculateRenderKitId(FacesContext facesContext) {
         String renderKitId = facesContext.getApplication().getDefaultRenderKitId();
         return (renderKitId != null) ? renderKitId : RenderKitFactory.HTML_BASIC_RENDER_KIT;
         //TODO: how to calculate from client?
     }
 
     /**
      * Create a UIViewRoot object and return it; the returned object has no children.
      * <p>
      * As required by the spec, the returned object inherits locale and renderkit settings from
      * the viewRoot currently configured for the facesContext (if any). This means that on navigation
      * from one view to another these settings are "inherited".
      * <p>
      */
     public UIViewRoot createView(FacesContext facesContext, String viewId) {
         Application application = facesContext.getApplication();
         ViewHandler applicationViewHandler = application.getViewHandler();
 
         Locale currentLocale = null;
         String currentRenderKitId = null;
         UIViewRoot uiViewRoot = facesContext.getViewRoot();
         if (uiViewRoot != null) {
             //Remember current locale and renderKitId
             currentLocale = uiViewRoot.getLocale();
             currentRenderKitId = uiViewRoot.getRenderKitId();
         }
 
         uiViewRoot = (UIViewRoot) application.createComponent(UIViewRoot.COMPONENT_TYPE);
 //      as of JSF spec page 7-16:
 //      "It is the callers responsibility to ensure that setViewId() is called
 //      on the returned view, passing the same viewId value."
 //      so we do not set the viewId here
 
 //      ok, but the RI does so, so let's do it, too.
         uiViewRoot.setViewId(viewId);
 
         if (currentLocale != null) {
             //set old locale
             uiViewRoot.setLocale(currentLocale);
         }
         else {
             //calculate locale
             uiViewRoot.setLocale(applicationViewHandler.calculateLocale(facesContext));
         }
 
         if (currentRenderKitId != null) {
             //set old renderKit
             uiViewRoot.setRenderKitId(currentRenderKitId);
         }
         else {
             //calculate renderKit
             uiViewRoot.setRenderKitId(applicationViewHandler.calculateRenderKitId(facesContext));
         }
 
         if (log.isTraceEnabled()) log.trace("Created view " + viewId);
         return uiViewRoot;
     }
 
     public String getActionURL(FacesContext facesContext, String viewId) {
         if (PortletUtil.isRenderResponse(facesContext)) {
             RenderResponse response = (RenderResponse) facesContext.getExternalContext().getResponse();
             PortletURL url = response.createActionURL();
             url.setParameter(MyFacesGenericPortlet.VIEW_ID, viewId);
             return url.toString();
         }
 
         String path = getViewIdPath(facesContext, viewId);
         if (path.length() > 0 && path.charAt(0) == '/') {
             return facesContext.getExternalContext().getRequestContextPath() + path;
         }
         else {
             return path;
         }
     }
 
     public String getResourceURL(FacesContext facesContext, String path) {
         if (path.length() > 0 && path.charAt(0) == '/') {
             return facesContext.getExternalContext().getRequestContextPath() + path;
         }
         else {
             return path;
         }
     }
 
     /**
      * Simply invoke the appropriate jsp-generated servlet.
      */
     public void renderView(FacesContext facesContext, UIViewRoot viewToRender)
         throws IOException, FacesException {
         if (viewToRender == null) {
             log.fatal("viewToRender must not be null");
             throw new NullPointerException("viewToRender must not be null");
         }
 
         ExternalContext externalContext = facesContext.getExternalContext();
 
         String viewId = facesContext.getViewRoot().getViewId();
 
         if (PortletUtil.isPortletRequest(facesContext)) {
             externalContext.dispatch(viewId);
             return;
         }
 
         ServletMapping servletMapping = getServletMapping(externalContext);
 
         if (servletMapping != null && servletMapping.isExtensionMapping()) {
             String defaultSuffix = externalContext.getInitParameter(ViewHandler.DEFAULT_SUFFIX_PARAM_NAME);
             String suffix = defaultSuffix != null ? defaultSuffix : ViewHandler.DEFAULT_SUFFIX;
             DebugUtils.assertError(suffix.charAt(0) == '.',
                                    log, "Default suffix must start with a dot!");
             if (!viewId.endsWith(suffix)) {
                 int slashPos = viewId.lastIndexOf('/');
                 int extensionPos = viewId.lastIndexOf('.');
                 if (extensionPos == -1 || extensionPos <= slashPos) {
                     if (log.isTraceEnabled())
                         log.trace("Current viewId has no extension, appending default suffix " + suffix);
                     viewId = viewId + suffix;
                 }
                 else {
                     if (log.isTraceEnabled()) log.trace("Replacing extension of current viewId by suffix " + suffix);
                     viewId = viewId.substring(0, extensionPos) + suffix;
                 }
                 facesContext.getViewRoot().setViewId(viewId);
             }
         }
 
         if (log.isTraceEnabled()) log.trace("Dispatching to " + viewId);
 
         // handle character encoding as of section 2.5.2.2 of JSF 1.1
         if (externalContext.getResponse() instanceof ServletResponse) {
             ServletResponse response = (ServletResponse) externalContext.getResponse();
             response.setLocale(viewToRender.getLocale());
         }
 
         // TODO: 2.5.2.2 for Portlet?  What do I do?
 
         externalContext.dispatch(viewId);
 
         // handle character encoding as of section 2.5.2.2 of JSF 1.1
         if (externalContext.getRequest() instanceof HttpServletRequest) {
             HttpServletResponse response = (HttpServletResponse) externalContext.getResponse();
             HttpServletRequest request = (HttpServletRequest) externalContext.getRequest();
             HttpSession session = request.getSession(false);
 
             if (session != null) {
                 session.setAttribute(ViewHandler.CHARACTER_ENCODING_KEY, response.getCharacterEncoding());
             }
         }
 
     }
 
 
     /**
      * Just invoke StateManager.restoreView.
      */
     public UIViewRoot restoreView(FacesContext facesContext, String viewId) {
         Application application = facesContext.getApplication();
         ViewHandler applicationViewHandler = application.getViewHandler();
         String renderKitId = applicationViewHandler.calculateRenderKitId(facesContext);
         UIViewRoot viewRoot = application.getStateManager().restoreView(facesContext,
                                                                         viewId,
                                                                         renderKitId);
         return viewRoot;
     }
 
     /**
      * Writes a state marker that is replaced later by one or more hidden form
      * inputs.
      * <p>
      * The problem with html is that the only place to encode client-side state is
      * in a hidden html input field. However when a form is submitted, only the fields
      * within a particular form are sent; fields in other forms are not sent. Therefore
      * the view tree state must be written into every form in the page. This method
      * is therefore invoked at the end of every form.
      * <p>
      * And the problem with JSP2.0 as a templating system is that as described at the
      * top of this file the component tree is not built before rendering starts. It
      * is created only as jsf tags are encountered while the page is being rendered.
      * <p>
      * But when the end of a form (h:form tag) is encountered, not all of the component
      * tree exists yet, so it is impossible to write the tree state out at that time.
      * <p>
      * The solution used here is to buffer the entire page being generated, and simply
      * output a "marker" string. After the rendering pass is complete the component
      * tree state can be computed. The generated page is then post-processed to
      * replace all the "marker" strings with the complete tree state.
      * <p> 
      * Note that this is only a problem with client-side state saving. For server-side
      * state it should be possible to write the appropriate "key" out even though the
      * data will not be stored under that key until the end of the rendering. This is
      * not yet implemented however. TODO: optimise server-side state saving by not
      * writing markers.
      * <p>
      * See {@link org.apache.myfaces.taglib.core.ViewTag#doAfterBody()} for the call
      * that triggers the replacement of marker strings.
      *  
      * @param facesContext
      * @throws IOException
      */
     public void writeState(FacesContext facesContext) throws IOException {
         facesContext.getResponseWriter().write(FORM_STATE_MARKER);
     }
 
 
     protected String getViewIdPath(FacesContext facescontext, String viewId) {
         if (viewId == null) {
             log.error("ViewId must not be null");
             throw new NullPointerException("ViewId must not be null");
         }
         if (!viewId.startsWith("/")) {
             log.error("ViewId must start with '/' (viewId = " + viewId + ")");
             throw new IllegalArgumentException("ViewId must start with '/' (viewId = " + viewId + ")");
         }
 
         if (PortletUtil.isPortletRequest(facescontext)) {
             return viewId;
         }
 
         ServletMapping servletMapping = getServletMapping(facescontext.getExternalContext());
 
         if (servletMapping != null) {
             if (servletMapping.isExtensionMapping()) {
                 // extension mapping
                 String urlpattern = servletMapping.getUrlPattern();
                 if (urlpattern.startsWith("*")) {
                     urlpattern = urlpattern.substring(1, urlpattern.length());
                 }
                 if (viewId.endsWith(urlpattern)) {
                     return viewId;
                 }
                 else {
                     int slashPos = viewId.lastIndexOf('/');
                     int extensionPos = viewId.lastIndexOf('.');
                     
                     if (extensionPos == -1 || extensionPos <= slashPos) {
                         return viewId + urlpattern;
                     }
                     else {
                         return viewId.substring(0, extensionPos) + urlpattern;
                     }
 
                 }
             }
             else {
                 // prefix mapping
                 String urlpattern = servletMapping.getUrlPattern();
                 if (urlpattern.endsWith("/*")) {
                     urlpattern = urlpattern.substring(0, urlpattern.length() - 2);
                 }
                 return urlpattern + viewId;
             }
         }
         else {
             return viewId;
         }
     }
 
     private static ServletMapping getServletMapping(ExternalContext externalContext) {
         String servletPath = externalContext.getRequestServletPath();
         String requestPathInfo = externalContext.getRequestPathInfo();
 
         WebXml webxml = WebXml.getWebXml(externalContext);
         List mappings = webxml.getFacesServletMappings();
 
 
         if (requestPathInfo == null) {
             // might be extension mapping
             for (int i = 0, size = mappings.size(); i < size; i++) {
                 ServletMapping servletMapping = (ServletMapping) mappings.get(i);
                 String urlpattern = servletMapping.getUrlPattern();
                 String extension = urlpattern.substring(1, urlpattern.length());
                 if (servletPath.endsWith(extension)) {
                     return servletMapping;
                 }
                 else if (servletPath.equals(urlpattern)) {
                     // path mapping with no pathInfo for the current request
                     return servletMapping;
                 }
             }
         }
         else {
             // path mapping
             for (int i = 0, size = mappings.size(); i < size; i++) {
 
                 ServletMapping servletMapping = (ServletMapping) mappings.get(i);
                 String urlpattern = servletMapping.getUrlPattern();
                 urlpattern = urlpattern.substring(0, urlpattern.length() - 2);
                 // servletPath starts with "/" except in the case where the
                 // request is matched with the "/*" pattern, in which case
                 // it is the empty string (see Servlet Sepc 2.3 SRV4.4)
                 if (servletPath.equals(urlpattern)) {
                     return servletMapping;
                 }
             }
         }
 
         // handle cases as best possible where servletPath is not a faces servlet,
         // such as when coming through struts-faces
         if (mappings.size() > 0) {
             return (ServletMapping) mappings.get(0);
         }
         else {
             log.warn("no faces servlet mappings found");
             return null;
         }
     }
 
 
 }