/*
    * Copyright 2012-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.api.config.domain.key;
  
  import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  import java.util.jar.Attributes;
  import java.util.jar.JarFile;
  import java.util.jar.Manifest;
  
  import javax.annotation.concurrent.ThreadSafe;
  
  import org.apache.commons.io.IOUtils;
  
  /**
   * Loads the application identifier from the Manifest file.
   */
  @ThreadSafe
  public final class ApplicationIdLoader
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The flag to signal that the manifest of a EAR file (with the extension
     * <code>ear</code>) is preferred if present.
     *
     * @serial
     */
    private final boolean preferEarManifest;
  
    /**
     * Cache with the root URL as a key and the application ID as value. The cache
     * is set to <code>null</code>, if no caching is used.
     *
     * @serial
     */
    private final Map<String, ApplicationId> cache;
  
    /**
     * The lock for synchronized access.
     *
     * @serial
     */
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  
    /**
     * The read lock for synchronized access.
     *
     * @serial
     */
    private final Lock readLock = lock.readLock();
  
    /**
     * The write lock for synchronized access.
     *
     * @serial
     */
    private final Lock writeLock = lock.writeLock();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Convenience constructor preferring manifest information from EARs and no
     * caching.
     */
    public ApplicationIdLoader()
    {
      this(true);
    }
  
    /**
    * Convenience constructor preferring no caching.
    *
    * @param preferEarManifest the flag to signal that the manifest of a EAR file
    *          (with the extension (with the extension <code>ear</code>) is
    *          preferred if present.
    */
   public ApplicationIdLoader(final boolean preferEarManifest)
   {
     this(preferEarManifest, false);
   }
 
   /**
    * Default constructor.
    *
    * @param preferEarManifest the flag to signal that the manifest of a EAR file
    *          (with the extension (with the extension <code>ear</code>) is
    *          preferred if present.
    * @param useCache set to <code>true</code> if all loaded application IDs
    *          should be cached, <code>false</code> otherwise.
    */
   public ApplicationIdLoader(final boolean preferEarManifest,
       final boolean useCache)
   {
     this.preferEarManifest = preferEarManifest;
     this.cache = (useCache ? new HashMap<String, ApplicationId>() : null);
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- factory --------------------------------------------------------------
 
   /**
    * Returns a caching loader that reads the Manifest file from the JAR that
    * actually contains the resource.
    *
    * @return the loader instance.
    * @see #ApplicationIdLoader(boolean, boolean)
    */
   public static ApplicationIdLoader createCachedJarLoader()
   {
     return new ApplicationIdLoader(false, true);
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Loads the application identifier from the manifest file pointed at by the
    * {@link Thread#getContextClassLoader() context class loader}.
    *
    * @return the application identifier.
    * @throws IllegalStateException if the application identifier cannot be read
    *           from the manifest.
    */
   public ApplicationId load() throws IllegalStateException
   {
     return load(Thread.currentThread().getContextClassLoader());
   }
 
   /**
    * Loads the application identifier from the manifest file pointed at from the
    * given class.
    *
    * @param locator the class to locate the manifest file to load. It is the
    *          manifest file of the archive this class is part of.
    * @return the application identifier.
    * @throws IllegalStateException if the application identifier cannot be read
    *           from the manifest.
    */
   public ApplicationId load(final Class<?> locator)
     throws IllegalStateException
   {
     final URL selectorUrl = locator.getResource("");
     final URL rootUrl = selectUrl(locator, selectorUrl);
     final ApplicationId applicationId = load(rootUrl);
     return applicationId;
   }
 
   /**
    * Loads the manifest information as application ID from the given root URL.
    *
    * @param rootUrl the URL to a class path root. The
    *          {@link JarFile#MANIFEST_NAME} will be appended to locate the
    *          manifest file.
    * @return the application ID as read from the manifest file found in the
    *         {@code rootUrl}.
    */
   public ApplicationId load(final URL rootUrl)
   {
     try
     {
       final URL manifestFileUrl = constructUrl(rootUrl);
       final ApplicationId applicationId = getApplicatioIdFrom(manifestFileUrl);
       return applicationId;
     }
     catch (final MalformedURLException e)
     {
       throw new IllegalStateException(
           "Cannot read Manifest file from base URL: "
               + rootUrl.toExternalForm(), e);
     }
   }
 
   private URL constructUrl(final URL rootUrl) throws MalformedURLException
   {
     final String urlString = rootUrl.toExternalForm();
     final int index = urlString.indexOf("/WEB-INF/classes");
     if (index != -1)
     {
       final String baseUrl = urlString.substring(0, index);
       return new URL(baseUrl + '/' + JarFile.MANIFEST_NAME);
     }
     return new URL(rootUrl, JarFile.MANIFEST_NAME);
   }
 
   private URL selectUrl(final Class<?> locator, final URL selectorUrl)
   {
     try
     {
       final String selectorUrlString = selectorUrl.toExternalForm();
       for (final Enumeration<URL> en =
           locator.getClassLoader().getResources(""); en.hasMoreElements();)
       {
         final URL rootUrl = en.nextElement();
         if (selectorUrlString.startsWith(rootUrl.toExternalForm()))
         {
           return calcActualRootUrl(rootUrl);
         }
       }
     }
     catch (final IOException e)
     {
       throw new IllegalStateException(
           "Cannot determine Manifest file location using selector URL: "
               + selectorUrl.toExternalForm(), e);
     }
 
     return locator.getClassLoader().getResource("");
   }
 
   private URL calcActualRootUrl(final URL rootUrl)
   {
     URL actualUrl = rootUrl;
     if (preferEarManifest)
     {
       final String string = rootUrl.toExternalForm();
       final int index = string.lastIndexOf(".ear/");
       if (index != -1)
       {
         try
         {
           actualUrl = new URL(string.substring(0, index + 5));
         }
         catch (final MalformedURLException e)
         {
           // Ignore
         }
       }
     }
     return actualUrl;
   }
 
   /**
    * Loads the application identifier from the manifest file pointed at from the
    * given class loader.
    *
    * @param classLoader the class loader to load the manifest file.
    * @return the application identifier.
    * @throws IllegalStateException if the application identifier cannot be read
    *           from the manifest.
    */
   public ApplicationId load(final ClassLoader classLoader)
     throws IllegalStateException
   {
     final URL url = classLoader.getResource(JarFile.MANIFEST_NAME);
     return getApplicatioIdFrom(url);
   }
 
   private ApplicationId getApplicatioIdFrom(final URL url)
   {
     if (cache != null)
     {
       readLock.lock();
       try
       {
         final ApplicationId applicationId = cache.get(url.toExternalForm());
         return applicationId;
       }
       finally
       {
         readLock.unlock();
       }
     }
 
     final ApplicationId applicationId = readManifestFile(url);
 
     if (cache != null)
     {
       // It is ok to read the application ID more than once.
       writeLock.lock();
       try
       {
         cache.put(url.toExternalForm(), applicationId);
       }
       finally
       {
         writeLock.unlock();
       }
     }
 
     return applicationId;
   }
 
   private ApplicationId readManifestFile(final URL url)
     throws IllegalArgumentException, IllegalStateException
   {
     InputStream inputStream = null;
     try
     {
       inputStream = url.openStream();
       if (inputStream != null)
       {
         inputStream = new BufferedInputStream(inputStream);
         final Manifest manifest = new Manifest(inputStream);
 
         final ApplicationId applicationId = createApplicationId(manifest);
 
         return applicationId;
       }
 
       throw new IllegalStateException(
           "Cannot find Manifest file to determine application ID: "
               + url.toExternalForm());
     }
     catch (final IOException e)
     {
       throw new IllegalStateException("Cannot read Manifest file: "
                                       + url.toExternalForm(), e);
     }
     finally
     {
       IOUtils.closeQuietly(inputStream);
     }
   }
 
   private ApplicationId createApplicationId(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 ApplicationId applicationId =
         new ApplicationId(groupId, artifactId, version);
     return applicationId;
   }
 
   // --- object basics --------------------------------------------------------
 
   /**
    * Returns the string representation of the object.
    *
    * @return the string representation of the object.
    */
   @Override
   public String toString()
   {
     final StringBuilder buffer = new StringBuilder();
     readLock.lock();
     try
     {
       for (final Entry<String, ApplicationId> entry : cache.entrySet())
       {
         buffer.append(entry.getKey()).append(": ").append(entry.getValue())
             .append('\n');
       }
     }
     finally
     {
       readLock.unlock();
     }
     return buffer.toString();
   }
 }