/**
    * This file Copyright (c) 2003-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.cms.filters;
  
  import info.magnolia.cms.util.CustomServletConfig;
  import info.magnolia.objectfactory.ComponentProvider;
  
  import java.io.IOException;
  import java.util.Collection;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.inject.Inject;
  import javax.servlet.FilterChain;
  import javax.servlet.FilterConfig;
  import javax.servlet.Servlet;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletRequestWrapper;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.common.collect.ImmutableList;
  
  /**
   * A filter that dispatches requests to a wrapped servlet.
   *
   * TODO : cache matching URIs ?
   */
  public class ServletDispatchingFilter extends AbstractMgnlFilter {
  
      private static final Logger log = LoggerFactory.getLogger(ServletDispatchingFilter.class);
  
      private final ComponentProvider componentProvider;
  
      private final Mapping servletMapping;
  
      private String servletName;
  
      private Class<? extends Servlet> servletClass;
  
      private Map parameters;
  
      private String comment;
  
      private Servlet servlet;
  
      @Inject
      public ServletDispatchingFilter(ComponentProvider componentProvider) {
          this.componentProvider = componentProvider;
          this.servletMapping = new ServletMapping();
      }
  
      @Override
      public String getName() {
          return "Wrapper for " + servletName + " servlet";
      }
  
      /**
       * Initializes the servlet and its mappings. ServletConfig is wrapped to take init parameters into account.
       */
      @Override
      public void init(final FilterConfig filterConfig) throws ServletException {
          super.init(filterConfig);
 
         if (getServletClass() != null) {
             try {
                 initializeServlet(filterConfig);
             } catch (Throwable e) {
                 log.error("Unable to load servlet {} : {}", getServletClass(), e.getMessage(), e);
             }
         }
     }
 
     protected void initializeServlet(FilterConfig filterConfig) throws ClassNotFoundException, ServletException {
         servlet = newServletInstance();
         servlet.init(new CustomServletConfig(servletName, filterConfig.getServletContext(), parameters));
     }
 
     protected Servlet newServletInstance() throws ClassNotFoundException {
         return componentProvider.newInstance(getServletClass());
     }
 
     protected Servlet getServlet() {
         return servlet;
     }
 
     @Override
     protected Mapping getMapping() {
         return servletMapping;
     }
 
     /**
      * Delegates the destroy() call to the wrapper servlet, then to this filter itself.
      */
     @Override
     public void destroy() {
         if (servlet != null) {
             servlet.destroy();
         }
         super.destroy();
     }
 
     /**
      * Dispatches the request to the servlet if not already bypassed. The request is wrapped for properly setting the
      * pathInfo.
      */
     @Override
     public void doFilter(final HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
         if (!getMapping().getMappings().isEmpty()) {
             log.debug("Dispatching to servlet {}", getServletClass());
             final Matcher matcher = getMapping().match(request).getMatcher();
             servlet.service(new WrappedRequest(request, matcher), response);
         } else {
             log.debug("No mappings found to {}", getServletClass());
             setEnabled(false);
         }
     }
 
     public String getServletName() {
         return servletName;
     }
 
     public void setServletName(String servletName) {
         this.servletName = servletName;
     }
 
     public Class<? extends Servlet> getServletClass() {
         return servletClass;
     }
 
     public void setServletClass(Class<? extends Servlet> servletClass) {
         this.servletClass = servletClass;
     }
 
     public Map getParameters() {
         return parameters;
     }
 
     public void setParameters(Map parameters) {
         this.parameters = parameters;
     }
 
     public String getComment() {
         return comment;
     }
 
     public void setComment(String comment) {
         this.comment = comment;
     }
 
     /**
      * Request wrapper that overrides servletPath and pathInfo with new values. If any of the path elements changes in
      * a wrapper behind it then it returns them instead of the overridden values. This happens on forwards. It's
      * necessary to check all four since they act as a group, if any of them changes we cannot override any of them.
      */
     private static class WrappedRequest extends HttpServletRequestWrapper {
 
         private String originalRequestUri;
         private String originalServletPath;
         private String originalPathInfo;
         private String originalQueryString;
 
         private String newServletPath;
         private String newPathInfo;
 
         /**
          * The given Matcher should be built from a Pattern containing two groups:
          * (1) servletPath (2) ignored (3) pathInfo.
          */
         public WrappedRequest(HttpServletRequest request, Matcher matcher) {
             super(request);
 
             this.originalRequestUri = request.getRequestURI();
             this.originalServletPath = request.getServletPath();
             this.originalPathInfo = request.getPathInfo();
             this.originalQueryString = request.getQueryString();
 
             this.newServletPath = matcher.group(1);
             if (matcher.groupCount() > 2) {
                 String pathInfo = matcher.group(3);
                 // pathInfo should be null when empty
                 if (!pathInfo.equals("")) {
                     // according to the servlet spec the pathInfo should contain a leading slash
                     this.newPathInfo = (pathInfo.startsWith("/") ? pathInfo : "/" + pathInfo);
                 }
             }
         }
 
         @Override
         public String getPathInfo() {
             String current = super.getPathInfo();
             if (!StringUtils.equals(super.getRequestURI(), originalRequestUri)) {
                 return current;
             }
             if (!StringUtils.equals(super.getServletPath(), originalServletPath)) {
                 return current;
             }
             if (!StringUtils.equals(current, originalPathInfo)) {
                 return current;
             }
             if (!StringUtils.equals(super.getQueryString(), originalQueryString)) {
                 return current;
             }
             return newPathInfo;
         }
 
         @Override
         public String getServletPath() {
             String current = super.getServletPath();
             if (!StringUtils.equals(super.getRequestURI(), originalRequestUri)) {
                 return current;
             }
             if (!StringUtils.equals(current, originalServletPath)) {
                 return current;
             }
             if (!StringUtils.equals(super.getPathInfo(), originalPathInfo)) {
                 return current;
             }
             if (!StringUtils.equals(super.getQueryString(), originalQueryString)) {
                 return current;
             }
             return newServletPath;
         }
     }
 
     /**
      * A subclass of Mapping which allows adding *one* specific mapping, in this case provided by the Servlet,
      * if it implements {@link SelfMappingServlet}.
      */
     private class ServletMapping extends Mapping {
         private Collection<Pattern> mergedMappings;
         private String lastUsedSelfMapping;
 
         /**
          * Returns mapping that potentially include an entry for the servlet's self mapping.
          * Does some preemptive optimization to avoid re-instantiating the collection at every call,
          * while still getting the "latest" self mapping (i.e allows the servlet to delegate that call
          * to some dynamic component)
          */
         @Override
         public Collection<Pattern> getMappings() {
             final Collection<Pattern> configuredMappings = super.getMappings();
             if (!(getServlet() instanceof SelfMappingServlet)) {
                 return configuredMappings;
             }
 
             final String selfMapping = ((SelfMappingServlet) getServlet()).getSelfMappingPath();
             if (selfMapping == null) {
                 return configuredMappings;
             }
 
             if (lastUsedSelfMapping == null || !lastUsedSelfMapping.equals(selfMapping)) {
                 final Pattern selfMappingPattern = servletMappingToRegex(selfMapping);
                 // Using ImmutableList and its builder - which may or may not optimize this, and will avoid leaking write operations in the list.
                 mergedMappings = ImmutableList.<Pattern>builder().add(selfMappingPattern).addAll(configuredMappings).build();
                 lastUsedSelfMapping = selfMapping;
             }
             return mergedMappings;
         }
 
 
     }
 }