package org.codehaus.plexus.util;
   
   /*
    * Copyright The Codehaus Foundation.
    *
    * 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.
   */
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Stack;
  
  /**
   * DirectoryWalker
   *
   *
   */
  public class DirectoryWalker {
      /**
       * DirStackEntry is an Item on the {@link DirectoryWalker#dirStack}
       */
      class DirStackEntry {
          /**
           * Count of files in the directory.
           */
          public int count;
  
          /**
           * Current Directory.
           */
          public File dir;
  
          /**
           * Index (or offset) within the directory count.
           */
          public int index;
  
          /**
           * Offset for percentage calculations. Based on parent DirStackEntry.
           */
          public double percentageOffset;
  
          /**
           * Size of percentage space to work with.
           */
          public double percentageSize;
  
          /**
           * Create a DirStackEntry.
           *
           * @param d the directory to track
           * @param length the length of entries in the directory.
           */
          public DirStackEntry(File d, int length) {
              dir = d;
              count = length;
          }
  
          /**
           * Calculate the next percentage offset. Used by the next DirStackEntry.
           *
           * @return the value for the next percentage offset.
           */
          public double getNextPercentageOffset() {
              return percentageOffset + (index * (percentageSize / count));
          }
  
          /**
           * Calculate the next percentage size. Used by the next DirStackEntry.
           *
           * @return the value for the next percentage size.
           */
          public double getNextPercentageSize() {
              return (percentageSize / count);
          }
  
          /**
           * The percentage of the DirStackEntry right now. Based on count, index, percentageOffset, and percentageSize.
           *
           * @return the percentage right now.
           */
          public int getPercentage() {
              double percentageWithinDir = (double) index / (double) count;
              return (int) Math.floor(percentageOffset + (percentageWithinDir * percentageSize));
          }
  
          @Override
         public String toString() {
             return "DirStackEntry[" + "dir=" + dir.getAbsolutePath() + ",count=" + count + ",index=" + index
                     + ",percentageOffset=" + percentageOffset + ",percentageSize=" + percentageSize + ",percentage()="
                     + getPercentage() + ",getNextPercentageOffset()=" + getNextPercentageOffset()
                     + ",getNextPercentageSize()=" + getNextPercentageSize() + "]";
         }
     }
 
     private File baseDir;
 
     private int baseDirOffset;
 
     private Stack<DirectoryWalker.DirStackEntry> dirStack;
 
     private List<String> excludes;
 
     private List<String> includes;
 
     private boolean isCaseSensitive = true;
 
     private List<DirectoryWalkListener> listeners;
 
     private boolean debugEnabled = false;
 
     public DirectoryWalker() {
         includes = new ArrayList<String>();
         excludes = new ArrayList<String>();
         listeners = new ArrayList<DirectoryWalkListener>();
     }
 
     public void addDirectoryWalkListener(DirectoryWalkListener listener) {
         listeners.add(listener);
     }
 
     public void addExclude(String exclude) {
         excludes.add(fixPattern(exclude));
     }
 
     public void addInclude(String include) {
         includes.add(fixPattern(include));
     }
 
     /**
      * Add's to the Exclude List the default list of SCM excludes.
      */
     public void addSCMExcludes() {
         String scmexcludes[] = AbstractScanner.DEFAULTEXCLUDES;
         for (String scmexclude : scmexcludes) {
             addExclude(scmexclude);
         }
     }
 
     private void fireStep(File file) {
         DirStackEntry dsEntry = dirStack.peek();
         int percentage = dsEntry.getPercentage();
         for (Object listener1 : listeners) {
             DirectoryWalkListener listener = (DirectoryWalkListener) listener1;
             listener.directoryWalkStep(percentage, file);
         }
     }
 
     private void fireWalkFinished() {
         for (DirectoryWalkListener listener1 : listeners) {
             listener1.directoryWalkFinished();
         }
     }
 
     private void fireWalkStarting() {
         for (DirectoryWalkListener listener1 : listeners) {
             listener1.directoryWalkStarting(baseDir);
         }
     }
 
     private void fireDebugMessage(String message) {
         for (DirectoryWalkListener listener1 : listeners) {
             listener1.debug(message);
         }
     }
 
     private String fixPattern(String pattern) {
         String cleanPattern = pattern;
 
         if (File.separatorChar != '/') {
             cleanPattern = cleanPattern.replace('/', File.separatorChar);
         }
 
         if (File.separatorChar != '\\') {
             cleanPattern = cleanPattern.replace('\\', File.separatorChar);
         }
 
         return cleanPattern;
     }
 
     public void setDebugMode(boolean debugEnabled) {
         this.debugEnabled = debugEnabled;
     }
 
     /**
      * @return Returns the baseDir.
      */
     public File getBaseDir() {
         return baseDir;
     }
 
     /**
      * @return Returns the excludes.
      */
     public List<String> getExcludes() {
         return excludes;
     }
 
     /**
      * @return Returns the includes.
      */
     public List<String> getIncludes() {
         return includes;
     }
 
     private boolean isExcluded(String name) {
         return isMatch(excludes, name);
     }
 
     private boolean isIncluded(String name) {
         return isMatch(includes, name);
     }
 
     private boolean isMatch(List<String> patterns, String name) {
         for (String pattern1 : patterns) {
             if (SelectorUtils.matchPath(pattern1, name, isCaseSensitive)) {
                 return true;
             }
         }
 
         return false;
     }
 
     private String relativeToBaseDir(File file) {
         return file.getAbsolutePath().substring(baseDirOffset + 1);
     }
 
     /**
      * Removes a DirectoryWalkListener.
      *
      * @param listener the listener to remove.
      */
     public void removeDirectoryWalkListener(DirectoryWalkListener listener) {
         listeners.remove(listener);
     }
 
     /**
      * Performs a Scan against the provided {@link #setBaseDir(File)}
      */
     public void scan() {
         if (baseDir == null) {
             throw new IllegalStateException("Scan Failure.  BaseDir not specified.");
         }
 
         if (!baseDir.exists()) {
             throw new IllegalStateException("Scan Failure.  BaseDir does not exist.");
         }
 
         if (!baseDir.isDirectory()) {
             throw new IllegalStateException("Scan Failure.  BaseDir is not a directory.");
         }
 
         if (includes.isEmpty()) {
             // default to include all.
             addInclude("**");
         }
 
         if (debugEnabled) {
             Iterator<String> it;
             StringBuilder dbg = new StringBuilder();
             dbg.append("DirectoryWalker Scan");
             dbg.append("\n  Base Dir: ").append(baseDir.getAbsolutePath());
             dbg.append("\n  Includes: ");
             it = includes.iterator();
             while (it.hasNext()) {
                 String include = it.next();
                 dbg.append("\n    - \"").append(include).append("\"");
             }
             dbg.append("\n  Excludes: ");
             it = excludes.iterator();
             while (it.hasNext()) {
                 String exclude = it.next();
                 dbg.append("\n    - \"").append(exclude).append("\"");
             }
             fireDebugMessage(dbg.toString());
         }
 
         fireWalkStarting();
         dirStack = new Stack<DirStackEntry>();
         scanDir(baseDir);
         fireWalkFinished();
     }
 
     private void scanDir(File dir) {
         File[] files = dir.listFiles();
 
         if (files == null) {
             return;
         }
 
         DirectoryWalker.DirStackEntry curStackEntry = new DirectoryWalker.DirStackEntry(dir, files.length);
         if (dirStack.isEmpty()) {
             curStackEntry.percentageOffset = 0;
             curStackEntry.percentageSize = 100;
         } else {
             DirectoryWalker.DirStackEntry previousStackEntry = dirStack.peek();
             curStackEntry.percentageOffset = previousStackEntry.getNextPercentageOffset();
             curStackEntry.percentageSize = previousStackEntry.getNextPercentageSize();
         }
 
         dirStack.push(curStackEntry);
 
         for (int idx = 0; idx < files.length; idx++) {
             curStackEntry.index = idx;
             String name = relativeToBaseDir(files[idx]);
 
             if (isExcluded(name)) {
                 fireDebugMessage(name + " is excluded.");
                 continue;
             }
 
             if (files[idx].isDirectory()) {
                 scanDir(files[idx]);
             } else {
                 if (isIncluded(name)) {
                     fireStep(files[idx]);
                 }
             }
         }
 
         dirStack.pop();
     }
 
     /**
      * @param baseDir The baseDir to set.
      */
     public void setBaseDir(File baseDir) {
         this.baseDir = baseDir;
         baseDirOffset = baseDir.getAbsolutePath().length();
     }
 
     /**
      * @param entries The excludes to set.
      */
     public void setExcludes(List<String> entries) {
         excludes.clear();
         if (entries != null) {
             for (String entry : entries) {
                 excludes.add(fixPattern(entry));
             }
         }
     }
 
     /**
      * @param entries The includes to set.
      */
     public void setIncludes(List<String> entries) {
         includes.clear();
         if (entries != null) {
             for (String entry : entries) {
                 includes.add(fixPattern(entry));
             }
         }
     }
 }