/*
    * Copyright 2007 Hippo
    *
    * Licensed 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 nl.hippo.client.webdav;
  
  import java.util.regex.Pattern;
  
  import nl.hippo.client.api.content.DocumentPath;
  
  import org.apache.commons.lang.builder.HashCodeBuilder;
  import org.apache.commons.lang.builder.ToStringBuilder;
  import org.apache.commons.lang.builder.ToStringStyle;
  
  /**
   * Represents a path in the repository. 
   * 
   * <p>
   * <b>methods</b>
   * <ul>
   * <li>getNamespace()    => returns hippo.client.namespace from WebdavConfig</li>
   * <li>getFilesPath()    => returns hippo.client.filespath from WebdavConfig</li>
   * <li>getRootPath()     => returns getNameSpace() + getFilesPath() or getPrefixPath() + getFilesPath()</li>
   * <li>getRelativePath() => returns the relative documentpath (getFullPath() - getRootPath())</li>
   * <li>getFullPath()     => returns getRootPath() + getRelativePath()</li>
   * </ul>
   * </p>
   * 
   * <p>
   * <b>slashes</b>
   * <ul>
   * <li>getNamespace() -> without any slashes</li> 
   * <li>All other methods -> starts with slash and ends without slash</li>
   * </ul>
   * 
   * These rules are guaranteed even if the configuration isn't completely clean,
   * ie "namespace = /default/"
   * </p>
   */
  public class DocumentPathImpl implements DocumentPath {
  
      private static final long serialVersionUID = 1L;
  
      private String contextroot;
      private String namespace;
      private String filesPath;
      private String fullPath;
      private String rootPath;
      private String relativePath;
  
      public DocumentPathImpl(String namespace, String contextroot, String filesPath, String path, boolean isRelative) {
          this(namespace, contextroot, filesPath, new String[] { path }, isRelative);
      }
  
      public DocumentPathImpl(String namespace, String contextroot, String filesPath, String[] pathElems,
              boolean isRelative) {
          if (namespace == null) {
              throw new IllegalArgumentException("namespace may not be null");
          }
          if (pathElems == null) {
              throw new IllegalArgumentException("pathElems may not be null");
          }
  
          if(contextroot != null) {
              this.contextroot = contextroot.equals("/") ? "" : fixPath(contextroot);
          } else {
              this.contextroot = null;
          }
          this.namespace = namespace.replaceAll("/+", "");
          this.filesPath = fixPath(filesPath);
          if (this.contextroot != null) {
              this.rootPath = fixPath(this.contextroot + this.filesPath);
          } else {
              this.rootPath = fixPath(this.namespace + this.filesPath);
          }
  
          StringBuffer buf = new StringBuffer();
          for (int i = 0; i < pathElems.length; i++) {
              buf.append(fixPath(pathElems[i]));
          }
          String path = fixPath(buf.toString());
  
          if (isRelative) {
              this.fullPath = rootPath + path;
              this.relativePath = path;
  
          } else {
              this.fullPath = path;
             if (!fullPath.startsWith(rootPath)) {
                 throw new IllegalArgumentException("Absolute path '" + fullPath
                         + "' cannot be constructed if root path is configured as '" + rootPath + "'");
             }
             this.relativePath = fullPath.substring(rootPath.length(), fullPath.length());
         }
     }
 
     // Regular expression matching two or more consecutive slashes
     private static final Pattern multipleSlashes = Pattern.compile("/{2,}");
 
     /**
      * Ensure that:
      * <ol>
      * <li>path is '/' rather than null or an empty String</li>
      * <li>there are only single '/' occurences</li>
      * <li>path starts with one and only one '/'</li>
      * <li>path ends without a '/'</li>
      * </ol>
      */
     private String fixPath(String path) {
         // rule number 1
         if (path == null || path.length() == 0) {
             path = "/";
         }
 
         // rule number 2
         path = multipleSlashes.matcher(path).replaceAll("/");
 
         // rule number 3
         if (!path.startsWith("/")) {
             path = "/" + path;
         }
 
         // rule number 4
         if (path.endsWith("/")) {
             path = path.substring(0, path.length() - 1);
         }
 
         return path;
     }
 
     public String getContextRoot() {
         return contextroot;
     }
 
     public String getNamespace() {
         return namespace;
     }
 
     public String getFilesPath() {
         return filesPath;
     }
 
     public String getRootPath() {
         return rootPath;
     }
 
     public String getRelativePath() {
         return relativePath;
     }
 
     public String getFullPath() {
         return fullPath;
     }
 
     public DocumentPath createAbsolutePath(String absolute) {
         return createAbsolutePath(new String[] { absolute });
     }
 
     public DocumentPath createAbsolutePath(String[] pathElems) {
         return new DocumentPathImpl(this.namespace, this.contextroot, this.filesPath, pathElems, false);
     }
 
     public DocumentPath createRelativePath(String relative) {
         return createRelativePath(new String[] { relative });
     }
 
     public DocumentPath createRelativePath(String[] pathElems) {
         return new DocumentPathImpl(this.namespace, this.contextroot, this.filesPath, pathElems, true);
     }
 
     public String toString() {
         ToStringBuilder builder = new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).append("namespace",
                 namespace).append("contextroot", (contextroot != null ? contextroot : "")).append("filesPath",
                 filesPath).append("fullPath", fullPath).append("rootPath", rootPath).append("relativePath",
                 relativePath);
         return builder.toString();
     }
 
     public boolean equals(Object obj) {
         boolean eq;
         if (obj == null) {
             eq = false;
         } else if (!(obj instanceof DocumentPathImpl)) {
             eq = false;
         } else if (this == obj) {
             eq = true;
         } else {
             DocumentPathImpl rhs = (DocumentPathImpl) obj;
             eq = ((contextroot == null && rhs.contextroot == null) || (contextroot != null && rhs.contextroot != null && contextroot
                     .equals(rhs.contextroot)))
                     && (namespace.equals(rhs.namespace) && filesPath.equals(rhs.filesPath) && fullPath
                             .equals(rhs.fullPath));
         }
         return eq;
     }
 
     public int hashCode() {
         int hash;
         if (contextroot != null) {
             hash = new HashCodeBuilder(23, 77).append(namespace).append(contextroot).append(filesPath).append(fullPath)
                 .append(rootPath).append(relativePath).toHashCode();
         } else {
             hash = new HashCodeBuilder(23, 77).append(namespace).append(filesPath).append(fullPath).append(rootPath)
                     .append(relativePath).toHashCode();
         }
         return hash;
     }
 
 }