/*
    * 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.jxr.pacman;
  
  import java.io.IOException;
  import java.nio.file.Path;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.codehaus.plexus.util.DirectoryScanner;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Given a list of directories, parse them out and store them as rendered
   * packages, classes, imports, etc.
   */
  public class PackageManager {
      private static final Logger LOGGER = LoggerFactory.getLogger(PackageManager.class);
  
      private final FileManager fileManager;
  
      private Set<Path> directories = new HashSet<>();
  
      /**
       * All the packages that have been parsed
       */
      private Map<String, PackageType> packages = new HashMap<>();
  
      /**
       * The default Java package.
       */
      private PackageType defaultPackage = new PackageType();
  
      /**
       * The list of exclude patterns to use.
       */
      private String[] excludes = null;
  
      /**
       * The list of include patterns to use.
       */
      private String[] includes = {"**/*.java"};
  
      public PackageManager(FileManager fileManager) {
          this.fileManager = fileManager;
      }
  
      /**
       * Given the name of a package (Ex: org.apache.maven.util) obtain it from
       * the package manager.
       *
       * @param name name of package
       * @return package type if found or default package type
       */
      public PackageType getPackageType(String name) {
          // return the default package if the name is null.
          if (name == null) {
              return defaultPackage;
          }
  
          return this.packages.get(name);
      }
  
      /**
       * Add a package to this package manager.
       *
       * @param packageType package type to add
       */
      public void addPackageType(PackageType packageType) {
          this.packages.put(packageType.getName(), packageType);
      }
  
      /**
       * Gets all of the packages in this package manager.
       *
       * @return package types
       */
      public Collection<PackageType> getPackageTypes() {
          return packages.values();
     }
 
     /**
      * Parse out all the directories on which this depends.
      */
     private void parse(Path baseDir) {
         // Go through each directory and get the java source
         // files for this dir.
         LOGGER.debug("Scanning " + baseDir);
         DirectoryScanner directoryScanner = new DirectoryScanner();
         directoryScanner.setBasedir(baseDir.toFile());
         directoryScanner.setExcludes(excludes);
         directoryScanner.setIncludes(includes);
         directoryScanner.scan();
 
         for (String file : directoryScanner.getIncludedFiles()) {
             LOGGER.debug("parsing... " + file);
 
             // now parse out this file to get the packages/classname/etc
             try {
                 Path fileName = baseDir.resolve(file);
                 JavaFile jfi = fileManager.getFile(fileName);
 
                 // now that we have this parsed out blend its information
                 // with the current package structure
                 PackageType jp = this.getPackageType(jfi.getPackageType().getName());
 
                 if (jp == null) {
                     this.addPackageType(jfi.getPackageType());
                     jp = jfi.getPackageType();
                 }
 
                 // Add the current file's class(es) to this global package.
                 if (jfi.getClassTypes() != null && !jfi.getClassTypes().isEmpty()) {
                     for (ClassType ct : jfi.getClassTypes()) {
                         jp.addClassType(ct);
                     }
                 }
 
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
 
     public void process(Path directory) {
         if (this.directories.add(directory)) {
             this.parse(directory);
         }
     }
 
     /**
      * Dump the package information to STDOUT. FOR DEBUG ONLY
      */
     public void dump() {
 
         LOGGER.debug("Dumping out PackageManager structure");
 
         for (PackageType current : getPackageTypes()) {
             LOGGER.debug(current.getName());
 
             // get the classes under the package and print those too.
             for (ClassType currentClass : current.getClassTypes()) {
                 LOGGER.debug('\t' + currentClass.getName());
             }
         }
     }
 
     public void setExcludes(String[] excludes) {
         this.excludes = excludes;
     }
 
     public void setIncludes(String[] includes) {
         this.includes = includes;
     }
 }