package org.eclipse.jetty.rewrite.handler;
   
   import java.io.IOException;
   import java.util.Collections;
   import java.util.List;
   import java.util.concurrent.CopyOnWriteArrayList;
   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import org.eclipse.jetty.server.Request;
  import org.eclipse.jetty.server.handler.ContextHandler;
  import org.eclipse.jetty.server.handler.ContextHandler.Context;
  import org.eclipse.jetty.server.handler.ScopedHandler;
  import org.eclipse.jetty.util.component.AggregateLifeCycle;
  import org.eclipse.jetty.util.log.Log;
  import org.eclipse.jetty.util.log.Logger;
  
  
  /* ------------------------------------------------------------ */
  /** A handle that uses regular expressions to select the target.
   * <p>
   * This handler applies a list of regex to target name mappings to the URIs of requests. 
   * If the regex matches the URI, then the mapped target name is used in the nested
   * call to {@link #doScope(String, Request, HttpServletRequest, HttpServletResponse)}.
   * <p>
   * This handler should be installed as the first handler in a Context.   It can be configured
   * either with direct calls to {@link #addPatternTarget(String, String)} or by setting
   * the context init parameters "org.eclipse.jetty.rewrite.handler.REGEX_MAPPINGS" to a comma
   * separated list of strings in the format regex==target.
   */
  public class RegexTargetHandler extends ScopedHandler
  {
      private final static Logger LOG = Log.getLogger(RegexTargetHandler.class);
      public final static String REGEX_MAPPINGS="org.eclipse.jetty.rewrite.handler.REGEX_MAPPINGS";
      static class RegexMapping
      {
          RegexMapping(String regex,String target)
          {
              _pattern=Pattern.compile(regex);
              _target=target;
          }
          final Pattern _pattern;
          final String _target;
          
          public String toString()
          {
              return _pattern+"=="+_target;
          }
      }
      
      final private List<RegexTargetHandler.RegexMapping> _patterns = new CopyOnWriteArrayList<RegexTargetHandler.RegexMapping>();
      
      /* ------------------------------------------------------------ */
      /** Add a pattern to target mapping.
       * @param pattern The regular expression pattern to match.  
       * @param target The target (normally servlet name) to handle the request
       */
      public void addPatternTarget(String pattern,String target)
      {
          _patterns.add(new RegexMapping(pattern,target));
      }
  
      /* ------------------------------------------------------------ */
      @Override
      protected void doStart() throws Exception
      {
          super.doStart();
          
          Context context = ContextHandler.getCurrentContext();
          if (context!=null)
          {
              String config=context.getInitParameter(REGEX_MAPPINGS);
              LOG.debug("{}={}",REGEX_MAPPINGS,config);
              String[] mappings=config.split("\\s*,\\s*");
              for (String mapping : mappings)
              {
                  mapping=mapping.trim();
                  String[] parts=mapping.split("\\s*==\\s*");
                  if (parts.length==2)
                  {
                      String pattern=parts[0];
                      String target=parts[1];
                      addPatternTarget(pattern,target);
                  }
                  else
                      LOG.warn("Bad regex mapping: "+mapping);
              }
          }
      }
  
      /* ------------------------------------------------------------ */
      @Override
      public void doScope(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
      {
          for (RegexTargetHandler.RegexMapping rm : _patterns)
         {
             Matcher m=rm._pattern.matcher(target);
             if (m.matches())
             {
                 String new_target = rm._target;
                 final String sp;
                 final String pi;
                 
                 if (m.groupCount()==1&&target.endsWith(m.group(1)))
                 {
                     pi=m.group(1);
                     sp=target.substring(0,target.length()-pi.length());
                 }
                 else
                 {
                     sp=target;
                     pi=null;
                 }
                 baseRequest.setServletPath(sp);
                 baseRequest.setPathInfo(pi);
                 baseRequest.setAttribute("org.eclipse.jetty.servlet.REGEX_PATH",target);
                 super.nextScope(new_target,baseRequest,request,response);
                 return;
             }
         }
         super.nextScope(target,baseRequest,request,response);
     }
 
     /* ------------------------------------------------------------ */
     @Override
     public void doHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
     {
         String path=(String)baseRequest.getAttribute("org.eclipse.jetty.servlet.REGEX_PATH");
         if (path==null)
             path=target;
         else
             baseRequest.setAttribute("org.eclipse.jetty.servlet.REGEX_PATH",null);
         
         super.nextHandle(path,baseRequest,request,response);
     }
 
     /* ------------------------------------------------------------ */
     public void dump(Appendable out, String indent) throws IOException
     {
         AggregateLifeCycle.dumpObject(out,this);
         AggregateLifeCycle.dump(out,indent,_patterns,Collections.singletonList(getHandler()));
     }
     
     
 }