/*
    * 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.commons.finder;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Searches for files that match certain criteria in a directory, and
   * typically also subdirectories.
   * <p>
   * This is a programmatic equivalent of the search functions present
   * in many operating systems. You can be informed dynamically of
   * events as they occur by adding a listener.
   * 
   * @author Henri Yandell
   * @version $Id: FileFinder.java 437543 2006-08-28 05:47:51Z bayard $
   * @since 1.1
   */
  public class FileFinder implements Finder {
  
      /** The list of listeners. */
      private List findListeners;
  
      /**
       * Constructor.
       */
      public FileFinder() {
          super();
      }
  
      //-----------------------------------------------------------------------
      /**
       * Find all files in the specified directory.
       * 
       * @param directory  the directory to search in
       */
      public File[] find(File directory) {
          return find(directory, Collections.EMPTY_MAP);
      }
  
      /**
       * Finds files in the specified directory that match the given options.
       * 
       * @param directory  the directory to search in
       * @param options  the options to use
       */
      public File[] find(File directory, Map options) {
          List retlist = new ArrayList();
          find(directory, options, retlist);
          File[] files = (File[]) retlist.toArray(new File[retlist.size()]);
          return files;
      }
  
      /**
       * Finds files in the specified directory that match the given options.
       * The results are added to the non-null list provided.
       * <p>
       * Note: To avoid large memory allocations, avoid adding any FileListeners,
       * and try overwriding List.add(Object o) instead.
       * 
       * @param directory  the directory to search in
       * @param options  the options to use
       * @param foundFiles  a List to which all found files will be added
       */
      public void find(File directory, Map options, List foundFiles) {
          if (foundFiles == null) {
              throw new IllegalArgumentException("foundFiles list cannot be null");
          }
          
          notifyDirectoryStarted(directory);
          boolean depthFirst = toBoolean(options.get(Finder.DEPTH));
          int maxDepth = toInt(options.get(Finder.MAXDEPTH));
          int minDepth = toInt(options.get(Finder.MINDEPTH));
          boolean ignoreHiddenDirs = toBoolean(options.get(Finder.IGNORE_HIDDEN_DIRS));
          
          FindingFilter filter = new FindingFilter(options);
          int startIdx = foundFiles.size();
          find(directory, filter, depthFirst, foundFiles);
          if (filter.accept(directory)) {
              if (depthFirst) {
                 foundFiles.add(directory);
             } else {
                 foundFiles.add(0, directory);
             }
         }
         int endIdx = foundFiles.size();
         notifyDirectoryFinished(directory, foundFiles, startIdx, endIdx);        
     }
 
     private void find(File directory, FindingFilter filter, boolean depthFirst, List retlist) {
         // we can't use listFiles(filter) here, directories don't work correctly
         File[] list = directory.listFiles();
         if (list == null) {
             return;
         }
         int sz = list.length;
         for (int i = 0; i < sz; i++) {
             File tmp = list[i];
             if (!depthFirst && filter.accept(tmp)) {
                 retlist.add(tmp);
                 notifyFileFound(directory, tmp);
             }
             if (tmp.isDirectory()) {
                 notifyDirectoryStarted(tmp);
                 int startIdx = retlist.size();
                 find(tmp, filter, depthFirst, retlist);
                 int endIdx = retlist.size();
                 notifyDirectoryFinished(tmp, retlist, startIdx, endIdx);
             }
             if (depthFirst && filter.accept(tmp)) {
                 retlist.add(tmp);
                 notifyFileFound(directory, tmp);
             }
         }
     }
 
     //-----------------------------------------------------------------------
     /**
      * Adds a FindListener that is notified when a file is found.
      * 
      * @param listener  the listener
      */
     public void addFindListener(FindListener listener) {
         if (findListeners == null) {
             findListeners = new ArrayList();
         }
         findListeners.add(listener);
     }
 
     /**
      * Removes a FindListener.
      * 
      * @param listener  the listener
      */
     public void removeFindListener(FindListener listener) {
         if (findListeners != null) {
             findListeners.remove(listener);
         }
     }
 
     //-----------------------------------------------------------------------
     /**
      * Notify all FindListeners that a directory is being started.
      * 
      * @param directory  the directory
      */
     protected void notifyDirectoryStarted(File directory) {
         if (!directory.isDirectory()) {
             return;
         }
         if (findListeners != null) {
             FindEvent fe = new FindEvent(this, "directoryStarted", directory);
             Iterator it = findListeners.iterator();
             while (it.hasNext()) {
                 FindListener findListener = (FindListener) it.next();
                 findListener.directoryStarted(fe);
             }
         }
     }
 
     /**
      * Notify all FindListeners that a directory has been finished.
      * 
      * @param directory  the directory
      * @param files  the files that were found in the directory
      */
     protected void notifyDirectoryFinished(File directory, File[] files) {
         if (!directory.isDirectory()) {
             return;
         }
         if (findListeners != null) {
             FindEvent fe = new FindEvent(this, "directoryFinished", directory, files);
             Iterator it = findListeners.iterator();
             while (it.hasNext()) {
                 FindListener findListener = (FindListener) it.next();
                 findListener.directoryFinished(fe);
             }
         }
     }
 
     private void notifyDirectoryFinished(File directory, List files, int startIdx, int endIdx) {
         // only allocate a File array if we really have to 
         if (!directory.isDirectory() || findListeners == null || findListeners.size() == 0) {
             return;
         }
         
         // we should drop this when/if FindEvent stops dealing with File arrays
         File[] filesa = (File[]) files.subList(startIdx, endIdx).toArray(new File[endIdx - startIdx]);
         notifyDirectoryFinished(directory, filesa);
         
     }
 
     /**
      * Notifies each FindListeners that a file has been found.
      * 
      * @param directory  the directory being processed
      * @param file  the file that was found
      */
     protected void notifyFileFound(File directory, File file) {
         if (file.isDirectory()) {
             return;
         }
         if (findListeners != null) {
             FindEvent fe = new FindEvent(this, "fileFound", directory, file);
             Iterator it = findListeners.iterator();
             while (it.hasNext()) {
                 FindListener findListener = (FindListener) it.next();
                 findListener.fileFound(fe);
             }
         }
     }
 
     //-----------------------------------------------------------------------
     /**
      * Converts an object to an int.
      * 
      * @param obj  the object
      * @return an int
      */
     private static int toInt(Object obj) {
         if (obj == null) {
             return 0;
         } else if (obj instanceof Number) {
             return ((Number) obj).intValue();
         } else {
             String str = obj.toString();
             try {
                 return Integer.parseInt(str.toString());
             } catch(NumberFormatException nfe) {
                 throw new IllegalArgumentException("String argument " + str + " must be parseable as an integer");
             }
         }
     }
 
     /**
      * Converts an object to a boolean.
      * 
      * @param obj  the object
      * @return a boolean
      */
     private static boolean toBoolean(Object obj) {
         if (obj == null) {
             return false;
         } else if (obj instanceof Boolean) {
             return ((Boolean) obj).booleanValue();
         } else if (obj instanceof Number) {
             return ((Number) obj).intValue() != 0;
         } else {
             String str = obj.toString();
             return new Boolean(str).booleanValue();
         }
     }
 
 }