/*
    * Copyright 2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.properties.resource.filesystem.heap;
  
  import java.io.BufferedInputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.jar.Attributes;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang.StringUtils;
  
  import de.smartics.properties.resource.domain.ArtifactId;
  import de.smartics.util.lang.Arg;
  
  /**
   * Loads the artifact identifier from the Manifest file.
   */
  @ThreadSafe
  final class ArtifactIdGrabber
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The flag determines whether the archive contains properties definition
     * files (<code>true</code>) or not (<code>false</code>).
     */
    private final boolean definitionArchive;
  
    /**
     * The artifact ID as determined from the Manifest file.
     */
    private final ArtifactId artifactId;
  
    /**
     * The archive type as determined by the file name extension.
     */
    private final String archiveType;
  
    /**
     * The classifier determined by some crude heuristics.
     */
    private final String classifier;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    private ArtifactIdGrabber(final File archiveFile, final boolean lazy)
      throws NullPointerException, IOException
    {
      Arg.checkNotNull("archiveFile", archiveFile);
  
      final JarFile jarFile = new JarFile(archiveFile);
  
      this.definitionArchive = isDefinitionArchive(jarFile);
      if (lazy && !definitionArchive)
      {
        this.archiveType = null;
        this.classifier = null;
        this.artifactId = null;
        return;
      }
      final String name = archiveFile.getName();
      this.archiveType = determineType(name);
      this.classifier = determineClassifier(name);
      this.artifactId = load(jarFile);
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
   private static boolean isDefinitionArchive(final JarFile jarFile)
   {
     final String definitionXmlName =
         "META-INF/smartics-properties/definition.xml";
     final JarEntry entry = jarFile.getJarEntry(definitionXmlName);
     final boolean hasDefinition = entry != null;
     return hasDefinition;
   }
 
   private static String determineType(final String name)
   {
     final String extension = FilenameUtils.getExtension(name);
     final String type = StringUtils.isNotBlank(extension) ? extension : "jar";
     return type;
   }
 
   private static String determineClassifier(final String name)
   {
     final String baseName = FilenameUtils.getBaseName(name);
     final int pos = baseName.lastIndexOf('-');
     if (pos == -1)
     {
       return null;
     }
 
     final String classifier = baseName.substring(pos);
     if ("-SNAPSHOT".equals(classifier)
         || StringUtils.containsAny(classifier, "0123456789"))
     {
       return null;
     }
 
     return classifier;
   }
 
   private ArtifactId load(final JarFile jarFile)
   {
     final JarEntry entry = jarFile.getJarEntry(JarFile.MANIFEST_NAME);
     if (entry == null)
     {
       throw new IllegalStateException(String.format(
           "No Manifest file found in: %s", jarFile.getName()));
     }
 
     final ArtifactId id = readManifestFile(jarFile, entry);
     return id;
   }
 
   private ArtifactId readManifestFile(final JarFile jarFile,
       final JarEntry entry) throws IllegalArgumentException,
     IllegalStateException
   {
     InputStream inputStream = null;
     try
     {
       inputStream = jarFile.getInputStream(entry);
       if (inputStream != null)
       {
         inputStream = new BufferedInputStream(inputStream);
         final Manifest manifest = new Manifest(inputStream);
 
         final ArtifactId artifactId = createArtifactId(manifest);
 
         return artifactId;
       }
 
       throw new IllegalStateException(
           "Cannot find Manifest file to determine artifact ID: "
               + entry.getName());
     }
     catch (final IOException e)
     {
       throw new IllegalStateException(String.format(
           "Cannot read Manifest file: %s", jarFile.getName()), e);
     }
     finally
     {
       IOUtils.closeQuietly(inputStream);
     }
   }
 
   private ArtifactId createArtifactId(final Manifest manifest)
     throws IllegalArgumentException
   {
     final Attributes attributes = manifest.getMainAttributes();
     final String groupId =
         attributes.getValue(Attributes.Name.IMPLEMENTATION_VENDOR_ID);
     final String artifactId =
         attributes.getValue(Attributes.Name.IMPLEMENTATION_TITLE);
     final String version =
         attributes.getValue(Attributes.Name.IMPLEMENTATION_VERSION);
 
     final ArtifactId id =
         ArtifactId
             .create(groupId, artifactId, version, archiveType, classifier);
     return id;
   }
 
   // --- factory --------------------------------------------------------------
 
   /**
    * Creates a grabber instance.
    *
    * @param archiveFile the archive file to grab information from.
    * @throws NullPointerException if {@code archiveFile} is <code>null</code>.
    * @throws IOException if the file cannot be opened.
    */
   static ArtifactIdGrabber create(final File archiveFile)
     throws NullPointerException, IOException
   {
     return new ArtifactIdGrabber(archiveFile, false);
   }
 
   /**
    * Creates a lazy grabber instance that quits grabbing if the archive does not
    * provide properties definition information. That is the grabber instance
    * returns null for each value of {@link #isDefinitionArchive()} returns
    * <code>false</code>.
    *
    * @param archiveFile the archive file to grab information from.
    * @throws NullPointerException if {@code archiveFile} is <code>null</code>.
    * @throws IOException if the file cannot be opened.
    */
   static ArtifactIdGrabber createLazy(final File archiveFile)
     throws NullPointerException, IOException
   {
     return new ArtifactIdGrabber(archiveFile, true);
   }
 
   // --- get&set --------------------------------------------------------------
 
   /**
    * Returns the flag determines whether the archive contains properties
    * definition files (<code>true</code>) or not (<code>false</code>).
    *
    * @return the flag determines whether the archive contains properties
    *         definition files (<code>true</code>) or not (<code>false</code>).
    */
   public boolean isDefinitionArchive()
   {
     return definitionArchive;
   }
 
   /**
    * Returns the artifact ID as determined from the Manifest file.
    *
    * @return the artifact ID as determined from the Manifest file.
    */
   public ArtifactId getArtifactId()
   {
     return artifactId;
   }
 
   // --- business -------------------------------------------------------------
 
   // --- object basics --------------------------------------------------------
 
 }