/*
    * 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.File;
  import java.io.IOException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.io.FileUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import de.smartics.properties.resource.domain.ArtifactId;
  import de.smartics.properties.resource.domain.ArtifactRef;
  import de.smartics.properties.resource.domain.ClassPathEnvironment;
  import de.smartics.properties.resource.heap.HeapException;
  import de.smartics.properties.resource.heap.ResourceHeap;
  import de.smartics.util.lang.Arg;
  
  /**
   * Provides an implementation of {@link ResourceHeap} based on a file system.
   */
  public final class FileSystemResourceHeap implements ResourceHeap
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Logger LOG = LoggerFactory
        .getLogger(FileSystemResourceHeap.class);
  
    // --- members --------------------------------------------------------------
  
    /**
     * The list of root folders to traverse.
     */
    private final List<File> rootFolders = new ArrayList<File>();
  
    /**
     * The artifact identifier to use for properties files encountered.
     */
    private ArtifactId defaultArtifactId = new ArtifactId.Builder()
        .withGroupId("unknown-group").withName("unknown")
        .withVersion("unknown-version").withArchiveType("properties").build();
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    /**
     * Returns the artifact identifier to use for properties files encountered.
     *
     * @return the artifact identifier to use for properties files encountered.
     */
    public ArtifactId getDefaultArtifactId()
    {
      return defaultArtifactId;
    }
  
    /**
     * Sets the artifact identifier to use for properties files encountered.
     *
     * @param defaultArtifactId the artifact identifier to use for properties
     *          files encountered.
     */
    public void setDefaultArtifactId(final ArtifactId defaultArtifactId)
    {
      this.defaultArtifactId = defaultArtifactId;
    }
  
    // --- business -------------------------------------------------------------
 
   /**
    * Adds a root folder to check for property resources.
    *
    * @param rootFolder the folder to add as a root to check for property
    *          resources.
    * @throws NullPointerException if {@code rootFolder} is <code>null</code>.
    * @throws IllegalArgumentException if {@code rootFolder} is not a directory.
    */
   public void addRootFolder(final File rootFolder) throws NullPointerException,
     IllegalArgumentException
   {
     Arg.checkNotNull("rootFolder", rootFolder);
 
     if (!rootFolder.isDirectory())
     {
       throw new IllegalArgumentException(String.format("'%s' is not a folder.",
           rootFolder.getAbsolutePath()));
     }
 
     rootFolders.add(rootFolder);
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public ClassPathEnvironment resolve() throws HeapException
   {
     final ClassPathEnvironment env = new ClassPathEnvironment();
     final String[] extensions =
         new String[] { "jar", "ear", "war", "sar", "properties" };
 
     for (final File rootFolder : rootFolders)
     {
       boolean containsPropertiesFile = false;
       for (final Iterator<File> files =
           FileUtils.iterateFiles(rootFolder, extensions, true); files.hasNext();)
       {
         final File file = files.next();
 
         if (!isPropertiesFile(file))
         {
           final ArtifactRef archiveArtifactRef = createArchiveArtifactRef(file);
           if (archiveArtifactRef != null)
           {
             env.addArchiveArtifactRef(archiveArtifactRef);
           }
         }
         else if (!containsPropertiesFile)
         {
           containsPropertiesFile = true;
           final ArtifactRef rootRef = createFolderRef(rootFolder);
           env.addAnyArtifactRef(rootRef);
         }
       }
     }
 
     return env;
   }
 
   private ArtifactRef createFolderRef(final File file)
   {
     try
     {
       return new ArtifactRef(defaultArtifactId, file.toURI().toURL());
     }
     catch (final MalformedURLException e)
     {
       LOG.debug("Cannot transform file '{}' to an URL: "
                 + e.getLocalizedMessage());
       return null;
     }
   }
 
   private boolean isPropertiesFile(final File file)
   {
     final String name = file.getName();
     final boolean isPropertiesFile = name.endsWith(".properties");
     return isPropertiesFile;
   }
 
   private static ArtifactRef createArchiveArtifactRef(final File archiveFile)
     throws HeapException
   {
     try
     {
       final ArtifactId id = readArtifactId(archiveFile);
       final URL url = archiveFile.toURI().toURL();
       if (id != null)
       {
         final ArtifactRef ref = new ArtifactRef(id, url);
         return ref;
       }
     }
     catch (final MalformedURLException e)
     {
       LOG.debug("Cannot transform file '{}' to an URL: "
                 + e.getLocalizedMessage());
     }
     catch (final IOException e)
     {
       throw new HeapException(new FileMessageBean(
           FileSystemResourceCode.FAILED_TO_READ_ARCHIVE_FILE, e, archiveFile));
     }
     return null;
   }
 
   private static ArtifactId readArtifactId(final File archiveFile)
     throws NullPointerException, IOException
   {
     final ArtifactIdGrabber grabber = ArtifactIdGrabber.createLazy(archiveFile);
     if (grabber.isDefinitionArchive())
     {
       final ArtifactId id = grabber.getArtifactId();
       return id;
     }
     return null;
   }
 
   // --- object basics --------------------------------------------------------
 
 }