/*
    * Copyright 2006 Eric Ballet Baz
    *
    * 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 org.apache.maven.author;
  
  import java.io.File;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.SortedMap;
  import java.util.SortedSet;
  import java.util.TreeMap;
  import java.util.TreeSet;
  
  import org.apache.commons.jelly.tags.ant.FileScanner;
  import org.apache.maven.author.resolver.AuthorResolver;
  
  /**
   * This class is the main entry point to resolve the authors of each file to process.
   * The same file can have multiples authors (multiple author javadoc tag for example).
   *
   * @author Eric Ballet Baz
   */
  public final class FilesByAuthorProvider {
  
      /**
       * Private constructor : do not allow instanciation of this class.
       */
      private FilesByAuthorProvider() {
      }
  
      /**
       * This method is the main entry point to resolve the authors of each file to process.
       * The same file can have multiples authors (multiple author javadoc tags for example).
       *
       * @param filesToProcess List of files to process.
       * @param authorResolverClassNames List of AuthorResolver's class names.
       * @return Sorted map where key is the author and value is a list of filenames. The Map is sorted on author.
       *
       * @throws ClassNotFoundException If a class of a resolver is not found.
       * @throws InstantiationException If a class of a resolver cannot be instanciate.
       * @throws IllegalAccessException If a constructor of a resolver is not accessible.
       */
      public static SortedMap resolveAuthors(final FileScanner filesToProcess, final List authorResolverClassNames)
          throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  
          // Check arguments
          if (filesToProcess == null) {
              throw new IllegalArgumentException("Argument [filesToProcess] should not be null");
          }
          if (authorResolverClassNames == null) {
              throw new IllegalArgumentException("Argument [authorResolverClassNames] should not be null");
          }
  
          // Instanciate the list of resolvers
          AuthorResolver[] authorResolvers = instanciateAuthorResolvers(authorResolverClassNames);
  
          // Process each file, and build a Map where key is the author and value is a list of filenames
          // The Map will be sorted on author
          SortedMap filesByAuthorMap = new TreeMap();
          Iterator it = filesToProcess.iterator();
          while (it.hasNext()) {
              File file = (File) it.next();
  
              // Ask resolvers to find the author(s) of the current file
              String[] authors = resolveAuthorsForFile(file, authorResolvers);
  
              // Add map entry(ies) for this file and the author(s) found
              addAuthorsForFileToMap(filesByAuthorMap, authors, file.getPath());
          }
          return filesByAuthorMap;
      }
  
      /**
       * Resolve the authors of the specified file.
       *
       * @param file File to resolve authors for.
       * @param authorResolvers Array of AuthorResolvers.
       * @return Array of authors. If no author is found an array with an empty string as the unique element is returned.
       */
      private static String[] resolveAuthorsForFile(final File file, final AuthorResolver[] authorResolvers) {
          // Ask each resolvers to find the author(s) of this file
          for (int i = 0; i < authorResolvers.length; i++) {
              String[] currentAuthors = authorResolvers[i].resolveAuthors(file);
  
              // At least an author has been found by this resolver => exit loop
             if (currentAuthors != null && currentAuthors.length > 0) {
                 return currentAuthors;
             }
         }
 
         // No author has been found
         return new String[] {""};
     }
 
     /**
      * Add entry(ies) in the specified Map, where key is an author and value is a sorted set of filenames.
      *
      * @param filesByAuthorMap Map to add entry(ies) into.
      * @param authors Array of authors for the specified filename.
      * @param filename Filename to add.
      */
     private static void addAuthorsForFileToMap(final Map filesByAuthorMap, final String[] authors, final String filename) {
         for (int i = 0; i < authors.length; i++) {
             SortedSet set = (SortedSet) filesByAuthorMap.get(authors[i]);
             if (set == null) {
                 set = new TreeSet();
                 filesByAuthorMap.put(authors[i], set);
             }
             set.add(filename);
         }
     }
 
     /**
      * Instanciate the list of AuthorResolver from their class names.
      *
      * @param authorResolverClassNames List of AuthorResolver's class names.
      * @return List of AuthorResolver.
      *
      * @throws ClassNotFoundException If a class is not found.
      * @throws InstantiationException If a class cannot be instanciate.
      * @throws IllegalAccessException If a constructor is not accessible.
      */
     private static AuthorResolver[] instanciateAuthorResolvers(final List authorResolverClassNames)
         throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 
         AuthorResolver[] resolvers = new AuthorResolver[authorResolverClassNames.size()];
         for (int i = 0; i < authorResolverClassNames.size(); i++) {
             Class cl = Class.forName(((String) authorResolverClassNames.get(i)).trim());
             resolvers[i] = (AuthorResolver) cl.newInstance();
         }
         return resolvers;
     }
 }