/*
    * 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.maven.plugins.war.util;
  
  import java.io.File;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.Set;
  
  import org.codehaus.plexus.util.DirectoryScanner;
  
  /**
   * Set of file's paths.
   *
   * The class extends functionality of a "normal" set of strings by a process of the paths normalization. All paths are
   * converted to unix form (slashes) and they don't start with starting /.
   *
   * @author Piotr Tabor
   */
  public class PathSet implements Iterable<String> {
      private static final String SEPARATOR = "/";
      private static final char SEPARATOR_CHAR = SEPARATOR.charAt(0);
      /**
       * Set of normalized paths
       */
      private Set<String> pathsSet = new LinkedHashSet<>();
  
      static String normalizeSubPath(String path) {
          if (path.isEmpty()) {
              return path;
          }
          String cleanPath = path.replaceAll("[\\\\]+", SEPARATOR).replaceAll("[/]+", SEPARATOR);
          cleanPath = cleanPath.charAt(0) == SEPARATOR_CHAR ? cleanPath.substring(1) : cleanPath;
          if (cleanPath.isEmpty()) {
              return cleanPath;
          }
          if (cleanPath.charAt(cleanPath.length() - 1) == SEPARATOR_CHAR) {
              return cleanPath.substring(0, cleanPath.length() - 1);
          }
          return cleanPath;
      }
  
      /*-------------------- Business interface ------------------------------*/
  
      /**
       * Creates an empty paths set
       */
      public PathSet() {
          /* Empty default constructor */
      }
  
      /**
       * Creates paths set and normalizate and adds all 'paths'. The source 'paths' will not be changed
       *
       * @param paths to be added
       */
      public PathSet(Collection<String> paths) {
          addAll(paths);
      }
  
      /**
       * Creates paths set and normalizate and adds all 'paths'. The source 'paths' will not be changed
       *
       * @param paths to be added
       */
      public PathSet(String[] paths) {
          addAll(paths);
      }
  
      /**
       * Normalizes and adds given path to the set.
       *
       * @param path to be added
       */
      public void add(String path) {
          pathsSet.add(normalizeSubPath(path));
      }
  
      /**
       * Normalizes and adds given paths (collection of strings) to the set. The source collection will not be changed
       *
      * @param paths - collection of strings to be added
      * @param prefix added to all given paths
      */
     public void addAll(Collection<String> paths, String prefix) {
         for (String val : paths) {
             add(prefix + SEPARATOR + val);
         }
     }
 
     /**
      * Normalizes and adds given paths to the set. The source collection will not be changed
      *
      * @param paths to be added
      * @param prefix added to all given paths
      */
     public void addAll(String[] paths, String prefix) {
         for (String val : paths) {
             add(prefix + SEPARATOR + val);
         }
     }
 
     /**
      * Adds given paths to the set. The source collection will not be changed
      *
      * @param paths to be added
      * @param prefix added to all given paths
      */
     public void addAll(PathSet paths, String prefix) {
         for (String path : paths) {
             add(prefix + SEPARATOR + path);
         }
     }
 
     /**
      * Normalizes and adds given paths (collection of strings) to the set. The source collection will not be changed
      *
      * @param paths - collection of strings to be added
      */
     public void addAll(Collection<String> paths) {
         addAll(paths, "");
     }
 
     /**
      * Normalizes and adds given paths to the set. The source collection will not be changed
      *
      * @param paths to be added
      */
     public void addAll(String[] paths) {
         addAll(paths, "");
     }
 
     /**
      * Adds given paths to the set. The source collection will not be changed
      *
      * @param paths to be added
      */
     public void addAll(PathSet paths) {
         addAll(paths, "");
     }
 
     /**
      * Checks if the set constains given path. The path is normalized before check.
      *
      * @param path we are looking for in the set.
      * @return information if the set constains the path.
      */
     public boolean contains(String path) {
         return pathsSet.contains(normalizeSubPath(path));
     }
 
     /**
      * Removes the specified path if it exists.
      *
      * @param path the path to remove
      * @return true if the path was removed, false if it did not existed
      */
     boolean remove(String path) {
         return pathsSet.remove(normalizeSubPath(path));
     }
 
     /**
      * Returns iterator of normalized paths (strings)
      *
      * @return iterator of normalized paths (strings)
      */
     @Override
     public Iterator<String> iterator() {
         return pathsSet.iterator();
     }
 
     /**
      * @return {@link #pathsSet}
      */
     public Collection<String> paths() {
         return pathsSet;
     }
 
     /**
      * Adds given prefix to all paths in the set.
      *
      * The prefix should be ended by '/'. The generated paths are normalized.
      *
      * @param prefix to be added to all items
      */
     public void addPrefix(String prefix) {
         final Set<String> newSet = new HashSet<>();
         for (String path : pathsSet) {
             newSet.add(normalizeSubPath(prefix + path));
         }
         pathsSet = newSet;
     }
 
     /**
      * Returns count of the paths in the set
      *
      * @return count of the paths in the set
      */
     public int size() {
         return pathsSet.size();
     }
 
     /**
      * Adds to the set all files in the given directory
      *
      * @param directory that will be searched for file's paths to add
      * @param prefix to be added to all found files
      */
     public void addAllFilesInDirectory(File directory, String prefix) {
         DirectoryScanner scanner = new DirectoryScanner();
         scanner.setBasedir(directory);
         scanner.scan();
         addAll(scanner.getIncludedFiles(), prefix);
     }
 }