/*
 *  $Source: /cvsroot2/open/projects/WebARTS/ca/bc/webarts/tools/Zipper.java,v $
 *  Zipper.java - A zip compression tool.
 *
 *  $Revision: 563 $
 *  $Date: 2012-11-03 19:28:37 -0700 (Sat, 03 Nov 2012) $
 *  $Locker:  $
 *
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  Copyright (C) 2001 WebARTS Design, North Vancouver Canada
 *  http://www.webarts.bc.ca
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package ca.bc.webarts.tools;

import ca.bc.webarts.widgets.Util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;

import java.util.Date;
import java.util.Vector;

import java.util.zip.DataFormatException;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipOutputStream;

/**
 *  This class creates a zip file for specified directories or
 *  files. The max size for the zip file can be specified.<P>Usage details:<pre>
 *  Zipper <destination file with .zip extension> <source directory(s)/file(s)>
 *  </pre>
 *
 * @author     Tom Gutwin tgutwin@webarts.bc.ca
 * @created    May 19, 2002
 */
public class Zipper
{

  /**  Output stream for destination zip file. * */
  protected ZipOutputStream zos_ = null;
  protected File zipfile_ = null;
  /** the Out Stream for any info **/
  protected PrintStream printOutStream_ = System.out;
  protected OutputStream infoOutStream_ = System.out;
  protected boolean quiet_ = true;
  protected boolean reallyQuiet_ = false;
  private Vector zipWatchers_ = new Vector();
  private String oldName_ = "";
  int zipfilenameCounter_ = 0;
  int compressionLevel_ = 9;
  long maxZipFileSize_ = 630L * 1000L * 1024L;  //650 MB (630 to be safe for CDRW overhead issues)
  String [] defaultExcludes_ = {"~","SWAPPER.DAT","#","OldHPFS","OldFatDisk","tmp","Trash"};
  Vector excludes_ = new Vector();
  long startTime_ = 0L;


  /**  Constructor for the Zipper object */
  public Zipper()
  {
    for (int i=0;i < defaultExcludes_.length;i++)
      excludes_.add(defaultExcludes_[i]);
  }


  /**
   *  Constructor for the Zipper object
   *
   * @param  src  An array of files to include in the zip.
   * @param  des  Description of the Parameter
   */
  Zipper(File[] src, File des)
  {
    for (int i=0;i < defaultExcludes_.length;i++)
      excludes_.add(defaultExcludes_[i]);
    zipFiles(src, des);
  }


  /**
   *  Constructor for the Zipper object
   *
   * @param  src  Description of the Parameter
   * @param  des  Description of the Parameter
   */
  Zipper(File src, File des)
  {
    File[] srcArray = {src};
    for (int i=0;i < defaultExcludes_.length;i++)
      excludes_.add(defaultExcludes_[i]);
    zipFiles(srcArray, des);
  }


  /**
   *  Main Entry point to run this class as an application usage: <code>
   * Zipper <destination file with .zip extension> <source directorys / files>
   *</code>
   *
   * @param  args  1st arg is the destination file, 2nd arg is the source files
   */
  public static void main(String args[])
  {
    if (args.length >= 2)
    {
      try
      {
        File des = new File(args[0]);
        if (!args[0].toLowerCase().substring(args[0].length() - 4,
            args[0].length()).equalsIgnoreCase(".zip"))
        {
          throw new ArrayIndexOutOfBoundsException();
        }

        File[] src = new File[args.length - 1];
        for (int i = 1; i < args.length; i++)
        {
          src[i - 1] = new File(args[i]);
        }

        new Zipper(src, des);
      }
      catch (ArrayIndexOutOfBoundsException aioobe)
      {
        System.out.println("Usage: java Zipper DestZipfile.zip SourceFile " +
                           "SourceFile2 ...");
        System.out.println(" OR");
        System.out.println("Usage: java Zipper SourceFile");
        System.out.println("      ...zips the SourceFile to SourceFile.zip");
      }
    }
    else if (args.length == 1)
    {
      try
      {
        File src = new File(args[0]);
        File des = new File(System.getProperty("user.dir") +
            File.separator + args[0] + ".zip");
        new Zipper(src, des);
      }
      catch (ArrayIndexOutOfBoundsException aioobe)
      {
        System.out.println("Usage: java Zipper DestZipfile.zip " +
                           "SourceFile SourceFile2 ...");
        System.out.println(" OR");
        System.out.println("Usage: java Zipper SourceFile");
        System.out.println("      ...zips the SourceFile to SourceFile.zip");
      }
    }
    else
    {
      System.out.println("Usage: java Zipper DestZipfile.zip SourceFile " +
                           "SourceFile2 ...");
      System.out.println(" OR");
      System.out.println("Usage: java Zipper SourceFile");
      System.out.println("      ...zips the SourceFile to SourceFile.zip");
    }

  }


  /**
   * Gets the quiet_ field. Which specifies how much user feedback is provided
   **/
  public boolean getQuiet_()
  {
    return quiet_;
  }


  /**
   * Sets the quiet_ field. Which specifies how much user feedback is provided
   **/
  public void setQuiet_(boolean quiet_)
  {
    this.quiet_ = quiet_;
  }


  /**
   * Gets the infoOutStream_ field,Which specifies where to send feedback.
   **/
  public OutputStream getInfoOutStream()
  {
    return infoOutStream_;
  }


  /**
   * Sets the infoOutStream_ field, Which specifies where to send feedback.
   **/
  public void setInfoOutStream(OutputStream ios)
  {
    infoOutStream_ = ios;
    printOutStream_ = new PrintStream(ios);
  }


  /**
   * Adds a String to the excludes Vecotr that gets checked to exclude files.
   **/
  public void addToExcludes(String ex)
  {
    if (ex!= null && !ex.equals(""))
      excludes_.add(ex);
  }


  /**
   *  Sets the maxZipFileSize_ attribute of the Zipper object
   *
   * @param  maxZipFileSize_  The new maxZipFileSize_ value
   */
  public void setMaxZipFileSize_(long maxZipFileSize)
  {
    this.maxZipFileSize_ = maxZipFileSize *1024L *1000L;
  }


  /**
   *  Gets the maxZipFileSize_ attribute of the Zipper object
   *
   * @return    The maxZipFileSize_ value
   */
  public long getMaxZipFileSize_()
  {
    return maxZipFileSize_;
  }


  /**
   *  Sets the compressionLevel_ attribute of the Zipper object
   *
   * @param  compressionLevel_  The new compressionLevel_ value
   */
  public void setCompressionLevel_(int compressionLevel_)
  {
    this.compressionLevel_ = compressionLevel_;
  }


  protected boolean excludedFile(File fileToCheck)
  {
    boolean retVal = false;

    String filename = fileToCheck.getAbsolutePath();
    for (int i=0; i< excludes_.size(); i++)
      if (filename.endsWith((String)excludes_.get(i)))
      {
        retVal = true;
        break;
      }

    return retVal;
  }


   protected boolean excludedFile(String fileToCheck)
  {
    boolean retVal = false;

    for (int i=0; i< excludes_.size(); i++)
      if (fileToCheck.endsWith((String)excludes_.get(i)))
      {
        retVal = true;
        break;
      }

    return retVal;
  }


  /**
   *  Gets the compressionLevel_ attribute of the Zipper object
   *
   * @return    The compressionLevel_ value
   */
  public int getCompressionLevel_()
  {
    return compressionLevel_;
  }


  protected void registerAsZipWatcher(ZipWatcher watcherClass)
  {
    zipWatchers_.add(watcherClass);
  }


  protected void notifyZipWatchers(String filenameJustCompleted, boolean done)
  {
    ZipWatcher currentWatcher = null;
    for (int i=0; i< zipWatchers_.size(); i++)
    {
      currentWatcher = (ZipWatcher)zipWatchers_.get(i);
      currentWatcher.nextZipDone(filenameJustCompleted, done);
    }
  }



  protected ZipOutputStream createZipOutputStream(FileOutputStream fos)
  {
    return new ZipOutputStream(fos);
  }


  /**
   *  Inits the Zip Output stream with the latest increment counter.
   *
   * @param  destZipFile  Description of the Parameter
   * @return              Description of the Return Value
   */
  protected boolean initZipOutputStream(File destZipFile)
  {
    boolean retVal = (destZipFile != null);
    // avoid nullPEx

    if (retVal)
    {
      String newName = destZipFile.getPath().trim();
      oldName_ = newName;
      int endOffset = 6;

      if (zipfilenameCounter_ > 0)
      {
        if (zipfilenameCounter_ == 1)
        {
          endOffset = 4;
        }
        else if (zipfilenameCounter_ > 10)
        {
          endOffset = 7;
        }
        else if (zipfilenameCounter_ > 100)
        {
          endOffset = 8;
        }
        newName = newName.substring(0, newName.length() - endOffset) + "_" +
            zipfilenameCounter_ + ".zip";
        try
        {
          if (zos_ != null)
          {
            zos_.close();
            notifyZipWatchers(zipfile_.getAbsolutePath(), false);
          }
        }
        catch (java.io.IOException ioe)
        {
          printOutStream_.println("Input/Output problem attempting to close the " +
              "zipfile " + destZipFile.getPath().trim() +
              ". \nDetails :\n" + ioe.getMessage());
          retVal = false;
        }
      }

      // Attempt to open the stream
      try
      {
        zipfilenameCounter_++;
        zipfile_ = new File(newName);
        zos_ = createZipOutputStream(new FileOutputStream(zipfile_));
        zos_.setLevel(compressionLevel_);
      }
      catch (java.lang.NullPointerException npe)
      {
        printOutStream_.println("Internal Zipper Error. Details :\n" + npe.getMessage());
        retVal = false;
      }
      catch (java.io.FileNotFoundException fnfe)
      {
        printOutStream_.println("Cannot init File:" + newName + ". \nDetails :\n" +
            fnfe.getMessage());
        retVal = false;
      }
    }

    return retVal;
  }


  /**
   *  Encapsulates the zipping of file(s) into a zip archive.
   *
   * @param  source       The files to include in the zipped file.
   * @param  destination  The resultant zipped archive.
   */
  public void zipFiles(File[] source, File destination)
  {
    boolean initOkay = false;
    try
    {
      startTime_ = (new Date()).getTime();
      printOutStream_.println("\nInitializing the ZipOutput at:  "+
        Util.createCurrentDateTimeStamp());
      initOkay = initZipOutputStream(destination);
      // String srcFileNames[] = {source.getName()};
      //File arrFile[] = {source};
      if (initOkay && source.length > 0)
      {
        for (int i = 0; i < source.length; i++)
        {
          if (!reallyQuiet_ && source[i]!= null)
          {
            printOutStream_.println("Recursing "+source[i].getAbsolutePath());
            //printOutStream_.print(" ..." );
            //printOutStream_.println(
            //    Util.countFilesInDir(source[i].getAbsolutePath(),true)+" files.");
          }
          recursiveZip(source[i]);
        }
        zos_.close();
        notifyZipWatchers(zipfile_.getAbsolutePath(), true);

        long duration = ((new Date()).getTime() - startTime_)/1000L;
        long minutes = duration / 60L;
        long seconds = duration - (60L*minutes);
        if (!reallyQuiet_ && !quiet_)
        {
          printOutStream_.println(destination.getName() +
                             " file created successfully.");
          printOutStream_.print("Time to complete: ");
          printOutStream_.println(""+minutes+":"+seconds);
        }
      }
      else
      {
        if (initOkay)
          printOutStream_.println("There is no file in the specified source.");
        else
          printOutStream_.println("Could NOT Init Zip Output: " + destination);
      }
    }
    catch (java.util.zip.ZipException ze)
    {
      printOutStream_.println("Exception occured in zipping file. Details :\n" + ze.getMessage());
    }
    catch (java.io.FileNotFoundException fnfe)
    {
      printOutStream_.println("File is missing. Details :" + fnfe.getMessage());
    }
    catch (java.io.IOException ioe)
    {
      printOutStream_.println("Input / Output problem. Details :\n" + ioe.getMessage());
    }
  }


  /**
   *  Compresses and saves the passed file parameter into a zip stream. This
   *  is a convienience class that wraps the srcFilename into an array and
   *  calls the
   *  <pre>writeToZipStream(String[] srcFilenameArray, ZipOutputStream zos, boolean recurseSubDirs)</pre>
   *  method.
   *
   * @param  srcFilename                The File to zip up - it can be a dir.
   * @param  zos                        The ZipOutputStream to comptress into.
   * @param  recurseSubDirs             Flags if this method should decend into subdirs.
   * @exception  DataFormatException    Description of the Exception
   * @exception  ZipException           Description of the Exception
   * @exception  FileNotFoundException  Description of the Exception
   * @exception  IOException            Description of the Exception
   */
  public void writeToZipStream(String srcFilename, ZipOutputStream zos, boolean recurseSubDirs)
    throws DataFormatException, ZipException, FileNotFoundException, IOException
  {
    String [] tmpStr = {srcFilename};
    writeToZipStream(tmpStr, zos, recurseSubDirs);
  }


  /**
   *  Compresses and saves the passed files into a zip stream.
   *
   * @param  srcFilename                The Files to zip up - they can be a dir names.
   * @param  zos                        The ZipOutputStream to comptress into.
   * @param  recurseSubDirs             Flags if this method should decend into subdirs.
   * @exception  DataFormatException    Description of the Exception
   * @exception  ZipException           Description of the Exception
   * @exception  FileNotFoundException  Description of the Exception
   * @exception  IOException            Description of the Exception
   */
  public void writeToZipStream(String[] srcFilenameArray, ZipOutputStream zos, boolean recurseSubDirs)
    throws DataFormatException, ZipException, FileNotFoundException, IOException
  {
    boolean debugOutput = true;
    if (zos !=null)
    {
      String srcFilename = "";
      for (int arrayCounter = 0;
          arrayCounter< srcFilenameArray.length;
          arrayCounter++)
      {
        srcFilename = srcFilenameArray[arrayCounter];
        // This function write s the data in to Zipoutput Stream.
        byte fileBytes[] = new byte[2048];
        File fileToGet = new File(srcFilename);
        // clean off the drive letter and '/'
        String entry = srcFilename.toString().trim();
        if (entry.startsWith(":"+File.separator,1))
          entry = srcFilename.toString().substring(3);
        else if (entry.startsWith(File.separator))
          entry = srcFilename.toString().substring(1);

        // Make sure dirs hava a trailing separator char so it is represented
        // in the Zip correctly
        if (fileToGet.isDirectory() && !entry.endsWith(File.separator))
          entry += File.separator;

        entry = Util.tokenReplace(entry,"\\","/");
        ZipEntry ze = null;

        if (!fileToGet.isDirectory())
        {
          int len = 0;
          ze = new ZipEntry(entry);
          zos.putNextEntry(ze);
          FileInputStream fileInStream = new FileInputStream(srcFilename);
          len = fileInStream.read(fileBytes);
          if (debugOutput)
            System.out.println("Zipping on "+srcFilename+File.separator+srcFilename);
          while (len != -1)
          {
            if (debugOutput)
              System.out.print(".");
            zos.write(fileBytes);
            len = fileInStream.read(fileBytes);
          }
          if (debugOutput)
              System.out.println("");
          zos.closeEntry();
        }
        else // it is a dir
        {
          ze = new ZipEntry(entry);
          zos.putNextEntry(ze);
          zos.closeEntry();
          String srcFileNames[] = fileToGet.list();
          File tmpFile = null;
          for (int i=0; i< srcFileNames.length; i++)
          {
            tmpFile = new File(srcFilename+File.separator+srcFileNames[i]);
            if (tmpFile != null && tmpFile.isDirectory() && recurseSubDirs)
            {
              if (debugOutput)
                System.out.println("Recursing on "+srcFilename+File.separator+srcFileNames[i]);
              writeToZipStream(srcFilename+File.separator+srcFileNames[i],
                               zos, recurseSubDirs);
            }
            else if (tmpFile != null && !tmpFile.isDirectory())
            {
              if (debugOutput)
                System.out.println("Recursing on "+srcFilename+File.separator+srcFileNames[i]);
              writeToZipStream(srcFilename+File.separator+srcFileNames[i],
                               zos, recurseSubDirs);
            }
          }
        }
      }
    }
  }


  /**
   *  Compresses and saves the passed file parameter to a zip file.
   *
   * @param  src                        The File to zip up - it can be a dir.
   * @exception  DataFormatException    Description of the Exception
   * @exception  ZipException           Description of the Exception
   * @exception  FileNotFoundException  Description of the Exception
   * @exception  IOException            Description of the Exception
   */
  public void writeToZip(File src)
    throws DataFormatException, ZipException, FileNotFoundException, IOException
  {
    // This function write s the data in to Zipoutput Stream.
    byte b[] = new byte[512];
    // clean off the drive letter and '/'
    String entry = src.toString().trim();
    if (entry.startsWith(":"+File.separator,1))
      entry = src.toString().substring(3);
    else if (entry.startsWith(File.separator))
      entry = src.toString().substring(1);

    // Make sure dirs hava a trailing separator char so it is represented
    // in the Zip correctly
    if (src.isDirectory() && !entry.endsWith(File.separator))
      entry += File.separator;

    entry = Util.tokenReplace(entry,"\\","/");
    ZipEntry ze = new ZipEntry(entry);
    zos_.putNextEntry(ze);
    if (!src.isDirectory())
    {
      int len = 0;
      FileInputStream is = new FileInputStream(src);
      while ((len = is.read(b)) != -1)
      {
        zos_.write(b, 0, len);
      }
      is = null;
    }

    // Provide some user feedback
    if (!reallyQuiet_ && !quiet_)
      if (!src.isDirectory())
        printOutStream_.println(" Adding " + entry);
      else
        printOutStream_.println(" Added directory " + entry);
    zos_.closeEntry();
  }


  /**
   *  Wrapper method to accept a dir or individual file in the passed in File
   *  object AND then calls the method that writes the passed file/dir to this
   *  Zipper instances zip output stream. This is a recursive function. If the
   *  passed File object is a file then it calls the function to write to zip
   *  output stream. If it is a directory it gets the list of file objects in
   *  the child directory and recurses on them.
   *
   * @param  fo  The File object to zip up (can be an actual file or dir).
   */
  public void recursiveZip(File fo)
  {
    try
    {
      if (!fo.isDirectory())
      {
        //printOutStream_.println("Adding "+fo.getName());
        if (zipfile_.length() + fo.length() > maxZipFileSize_)
        {
          printOutStream_.print("Max Zip File Size Reached! ");
          printOutStream_.println("Incrementing ZipFile Name.");
          System.out.print("Max Zip File Size Reached! ");
          System.out.println("Incrementing ZipFile Name.");
          initZipOutputStream(zipfile_);
        }
        try
        {
          if (!excludedFile(fo))
            writeToZip(fo);
          else if(!reallyQuiet_)
            printOutStream_.println("Excluding File:"+fo.getAbsolutePath());
        }
        catch (java.io.FileNotFoundException fnfe)
        {
          if(fnfe.getMessage().endsWith("(Too many open files)"))
          {
            //wait a bit and try again
            ca.bc.webarts.widgets.Util.sleep(2000);
            recursiveZip(fo);
          }
          else  if (!reallyQuiet_)
            printOutStream_.println("File is missing (Zipping will continue):\n" +
                             fnfe.getMessage());
        }
      }
      else
      { // it IS a Directory
        try
        {
          if (excludedFile(fo))
          {
            if(!reallyQuiet_)
            {
              printOutStream_.println("Excluding Directory:"+fo.getAbsolutePath());
            }
          }
          else
          {
            writeToZip(fo);
            if (!reallyQuiet_)
              printOutStream_.println("Recursing " + fo.getPath());
            String srcFileNames[] = fo.list();
            if (srcFileNames != null)
            {
              for (int i = 0; i < srcFileNames.length; i++)
              {
                if (!excludedFile(srcFileNames[i]))
                {
                  recursiveZip(new File(fo.getPath() + File.separator +
                    srcFileNames[i]));
                }
              }
            }
          }
        }
        catch (java.io.FileNotFoundException fnfe)
        {
          if(!reallyQuiet_)
            printOutStream_.println("Directory is missing (Zipping will continue):\n" +
                              fnfe.getMessage());
        }
      }
    }
    catch (java.util.zip.DataFormatException dfe)
    {
      printOutStream_.println("Input data is not in proper format. Details :\n" +
                         dfe.getMessage());
    }
    catch (java.util.zip.ZipException ze)
    {
      printOutStream_.println("Exception occured in zipping file. Details :\n" +
                          ze.getMessage());
    }
    /*catch (java.io.FileNotFoundException fnfe)
    {
      printOutStream_.println("File is missing. Details :\n" + fnfe.getMessage());
    }*/
    catch (java.io.IOException ioe)
    {
      printOutStream_.println("Input / Output problem. \nDetails : " +
                          ioe.getMessage());
      if ("no space left on device".equals(
           ioe.getMessage().trim().toLowerCase()))
      {
        try
        {
          // close up zip and stop
          zos_.closeEntry();
          zos_.close();
          notifyZipWatchers(zipfile_.getAbsolutePath(), true);
          long duration = ((new Date()).getTime() - startTime_)/1000L;
          long minutes = duration / 60L;
          long seconds = duration - (60L*minutes);
          if (!reallyQuiet_ && !quiet_)
          {
            printOutStream_.println(zipfile_.getAbsolutePath() +
                               " file created successfully.");
            printOutStream_.print("Time to complete: ");
            printOutStream_.println(""+minutes+":"+seconds);
          }
        }
        catch (java.io.IOException ioe2)
        {
          printOutStream_.println("Cannot Close zip output file. Details: \n" +
                          ioe2.getMessage());
        }
      }
    }
  }
}