package net.sourceforge.argval.manifestinfo.impl;
   
   
   import java.io.File;
   import java.io.IOException;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   import java.util.Set;
  import java.util.TreeSet;
  import java.util.Map.Entry;
  import java.util.jar.Attributes;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  import java.util.regex.Pattern;
  
  import net.sourceforge.argval.lang.SystemConstants;
  import net.sourceforge.argval.manifestinfo.ManifestInfo;
  import net.sourceforge.argval.manifestinfo.ManifestInfoManager;
  import net.sourceforge.argval.manifestinfo.ManifestInfoVisitor;
  import net.sourceforge.argval.packageinfo.PackageInfo;
  import net.sourceforge.argval.packageinfo.PackageInfoVisitor;
  import net.sourceforge.argval.packageinfo.PackageInfoVisitorAcceptor;
  import net.sourceforge.argval.utils.StringUtil;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  final public class ManifestInfoManagerImpl implements ManifestInfoManager, PackageInfoVisitorAcceptor {
      /** The logging instance. */
      public static Logger logger = LoggerFactory.getLogger(ManifestInfoManagerImpl.class);
      /** A Map containing the ManifestInfo instance, by their jar file name. */
      public Map<String, ManifestInfo> manifestInfoMap;
  
  
      public ManifestInfoManagerImpl() {
          super();
          this.manifestInfoMap = new HashMap<String, ManifestInfo>();    
      }
  
      
      public void addJar(String classPath) {
          String[] pathArray = classPath.split(System.getProperty(SystemConstants.PATH_SEPARATOR));
          for (String pathStr : pathArray) {
              if (pathStr.toLowerCase().endsWith(".jar")) {
                  File path = new File(pathStr);
                  addJar(path);
              }
          }
          if (logger.isTraceEnabled()) {
              // FIXME Make use of CollectionUtils.toString(StringbUilder, Object[]) as this class is using StringBuilder.
              StringBuilder builder = new StringBuilder();
              for (String pathStr : pathArray) {
                  builder.append(pathStr).append(StringUtil.LINE_SEPARATOR);
              }
              logger.trace("Added Jar-Manifest from class path entries:" 
                      + StringUtil.LINE_SEPARATOR + builder.toString());
          }
              
      }
      
      public void addJar(File path) {
          if (! path.isFile()) {
              logger.warn("Given jar path is not a file");
              return;
          }
          try {
              JarFile jarFile = new JarFile(path);
              Manifest manifest = jarFile.getManifest();
              ManifestInfo manifestInfo = new ManifestInfoAsPackageInfo(path, manifest);
              addManifestInfo(manifestInfo);
          }
          catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          }
      }
  
      
      public ManifestInfo getManifestInfo(String regularExpression) {
          for (Entry<String, ManifestInfo> entry : this.manifestInfoMap.entrySet()) {
              if (Pattern.matches(regularExpression, entry.getKey())) {
                  return entry.getValue();
              }
          }
          logger.info("No Manifest Information found for file based expression '" + regularExpression + "'.");
          return null;
      }
  
      public String getAttributeValue(String regularExpression , String name) {
          ManifestInfo manifestInfo = getManifestInfo(regularExpression);
          if (manifestInfo == null)
          {
              return null;
          }
          return getAttributeValue(manifestInfo, name);
      }
      
     public String getAttributeValue(ManifestInfo manifestInfo, String name) {
         Attributes attributes = manifestInfo.getManifest().getMainAttributes();
         if (attributes == null) {
             return null;
         }
         return attributes.getValue(name);
     }
 
     public void addManifestInfo(ManifestInfo manifestInfo) {
         this.manifestInfoMap.put(manifestInfo.getJarPath().toString(), manifestInfo);
     }
     
     // TODO Check if is this implementation actually is correct.
     public ManifestInfo getManifestInfo(PackageInfo packageInfo) {
         for (Entry<String, ManifestInfo> entry : manifestInfoMap.entrySet()) {
             entry.getKey();
             ManifestInfo manifestInfo = entry.getValue();
             if (manifestInfo != null 
                     && equals(packageInfo.getSpecificationTitle(), manifestInfo.getSpecificationTitle())
                     && equals(packageInfo.getSpecificationVersion(), manifestInfo.getSpecificationVersion())
                     && equals(packageInfo.getSpecificationVendor(), manifestInfo.getSpecificationVendor())) {
                 return manifestInfo;
             }
         }
         return null;
     }
     
     public boolean equals(String textA, String textB) {
         if (textA == null && textB == null)
         {
             return true;
         }
         return (textA != null) ? textA.equals(textB) : false;
     }
 
     public Set<String> getTitleSet() {
         // TODO: Check if this is really good, or if we should use the title (now jar name)?
         return new TreeSet<String>(manifestInfoMap.keySet());
     }
     
     /**
      * Entry point for a {@link PackageInfoVisitor} which will visit all registered 
      * {@link ManifestInfo} instances as if they are {@link PackageInfo} instances. 
      *
      * @param  visitor  The visitor.
      * @see ManifestInfo#getPackageInfo()
      */
     //@Override
     public void accept(PackageInfoVisitor visitor) {
         for (Iterator<String> iter = new TreeSet<String>(manifestInfoMap.keySet()).iterator(); iter.hasNext();) {
             String title = iter.next();
             ManifestInfo manifestInfo = manifestInfoMap.get(title);
             manifestInfo.getPackageInfo().accept(visitor);
         }
     }
     
     /**
      * Entry point for a {@link ManifestInfoVisitor} which will visit all registered 
      * {@link ManifestInfo} instances. 
      * 
      * @param visitor  The visitor.
      */
     //@Override
     public void accept(ManifestInfoVisitor visitor) {
         for (String jarPathStr : new TreeSet<String>(manifestInfoMap.keySet())) {
             manifestInfoMap.get(jarPathStr).accept(visitor);
         }
     }
     
 }