package com.atlassian.core.util.zip;
   
   import org.apache.commons.io.IOUtils;
   
   import javax.annotation.Nonnull;
   import javax.annotation.Nullable;
   import javax.annotation.concurrent.NotThreadSafe;
   import java.io.File;
   import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipOutputStream;
  
  /**
   * An utility class which allows to add multiple directories/files/entries from stream to zip archive.
   *
   * @since v6.4
   */
  @NotThreadSafe
  public class ZipArchiver
  {
  
      @Nonnull
      private final File archiveFile;
      @Nullable
      private FileArchiver fileArchiver;
      @Nullable
      private ZipOutputStream zipOutputStream;
  
      public ZipArchiver(final File archiveFile)
      {
          this.archiveFile = archiveFile;
      }
  
      /**
       * Adds directory and all subdirectories into archive.
       *
       * @param folderToCompress  the directory handle to add to archive
       * @param archiveFolderName the name which will be used as archive directory name, for example when {@code
       *                          folderToCompress} is pointing into /home/A/B directory which contains file with path
       *                          /home/A/B/C/file and {@code archiveFolderName} equals "archive" a result zip archive
       *                          will contain entry: /archive/C/file
       *
       * @throws IOException
       */
      public void addFolder(final File folderToCompress, final String archiveFolderName) throws IOException
      {
          final FolderAppender folderAppender = new FolderAppender(getFileArchiver(), folderToCompress, archiveFolderName, archiveFile);
          folderAppender.append();
      }
  
      /**
       * Adds directory and all subdirectories into archive.
       *
       * @param folderToCompress  the directory handle to add to archive
       * @param archiveParams parameters for the files in the folder to be added the to archive
       *
       * @throws IOException
       */
      public void addFolder(final File folderToCompress, final ArchiveParams archiveParams) throws IOException
      {
          final FolderAppender folderAppender = new FolderAppender(getFileArchiver(), folderToCompress, archiveParams, archiveFile);
          folderAppender.append();
      }
  
      /**
       * Adds a file to archive.
       * @param sourceFile a file which content will be added as new entry
       * @param targetPath a file path which will be used as entry name
       * @throws IOException
       */
      public void addFile(final File sourceFile, final String targetPath) throws IOException
      {
          getFileArchiver().addToArchive(sourceFile, targetPath, "");
      }
  
      /**
       * Adds new entry to zip archive with name specified by {@code entryPath} parameter and with content from provided
       * {@link java.io.InputStream}
       * @param content stream which will be used as entry content
       * @param entryPath will be used as entry name
       * @throws IOException
       */
      public void addEntry(final InputStream content, final String entryPath) throws IOException
      {
          final ZipEntry entry = new ZipEntry(FilePathUtils.stripSlashes(entryPath));
          getZipOutputStream().putNextEntry(entry);
          try
          {
              IOUtils.copyLarge(content, zipOutputStream);
          }
          finally
          {
              getZipOutputStream().closeEntry();
              IOUtils.closeQuietly(content);
          }
     }
 
     /**
      * Creates new zipEntry and provides OutputStream to write content to given entry. Keep in mind that provided
      * outPutStream is valid as long as no other methods creating new entry are called.
      * @param entryName the name of zip entry
      * @return OutputStream to write content to given entry
      * @throws IOException
      */
     public OutputStream addNextEntry(final String entryName) throws IOException
     {
         getZipOutputStream().putNextEntry(new ZipEntry(entryName));
         return getZipOutputStream();
     }
 
     public void close() throws IOException
     {
         if (zipOutputStream != null)
         {
             zipOutputStream.closeEntry();
             zipOutputStream.close();
         }
     }
 
     private FileArchiver getFileArchiver() throws FileNotFoundException
     {
         if (fileArchiver == null)
         {
             final ZipOutputStream zipOutputStream = getZipOutputStream();
             fileArchiver = new FileArchiver(zipOutputStream);
         }
         return fileArchiver;
     }
 
     private ZipOutputStream getZipOutputStream() throws FileNotFoundException
     {
         if(zipOutputStream == null)
         {
             zipOutputStream = new ZipOutputStream(new FileOutputStream(archiveFile));
         }
         return zipOutputStream;
     }
 
 }