/**
    * This file Copyright (c) 2003-2011 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.util;
  
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.context.WebContext;
  
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.regex.Pattern;
  
  import org.apache.commons.lang.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * An implementation of URLPattern which matches strings using simple <code>*</code> or <code>?</code> wildcards.
   * @author Sameer Charles
   * @author Fabrizio Giustina
   * TODO rewrite this class using ant-style path comparison and avoiding regexp. See
   * org.springframework.util.AntPathMatcher in spring 1.2 for a nice implementation.
   * @version $Revision $ ($Author $)
   */
  public final class SimpleUrlPattern implements UrlPattern {
      
      private static final Logger log = LoggerFactory.getLogger(SimpleUrlPattern.class);
  
      /**
       * Stable serialVersionUID.
       */
      private static final long serialVersionUID = 223L;
  
      /**
       * Any char, newline included.
       */
      public static final String URL_CHAR_PATTERN = "."; //$NON-NLS-1$
  
      /**
       * Regexp pattern used for the simple keyword <code>*</code>. Matches 0 or more characters.
       */
      public static final String MULTIPLE_CHAR_PATTERN = URL_CHAR_PATTERN + "*"; //$NON-NLS-1$
  
      /**
       * Regexp pattern used for the simple keyword <code>?</code>. Matches 0 or 1 character.
       */
      public static final String SINGLE_CHAR_PATTERN = URL_CHAR_PATTERN + "?"; //$NON-NLS-1$
  
      /**
       * Regexp pattern used in match().
       */
      private Pattern pattern;
  
      /**
       * Pattern length. Longer patterns have higher priority.
       */
      private int length;
  
      /**
       * internal pattern string.
       */
      private String patternString;
      
      private String site;
  
      /**
       * Compile a regexp pattern handling <code>*</code> and <code>?</code> chars.
       * @param string input string
      * @return a RegExp pattern
      */
     public SimpleUrlPattern(String string) {
         String newPattern = string;
         if(newPattern.startsWith("<")){
             this.site = StringUtils.substringAfter(StringUtils.substringBefore(newPattern, ">"), "<");
             newPattern = StringUtils.substringAfter(newPattern, ">");
         }
         this.length = StringUtils.removeEnd(newPattern, "*").length();
         this.pattern = Pattern.compile(getEncodedString(newPattern), Pattern.DOTALL);
         this.patternString = newPattern;
     }
 
     /**
      * Replace all "*" with <code>RegexWildcardPattern.MULTIPLE_CHAR_PATTERN</code>.
      * @param str input string
      * @return string where all the occurrences of <code>*</code> and <code>?</code> are replaced with a regexp
      * pattern.
      */
     public static String getEncodedString(String str) {
         StringBuffer stringBuffer = new StringBuffer();
         char[] chars = str.toCharArray();
         int i = 0, last = 0;
         while (i < chars.length) {
             char c = chars[i];
             if (c == '*') {
                 stringBuffer.append('(');
                 stringBuffer.append(chars, last, i - last);
                 stringBuffer.append(')');
                 stringBuffer.append(MULTIPLE_CHAR_PATTERN);
                 last = i + 1;
             }
             else if (c == '?') {
                 stringBuffer.append('(');
                 stringBuffer.append(chars, last, i - last);
                 stringBuffer.append(')');
                 stringBuffer.append(SINGLE_CHAR_PATTERN);
                 last = i + 1;
             }
             i++;
         }
         stringBuffer.append(chars, last, i - last);
         return stringBuffer.toString();
     }
 
     public boolean shouldUseFullURI(String pattern, String fullURI){
         //FullURI cannot be null
         if(StringUtils.isBlank(fullURI)){
             return false;
         }
         String patternWithoutLastSlash = StringUtils.removeEnd(pattern, "/");
         //Has to contain pattern it should replace
         if(!fullURI.contains(patternWithoutLastSlash)){
             return false;
         }
         //FullURI should end with pattern if it's not just "/"
         if(StringUtils.isNotBlank(StringUtils.substringAfter(fullURI, patternWithoutLastSlash)) && StringUtils.isNotBlank(patternWithoutLastSlash)){
             return false;
         }
         //FullURI should add just first level node
         if(StringUtils.countMatches(StringUtils.substringBefore(fullURI, patternWithoutLastSlash), "/") > 1){
             return false;
         }
         return true;
     }
 
     /**
      * @see info.magnolia.cms.util.UrlPattern#match(java.lang.String)
      */
     public boolean match(String str) {
         String domainName = getDomainName();
         String siteName = getSiteNameBasedOnDomain(domainName);
         if (StringUtils.isNotBlank(siteName)) {
             // site aware request !!!! URI was shortened
             String fullURI = getFullCurrentURI();
             if(shouldUseFullURI(str, fullURI) && StringUtils.isNotBlank(this.site)){
                 str = fullURI;
             }
         }
         return this.pattern.matcher(str).matches() && matchSiteName(siteName);
     }
     
     public boolean matchSiteName(String siteName){
         // case 1 - no site configured and no site available
         if(this.site == null && siteName == null){
             return true;
         }
 
         // case 2 - site is configured and we don't have site info
         if(this.site != null && siteName == null){
             return false;
         }
 
         // case 4 - permission is NOT site aware, but we have determined the site and changed the URI
         if (this.site == null && siteName != null) {
             return true;
         }
 
         // case 3 - site is configured and we have site info
         return site.equals(siteName);
     }
 
     private String getSiteNameBasedOnDomain(String domain) {
         if(MgnlContext.getInstance() instanceof WebContext){
             AggregationState aggregationState = MgnlContext.getAggregationState();
             if (aggregationState == null) {
                 return null;
             }
             // workaround until we move site to core
             Method getSite;
             try {
                 getSite = aggregationState.getClass().getMethod("getSiteBasedOnDomain", String.class);
                 Object siteName = getSite.invoke(aggregationState, domain);
                 if(null != siteName){
                     return siteName.toString();
                 }
                 return null;
             } catch (NoSuchMethodException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalArgumentException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalAccessException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (InvocationTargetException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             }
             return null;
         }
         return null;
     }
     
     private String getFullCurrentURI() {
         if(MgnlContext.getInstance() instanceof WebContext){
             AggregationState aggregationState = MgnlContext.getAggregationState();
             if (aggregationState == null) {
                 return null;
             }
             // workaround until we move site to core
             Method getFullCurrentURI;
             try {
                 getFullCurrentURI = aggregationState.getClass().getMethod("getFullCurrentURI");
                 Object fullURI = getFullCurrentURI.invoke(aggregationState);
                 if(null != fullURI){
                     return fullURI.toString();
                 }
                 return null;
             } catch (NoSuchMethodException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalArgumentException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalAccessException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (InvocationTargetException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             }
             return null;
         }
         return null;
     }
     
     private String getDomainName() {
         if(MgnlContext.getInstance() instanceof WebContext){
             AggregationState aggregationState = MgnlContext.getAggregationState();
             if (aggregationState == null) {
                 return null;
             }
             // workaround until we move site to core
             Method getDomainName;
             try {
                 getDomainName = aggregationState.getClass().getMethod("getDomainName");
                 Object domainName = getDomainName.invoke(aggregationState);
                 if(null != domainName){
                     return domainName.toString();
                 }
                 return null;
             } catch (NoSuchMethodException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalArgumentException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (IllegalAccessException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             } catch (InvocationTargetException e) {
                 log.debug("Not proper ExtendedAggregationState provided", e);
             }
             return null;
         }
         return null;
     }
 
     /**
      * @see info.magnolia.cms.util.UrlPattern#getLength()
      */
     public int getLength() {
         return this.length;
     }
 
     public String toString() {
         // don't use pattern.pattern(), but keep the original string.
         // The "compiled" pattern will display the ugly patterns like MULTIPLE_CHAR_PATTERN instead of simple *
         return "SimpleUrlPattern{" + patternString + '}';
     }
 }