/*
 *  $Source: /cvsroot2/open/projects/WebARTS/ca/bc/webarts/tools/EasyBak.java,v $
 *  EasyBak.java - A simple Backup utility with remote archiving capabiity.
 *
 *  $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 cz.dhl.ftp.Ftp;
import cz.dhl.ftp.FtpConnect;
import cz.dhl.ftp.FtpFile;
import cz.dhl.io.CoFile;
import cz.dhl.io.CoLoad;
import cz.dhl.io.LocalFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.IOException;
//import java.io.SecurityException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.dom4j.util.XMLErrorHandler;

import org.xml.sax.SAXException;


/**
 *  A quick and dirty backup app that zips and sends the zips off to a spec'd
 *  archive location. <br>
 *  <br>
 *  All that is needed is a config file that specifies the files to zip,
 *  resultant zip filename and the archive location and type (ftp, local, none).
 *  <br>
 *  <br>
 *  The config file is in xml format (default filename is 'EasyBak.xml'. You can
 *  spec a different filename as the only param on the commandline<br>
 *  Example configfile:<br>
 *  <pre>
 *  &lt;?xml
 *      version="1.0"
 *      encoding="UTF-8"?>
 *  &lt;?xml-stylesheet
 *      href="http://warp2.webarts.bc.ca/xml/FancyXmlTreeViewer.xsl"
 *      type="text/xsl"?>
 *  &lt;EasyBakPlan>
 *    &lt;Archive
 *        filename="easyBak.zip" />
 *    &lt;ArchiveLocation
 *        type="ftp"
 *        user="yourFtpUsername"
 *        pass="yourpassword"
 *        server="10.0.0.250"
 *        path="/private/bak" />
 *    &lt;BackupFile
 *        filename="/usr/local/export/home/tgutwin/testdir"
 *        recurse="true" />
 *  &lt;/EasyBakPlan> </pre>
 * <br>
 * <b>This application is released under a GNU license.</b><br>
 * Author: <a href="mailto:tgutwin@webarts.bc.ca">Tom Gutwin P.Eng.</a><br>
 * <a href="http://www.webarts.bc.ca">http://www.webarts.bc.ca</a>
 * @author    tgutwin
 */
class EasyBak extends java.lang.Object implements ZipWatcher
{
  /**
   * Constant holding the users file seperator ("/" or "\").
   */
  public final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**
   *  Constant holding the users line seperator.
   */
  public final static String SYSTEM_LINE_SEPERATOR =
      System.getProperty("line.separator");

  /**  The default config filename. */
  public final static String CONFIG_FILENAME =
      "." + SYSTEM_FILE_SEPERATOR + "EasyBak.xml";

  /**  The XML Plan Document. */
  private Document zipPlanDoc_ = null;

  /**  Flags if validating docs when read in.
   **/
  private boolean validatingXsd_ = false;

  /**  The archive servername(ip address), as read from the config file. */
  private String archiveServer_ = "";

  /**
   * The archive type, as read from the config file. Must be one of
   * 'ftp', 'local', or 'none'.
   */
  private String archiveType_ = "";

  /**  The archive ftp server user name, as read from the config file.*/
  private String archiveUser_ = "";

  /**  The archive ftp server password, as read from the config file. */
  private String archivePass_ = "";

  /**
   * The archive path for saving the archive to, as read from the config file.
   * It is used for local or ftp archive types
   */
  private String archivePath_ = "";

  /**  The archive name to zip to, as read from the config file. */
  private String outFileName_ = "";

  /**  The should we add the date to the archivename. */
  private String datedArchive_ = "";

  /**  The should we add the currentworkstation name to the archivename. */
  private String labelArchive_ = "";

  /**  The filenames to include in the archive as read from the config file. */
  private Vector inFilenames_ = new Vector();

  /**  The filenames to EXclude in the archive as read from the config file. */
  private Vector excludes_ = new Vector();

  /**  The log output name. */
  private static String logOutFileName_ = "";

  /**  The MAX size of the archive zip files in Mb. */
  private long maxZipSize_ = 650L ;

  /**
   * Flag specifying if the zip will go directly to the final local archive
   * location. It is used only if type is local.
   **/
  boolean zipDirectToLocalArchive_ = true;

  /** A thread mutex to signal that the zip file delivery is still inprocess. **/
  protected static boolean deliveryInProcess_ = false;


  /**
   * Archive Log file that lives with the final zip file. This ends up being
   * a FileOutputStream
   **/
  static OutputStream infoOutStream_ = null;


  /**
   * Constructor for the EasyBak object that uses the default config filename.
   */
  public EasyBak()
  {
    this(CONFIG_FILENAME);
  }


  /**
   * Constructor for the EasyBak object that uses the default config filename.
   *
   * @param a new filename to use as the config file.
   */
  public EasyBak(String configName)
  {
    if (readZipConfig(configName) &&
        outFileName_ != null &&
        !outFileName_.equals(""))
    {
      logOutFileName_ = "."+SYSTEM_FILE_SEPERATOR+
        outFileName_.substring(0,outFileName_.length()-4)+"_log.txt";
      System.out.println("Log File:" + logOutFileName_);
      try
      {
        infoOutStream_ = new FileOutputStream(logOutFileName_);
        // check if we can get access to the delivery location
        // BEFORE we spend the time to do the zip
        if (checkDeliveryConnection())
        {
          doBak();
          // before we leave we have to wait till all zips are delivered
          waitForDeliveryToFinish();

        }
        else
        {
            infoOutStream_.write(("ERROR EasyBak aborted.\n"+
                               "Cannot validate the archive location.").getBytes());
            infoOutStream_.write(
              ((String)"\nEasyBak Zipping Complete.").getBytes());
            infoOutStream_.close();
        }
      }
      catch (IOException ex)
      {
        System.out.println("Cannot init File:" + logOutFileName_ +
            ". \nDetails :\n" + ex.getMessage());
      }
    }
  }


  /**
   *  The main program for the EasyBak class. It creates an instance of itself
   *  and the instance does all the work. only one commandline param is accepted
   * and is optional... a configfilename to override the default.
   *
   * @param  args  The command line arguments
   */
  public static void main(String[] args)
  {
    EasyBak inst = null;
    if (args.length == 0)
      inst = new EasyBak();
    else if (args.length == 1)
      inst = new EasyBak(args[0]);
    else
      System.out.println("Error: too many commandline args.");
  }


  /**
   *  Abstracts the actual zipping of the files.
   **/
  private void doBak()
  {
    Zipper zipper = new Zipper();
    zipper.registerAsZipWatcher(this);
    zipper.setQuiet_(true);
    for (int i = 0; i < excludes_.size(); i++)
    {
      zipper.addToExcludes((String)excludes_.get(i));
    }
    File[] files = new File[inFilenames_.size()];
    for (int i = 0; i < inFilenames_.size(); i++)
    {
      files[i] = new File((String) inFilenames_.get(i));
    }

    if (outFileName_ != null &&
        !outFileName_.equals(""))
    {
      // first make sure logname is setup
      if (logOutFileName_ == null ||
          (logOutFileName_ != null && logOutFileName_.equals("")) )
      {
        logOutFileName_ =
          outFileName_.substring(0,outFileName_.length()-4)+"_log.txt";
      }

      zipper.setMaxZipFileSize_(maxZipSize_);
      try
      {
        infoOutStream_ = new FileOutputStream(logOutFileName_);
        //zipper.setInfoOutStream(infoOutStream_);
        System.out.println("\nStarting to Zip files to "+outFileName_+"...");
        logInfo("\nStarting to Zip files to "+outFileName_+"...");
        zipper.zipFiles(files, new File(outFileName_));
        logInfo("\nEasyBak Zipping Complete.");
        infoOutStream_.close();
      }
      catch (IOException ex)
      {
        System.out.println("Cannot init File:" + logOutFileName_ +
            ". \nDetails :\n" + ex.getMessage());
      }
    }
   }


  /**
   *  Implementation of ZipWatcher. This method gets called when a zip has been
   *  completed and is ready for pickup and delivery ;)
   *
   * @param  filename   Description of the Parameter
   * @param  completed  Description of the Parameter
   */
  public void nextZipDone(final String filename, boolean completed)
  {
    System.out.println("Ready For Pickup:" + filename);

    // Run in separate thread.
    Thread ftpThread =
      new Thread()
      {
        public void run()
        {
          deliverZipToArchiveLocation(filename);
        }
      };

    ftpThread.start();
    //watchFTPActive(ftpThread);
  }


  /** In a separate thread, watch the ftp thread and change the deliveryInProcess_ flag to false when done. **/
  private void watchFTPActive(final Thread watchThread)
  {
    long timeWatched = 0;
    int sleepTime = 5000;
    final long timeToTerminate = 1800000; // 30 minutes

    // inline Thread to do the watching
    Thread watchdogThread = new Thread (){
      long timeWatched = 0;
      int sleepTime = 500;

      public void run()
      {
        while (timeWatched < timeToTerminate &&
                watchThread.isAlive() &&
                !watchThread.isInterrupted() )
        {
          timeWatched += sleepTime;
          try
          {
            sleep(sleepTime);
          }
          catch (InterruptedException iex)
          {
          }
        }

        if (timeWatched >= timeToTerminate)
        {
          // this throws a security exception If the interrupt is not allowed
          watchThread.interrupt();
        }
      }
    };

    deliveryInProcess_ = true;
    watchdogThread.start();
    deliveryInProcess_ = false;
  }


  /** Blocks the current thread until the FTP Delivery is finished.
      It watches for deliveryInProcess_ to be false. **/
  private void waitForDeliveryToFinish()
  {
    long timeWatched = 0;
    int sleepTime = 5000;

    try
    {
      while (deliveryInProcess_)
        {
          timeWatched += sleepTime;
          Util.sleep(sleepTime);
        }
    }
    catch (SecurityException sEx)
    {
    }
  }


  /**
   *  Checks that the specified archive location is present and accessible.
   *
   * @return  a boolean if the connection is usable or not.
   */
  private boolean checkDeliveryConnection()
  {
    boolean retVal = false;
    String testPath = "";
    if (archiveType_.equals("ftp"))
    {
      logInfo("\nTesting FTP Archive Location.");
      Ftp ftp = new Ftp();
      try
      {
        /*
         *  connect & login to host
         */
        logInfo("\n    Connecting...");
        ftp.connect(archiveServer_, Ftp.PORT);
        ftp.login(archiveUser_, archivePass_);
        if (ftp != null && ftp.isConnected())
        {
          logInfo("\n    Connected!");
          logInfo("\n    Checking Final dir: "+ archivePath_);
          retVal = ftp.cd(archivePath_);
          logInfo("\n     "+(retVal?"success":"faliled"));
          ftp.disconnect();
        }
        ftp=null;
      }
      catch (IOException e)
      {
        System.out.println(e);
      }
    }
    else
    {
      logInfo("\nTesting Local Archive Location.");
      // check for the archive path
      if (archiveType_.equals("local"))
        testPath = archivePath_;
      else
        testPath = System.getProperty("user.dir");

      if (testPath != null && !testPath.equals(""))
      {
        File testLocation = new File(testPath);
        logInfo("\n"+ testPath);
        if ( (testLocation != null) &&
             testLocation.exists() &&
             testLocation.isDirectory())
        {
          // do a test write
          try
          {
            logInfo("\nTest Write."+archivePath_+File.separator+"t27a98Y1.ffs");
            File testFile = new File(archivePath_+File.separator+
                                     "t27a98Y1.ffs");
            testFile.createNewFile();
            retVal = (testFile != null) && testFile.canWrite();
            logInfo("\n..."+(retVal?" suceeded":" failed."));
            if (retVal) testFile.delete();
          }
          catch (IOException ex)
          {
            System.out.println("Cannot Test Log Location File:"+ex.getMessage());
          }
        }
      }
    }
    return retVal;
  }


  /**
   *  Sends a string message to the infoOutStream_.
   *
   * @param  the message to send
   */
  private void logInfo(String logEntry)
  {
    if (infoOutStream_ != null && logEntry!= null)
      try
      {
        infoOutStream_.write(logEntry.getBytes());
      }
      catch (IOException ex)
      {
        System.out.println("Cannot init File:" + logOutFileName_ +
            ". \nDetails :\n" + ex.getMessage());
      }
  }


  /**
   *  Takes a completed zip file and sends/moves it to the specified archive
   *  location for this instance.
   *
   * @param  filename  Zip Filename to send
   */
  private void deliverZipToArchiveLocation(String filename)
  {
    deliveryInProcess_ = true;
    String shortname = filename.substring(filename.lastIndexOf(File.separator) + 1);
    if (archiveType_.equals("ftp"))
    {
      Ftp ftp = new Ftp();
      try
      {
        /*
         *  connect & login to host
         */
        ftp.connect(archiveServer_, Ftp.PORT);
        ftp.login(archiveUser_, archivePass_);

        String uploadPath = archivePath_ + "/" + shortname;

        /*
         *  destination  FtpFile remote file
         */
        logInfo("\n"+shortname +" --> Preparing to deliver to " + archiveServer_ + uploadPath);
        System.out.println(shortname +
              " --> Preparing to deliver to " + archiveServer_ + uploadPath);
        //CoFile to = new FtpFile(uploadPath, ftp);
        CoFile to = new FtpFile(archivePath_, shortname, ftp);

        /*
         *  source LocalFile
         */
        logInfo("\n"+shortname +" --> Preparing to deliver from " + filename);
        System.out.println(shortname +
              " --> Preparing to deliver from " + filename);
        CoFile from = new LocalFile(filename);

        /*
         *  upload
         */
        if (CoLoad.copy(to, from))
        {
          logInfo("\n"+shortname +" --> Delivery Successful to " + archiveServer_ + uploadPath);
          System.out.println(shortname +
              " --> Delivery Successful to " + archiveServer_ + uploadPath);
          // Now delete the local zip file
          ((LocalFile) from).delete();
        }

        /*
         *  upload LOGfile
         */
        try
        {
          uploadPath = archivePath_ + "/" + logOutFileName_;
          to = new FtpFile(uploadPath, ftp);
          from = new LocalFile(logOutFileName_);
          if (CoLoad.copy(to, from))
          {
            logInfo("\n"+shortname +" --> Logfile Delivery Successful to " + archiveServer_ + uploadPath);
            System.out.println(shortname +
                " --> Logfile Delivery Successful to " + archiveServer_ + uploadPath);
            ((LocalFile) from).delete();
          }
        }
        catch (Exception e)
        {
          // Any exception here should not halt the uploads
          System.out.println(e);
          e.printStackTrace();
          logInfo("\nERROR: "+e.getMessage()+"\n"+e.getStackTrace());
        }

        ftp.disconnect();
      }
      catch (IOException e)
      {
        System.out.println(e);
        e.printStackTrace();
        logInfo("\nERROR: "+e.getMessage()+"\n"+e.getStackTrace());
        if (ftp!=null && ftp.isConnected())
          ftp.disconnect();
      }
    }
    else if (archiveType_.equals("local") && !zipDirectToLocalArchive_)
    {
      // move the zip file
      if (Util.moveFile(filename, archivePath_))
      {
        System.out.println(shortname +
            " Delivery Successful to " + archivePath_);
      }
      else
      {
        System.out.println(shortname +
            "\nERROR: Delivery of " + shortname + " to folder "+
            archivePath_+" failed.\n" +
            "Please check permissions and settings.");
      }

      // move the logfile
      if (Util.moveFile(logOutFileName_, archivePath_))
      {
        System.out.println(logOutFileName_ +
            " Delivery Successful to " + archivePath_);
      }
      else
      {
        System.out.println(logOutFileName_ +
            "\nERROR: Delivery of " + logOutFileName_ + " to folder "+
            archivePath_+" failed.\n" +
            "Please check permissions and settings.");
      }
    }
    else if (archiveType_.equals("none"))
    {
      // do nothing
      System.out.println(shortname +
          " is now in current directory.");
    }
    deliveryInProcess_ = false;
  }


  /**
   *  Reads the DEFAULT config XML file and parses the required data.
   *
   * @return    success or failure
   */
  private boolean readZipConfig()
  {
    return readZipConfig(CONFIG_FILENAME);
  }


  /**
   *  Reads the passed in config XML file and parses the required data.
   *
   * @param  configFilename  Description of the Parameter
   * @return                 success or failure
   */
  private boolean readZipConfig(String configFilename)
  {
    boolean retVal = true;

    // validate input params
    if (configFilename == null || configFilename.equals(""))
    {
      configFilename = CONFIG_FILENAME;
    }

    zipPlanDoc_ = readWithSAX(configFilename);

    if (zipPlanDoc_ != null)
    {
      // Get the Zipfile name
      outFileName_ = zipPlanDoc_.selectSingleNode("//EasyBakPlan/Archive").
          valueOf("@filename");
      datedArchive_ = zipPlanDoc_.selectSingleNode("//EasyBakPlan/Archive").
          valueOf("@dated");
      labelArchive_ = zipPlanDoc_.selectSingleNode("//EasyBakPlan/Archive").
          valueOf("@serverLabel");

      String tmpStr = zipPlanDoc_.selectSingleNode("//EasyBakPlan/Archive").
            valueOf("@maxSize");
      if (tmpStr != null && !tmpStr.equals(""))
          maxZipSize_ = Long.parseLong(tmpStr);

      // get the files to zip
      List list = zipPlanDoc_.selectNodes("//EasyBakPlan/BackupFile");
      for (Iterator iter = list.iterator(); iter.hasNext(); )
      {
        Node BackupFileNode = (Node) iter.next();
        inFilenames_.add(BackupFileNode.valueOf("@filename"));
      }
      System.out.println("NumFiles =" + inFilenames_.size());

      // get the files to EXCLUDE
      list = zipPlanDoc_.selectNodes("//EasyBakPlan/ExcludedFile");
      for (Iterator iter = list.iterator(); iter.hasNext(); )
      {
        Node ExcludedFileNode = (Node) iter.next();
        excludes_.add(ExcludedFileNode.valueOf("@endsWith"));
      }
      System.out.println("NumFiles =" + inFilenames_.size());

      // get the archive type and location
      archiveType_ =
          zipPlanDoc_.selectSingleNode("//EasyBakPlan/ArchiveLocation").
          valueOf("@type");
      if (!(archiveType_.toLowerCase().equals("ftp") ||
          archiveType_.toLowerCase().equals("local") ||
          archiveType_.toLowerCase().equals("none")))
      {
        retVal = false;
        System.out.println("ERROR in EasyBak Config File: ArchiveLocation - " +
            "type attribute MUST be one of 'ftp' or 'local' or 'none'.");
        archiveType_ = "none";
      }
      System.out.println("archiveType_ =" + archiveType_);

      if (archiveType_.toLowerCase().equals("ftp"))
      {
        archiveServer_ =
            zipPlanDoc_.selectSingleNode("//EasyBakPlan/ArchiveLocation").
            valueOf("@server");
        System.out.println("ArchiveServer =" + archiveServer_);
        archiveUser_ =
            zipPlanDoc_.selectSingleNode("//EasyBakPlan/ArchiveLocation").
            valueOf("@user");
        System.out.println("archiveUser_ =" + archiveUser_);
        archivePass_ =
            zipPlanDoc_.selectSingleNode("//EasyBakPlan/ArchiveLocation").
            valueOf("@pass");
        System.out.println("archivePass_ = ****");
      }
      archivePath_ =
          zipPlanDoc_.selectSingleNode("//EasyBakPlan/ArchiveLocation").
          valueOf("@path");
      System.out.println("archivePath_ =" + archivePath_);

      // concatenate the FULL archive filename
      if (labelArchive_ != null && !labelArchive_.equals("") &&
          labelArchive_.toLowerCase().equals("true"))
      {
        try
        {
          InetAddress localHostAddr = InetAddress.getLocalHost();
          if (localHostAddr != null)
            outFileName_ += (outFileName_ != null && !outFileName_.equals("") ?
                            "-":"") +
                            localHostAddr.getHostName();
        }
        catch (UnknownHostException ex)
        {
          System.out.println(
            "Cannot obtain LocalHostname - NOT labelling archive file." );
        }
      }
      if (datedArchive_ != null && !datedArchive_.equals("") &&
          datedArchive_.toLowerCase().equals("true"))
        outFileName_ += (outFileName_ != null && !outFileName_.equals("") ?
                         "-":"") + Util.createCurrentDateStamp();

      if (archiveType_.toLowerCase().equals("local")&&zipDirectToLocalArchive_)
      {
        outFileName_ = archivePath_ + File.separator + outFileName_;
      }

      if (!outFileName_.toLowerCase().endsWith(".zip"))
      {
        outFileName_+=".zip";
      }
      System.out.println("Outname =" + outFileName_);

    }
    else
      retVal = false;

    return retVal;
  }


  /**
   *  Reads the input config file with a SAX processor using dom4j.
   *
   * @param  filename  The XML config file to read
   * @return           Description of the Return Value
   */
  private Document readWithSAX(String filename)
  {
    Document retVal = null;

    try
    {
      retVal = (new SAXReader(validatingXsd_)).read(filename);
    }
    catch (DocumentException docEx)
    {
      System.out.println("\nERROR: The XML Config file "+filename+
                         " cannot be read or validated.");
      System.out.println("Please check file: "+ filename);
    }
    catch (Exception ex)
    {
      System.out.println("Something crapped Out:\n" + ex.getMessage());
    }

    return retVal;
  }


}