package net.sourceforge.argval.packageinfo.impl;
   
   
   import java.util.Iterator;
   import java.util.List;
   import java.util.Set;
   import java.util.TreeSet;
   
   import net.sourceforge.argval.collection.CollectionFilter;
  import net.sourceforge.argval.collection.CollectionUtil;
  import net.sourceforge.argval.collection.CollectionUtilConfig;
  import net.sourceforge.argval.collection.CollectionUtilConfigFactory;
  import net.sourceforge.argval.collection.Filter;
  import net.sourceforge.argval.packageinfo.PackageInfo;
  import net.sourceforge.argval.packageinfo.PackageInfoVisitor;
  import net.sourceforge.argval.utils.StringUtil;
  
  
  /**
   * Creates a plain text which shows the visited PackageInfo title 
   * and (implementation) version. And shows all the dot separated package
   * names, which are associated with the <code>Package</code>. 
   * 
   * @author $Author: $
   * @version $Revision: $
   * Last modified: $Date: $
   */
  final public class SimplePackageInfoVisitor implements PackageInfoVisitor {
      public final static int MAX_PACKAGE_NAME_DEPTH = Integer.MAX_VALUE;
  
      private static final String PACKAGE_NAME_SEPARATOR = ".";
      private final static String CONFIG_PACKAGE_NAME = "package name";
  	
      private StringBuffer strBuf = new StringBuffer();
      private int packageNameDepth = MAX_PACKAGE_NAME_DEPTH;
  
  //    private static CollectionUtilConfig config;
      
      private CollectionFilter collectionFilter = null;
      private CollectionUtilConfigFactory configFactory = null;
  
  	
  	/**
  	 * Create a plain text, which will include all package names assosiated with the
  	 * visited <code>PackageInfo</code> instances.
  	 */
  	public SimplePackageInfoVisitor(CollectionUtilConfigFactory configFactory, CollectionFilter collectionFilter) {
  		super();
          this.configFactory = configFactory;
          this.collectionFilter = collectionFilter;
          configFactory.create(CONFIG_PACKAGE_NAME, PACKAGE_NAME_SEPARATOR);
  	}
      public SimplePackageInfoVisitor() {
          this(new CollectionUtilConfigFactory(), new CollectionFilter());
      }
  	/**
  	 * Create a plain text, of all visited PackageInfo instances. With or without the
  	 * package names (Java language dot separated names, like 
  	 * <code>net.sourceforge.argval.packageinfo</code> ). 
  	 *  
  	 * @param  isIncludePackageNameActive  When <code>true</code> all package names 
  	 *         assosiated with this <code>Package</code> are added to the text.
  	 */
  	public SimplePackageInfoVisitor(boolean isIncludePackageNameActive) {
  		this((isIncludePackageNameActive) ? MAX_PACKAGE_NAME_DEPTH : 0);
  	}
      public SimplePackageInfoVisitor(int packageNameDepth) {
          this(packageNameDepth, null);
      }
      public SimplePackageInfoVisitor(Filter filter) {
          this(MAX_PACKAGE_NAME_DEPTH, filter);
      }
      public SimplePackageInfoVisitor(int packageNameDepth, Filter filter) {
          this();
          this.packageNameDepth = packageNameDepth;
          this.collectionFilter = new CollectionFilter(filter);
      }
  	
  
  	/** {@inheritDoc} 
  	 *
  	 * Adds the details (title and version) of each <code>PackageInfo</code> instance and 
  	 * all the package names (The Java language dot separated package names), which are 
  	 * associated with this package.
  	 */
  	public void visit(PackageInfo packageInfo) {
          if (PackageInfo.UNKNOWN_PACKAGE_TITLE.equals(packageInfo.getTitle())) {
              // Only include this if package names (and class names) should be included.
              if (packageNameDepth > 0) {
                  //strBuf.append(packageInfo.getTitle().toUpperCase());
                  strBuf.append("Loaded packages, from which no Specification/Implementation title (and version) is known");
              }
          }
          else {
              strBuf.append(packageInfo.getTitle());
          }
          if (packageInfo.getImplementationVersion() != null) {
              strBuf.append("  [").append(packageInfo.getImplementationVersion()).append("]");
          }
         strBuf.append(StringUtil.LINE_SEPARATOR);
         if (packageNameDepth > 0) {
             // Only chop package names, if the given package name depth (to show) is smaller then the maximum one.
             Set<String> compactNameSet = (packageNameDepth == MAX_PACKAGE_NAME_DEPTH) 
                     ? convert(packageInfo.getNameSet())
                     : chop(convert(packageInfo.getNameSet()), configFactory.getConfig(CONFIG_PACKAGE_NAME), packageNameDepth);
             
             // Filter away package names that start with 'java' or 'sun' a.k. all the JDK packages.
             Set<String> filteredSet = collectionFilter.filter(compactNameSet);        
 
             // Add the package names to the text 
             for (Iterator<String> nameIter = filteredSet.iterator(); nameIter.hasNext(); ) {
 	            strBuf.append("  ").append(nameIter.next()).append(StringUtil.LINE_SEPARATOR);
 	        }
         }
         strBuf.append(StringUtil.LINE_SEPARATOR);
 	}
     
     
     private TreeSet<String> convert(Set<?> originalSet) {
         TreeSet<String> newSet = new TreeSet<String>();
         for (Object object : originalSet) {
             newSet.add(object.toString());
         }
         return newSet;
     }
     
     
     // TODO [2007.07.06 tv] Refactor this
     private static TreeSet<String> chop(Set<String> nameSet, CollectionUtilConfig config, int maxDepth) {
         TreeSet<String> compactNameSet = new TreeSet<String>();
         for (Iterator<String> iter = nameSet.iterator(); iter.hasNext(); ) {
             String name = (String)iter.next();
 //            System.out.println("name: " + name);
             List<String> nameList = CollectionUtil.stringToList(name, PACKAGE_NAME_SEPARATOR);
 //            System.out.println(CollectionUtil.toString(nameList));
             while (nameList.size() > maxDepth) {
 //                System.out.println("Removing index [" + nameList.size() + "] element '" + nameList.get(nameList.size() - 1) + "'");
                 nameList.remove(nameList.size() - 1);
             }
             String compactName = CollectionUtil.toString(nameList, config);
             compactNameSet.add(compactName);
 //            System.out.println(compactName);
         }
         return compactNameSet;
     }
 
 
     /** {@inheritDoc} */
 	public String toString() {
 		return strBuf.toString();
 	}
 
 }