package org.apache.maven.util;
   
   /* ====================================================================
    *   Licensed to the Apache Software Foundation (ASF) under one or more
    *   contributor license agreements.  See the NOTICE file distributed with
    *   this work for additional information regarding copyright ownership.
    *   The ASF licenses this file to You 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.
   * ====================================================================
   */
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.Date;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.tools.ant.util.FileUtils;
  
  /**
   * Unzip a file.
   *
   * @author costin@dnt.ro
   * @author <a href="mailto:stefan.bodewig@epost.de">Stefan Bodewig</a>
   * @author <a href="mailto:umagesh@apache.org">Magesh Umasankar</a>
   * @since Ant 1.1
   * @ant.task category="packaging" name="unzip" name="unjar" name="unwar"
   */
  public class Expand
  {
      /** Logger. */
      private static final Log LOGGER = LogFactory.getLog( Expand.class );
  
      /** Destination. */
      private File dest;
  
      /** Source. */
      private File source; // req
  
      /** Should overwrite flag. */
      private boolean overwrite = true;
  
      /** file utility class */
      private FileUtils fileUtils;
  
      /**
       * Do the work.
       *
       * @throws IOException If an error occurs.
       */
      public void execute()
          throws IOException
      {
          expandFile();
      }
  
      /**
       * Expand a file.
       */
      protected void expandFile()
          throws IOException
      {
          ZipInputStream zis = null;
          FileInputStream fis = null;
          try
          {
              // code from WarExpand
              fis = new FileInputStream( source );
              zis = new ZipInputStream( fis );
              ZipEntry ze = null;
              setFileUtils( FileUtils.newFileUtils() );
  
              while ( ( ze = zis.getNextEntry() ) != null )
              {
                  extractFile( zis, ze.getName(), new Date( ze.getTime() ), ze.isDirectory() );
              }
  
              LOGGER.debug( "expand complete" );
          }
          finally
          {
              if ( fis != null )
              {
                  try
                  {
                     fis.close();
                 }
                 catch ( IOException e )
                 {
                     LOGGER.debug( "WARNING: Cannot close stream!", e );
                 }
             }
             if ( zis != null )
             {
                 try
                 {
                     zis.close();
                 }
                 catch ( IOException e )
                 {
                     LOGGER.debug( "WARNING: Cannot close stream!", e );
                 }
             }
         }
     }
 
     /** Extract a file.
      *
      *  @param compressedInputStream The input stream.
      *  @param entryName The entry name.
      *  @param entryDate The entry date.
      *  @param isDirectory Flag indicating if is directory.
      *
      *  @throws IOException If an error occurs while attempting to
      *          extract the file.
      */
     protected void extractFile( InputStream compressedInputStream, String entryName, Date entryDate, boolean isDirectory )
         throws IOException
     {
         File f = fileUtils.resolveFile( dest, entryName );
 
         if ( !overwrite && f.exists() && ( f.lastModified() >= entryDate.getTime() ) )
         {
             LOGGER.debug( "Skipping " + f + " as it is up-to-date" );
             return;
         }
         // create intermediary directories - sometimes zip don't add them
         File dirF = f.getParentFile();
         //File dirF = fileUtils.getParentFile(f);
         dirF.mkdirs();
 
         if ( isDirectory )
         {
             f.mkdirs();
         }
         else
         {
             byte[] buffer = new byte[1024];
             int length = 0;
             FileOutputStream fos = null;
             try
             {
                 fos = new FileOutputStream( f );
 
                 while ( ( length = compressedInputStream.read( buffer ) ) >= 0 )
                 {
                     fos.write( buffer, 0, length );
                 }
 
                 fos.close();
                 fos = null;
             }
             finally
             {
                 if ( fos != null )
                 {
                     try
                     {
                         fos.close();
                     }
                     catch ( IOException e )
                     {
                         LOGGER.debug( "WARNING: Cannot close stream!", e );
                     }
                 }
             }
         }
 
         fileUtils.setFileLastModified( f, entryDate.getTime() );
     }
 
     /**
      * Set the destination directory. File will be unzipped into the destination
      * directory.
      *
      * @param d Path to the directory.
      */
     public void setDest( File d )
     {
         dest = d;
     }
 
     /**
      * Set the path to zip-file.
      *
      * @param s Path to zip-file.
      */
     public void setSrc( File s )
     {
         source = s;
     }
 
     /**
      * Should we overwrite files in dest, even if they are newer than the
      * corresponding entries in the archive?
      *
      *  @param shouldOverwrite <code>true</code> to indicate that files
      *         should be overwritten, otherwise <code>false</code>.
      */
     public void setOverwrite( boolean shouldOverwrite )
     {
         overwrite = shouldOverwrite;
     }
 
     /**
      * @param utils
      */
     public void setFileUtils( FileUtils utils )
     {
         fileUtils = utils;
     }
 
 }