/*
 *  AliveURL.java
 *  $Source: /cvsroot2/open/projects/WebARTS/ca/bc/webarts/tools/AliveURL.java,v $
 *  $Revision: 563 $  $Date: 2012-11-03 19:28:37 -0700 (Sat, 03 Nov 2012) $  $Locker:  $
 *  Copyright 2002 (C) WebARTS Design.   All rights reserved.
 *
 *  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 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package ca.bc.webarts.tools;

import java.awt.Toolkit;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Authenticator;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.PasswordAuthentication;
import java.net.URL;
import java.net.URLConnection;
import java.util.Date;
import java.util.Properties;
import java.util.Vector;

import javax.mail.Address;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.SendFailedException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;

// not necessary but saves headaches later if classes move
import ca.bc.webarts.tools.StreamGobbler;

//import com.jpeterson.x10.SendX10;


/**
 *  A simple commandline based app that periodically contacts some specified
 *  URLs and confirms connectivity. It alarms if it cannot connect a specified
 *  number of consequetive times. It also has
 *  built in capability of calling/running an external script and or sending off
 *  an email.<br><br>For Example... I use this as a watchdog for one of my
 *  webservers.  The server is on a remote control power supply which allows me
 *  to reboot the server if, for some reason, it has hung and fails this AliveURL
 *  watchdog check 4 times in a row. It then sends off an email to my cell phone
 *  to let me kknow there has been a problem.
 *
 * <pre>
        Usage:
          java -DproxySet=true -DproxyHost=YourProxyServerHostname
               -DproxyPort=YourProxyServerPort
               -DproxyUser=YourProxyUsernameIFNEEDED
               -DproxyPassword=YourProxyUserPasswordIFNEEDED
               -DnonProxyHosts=CommaSeperatedlistOfNonProxiedSites
               ca.bc.webarts.tools.AliveURL [URL location 1] [URL location 2]...
 </pre>
 *
 * @author     Tom Gutwin P.Eng
 */
class AliveURL extends Authenticator
{
  public Date currDate = new Date();
  static int checkDelay = 300000; // 5 minutes
  private static URL errorMusic = null;
  private static File errorMusicFile = null;
  private static String errorMusicUrlStr =
      "http://www-bcg.bcg.ada.com/~gutwint/Carbrake.wav";
  private static String errorMusicFileStr =
      "/usr/lib/openoffice.org2.0/share/gallery/sounds/cow.wav";
  private static boolean useURL = false;
  Playback playback = null;
  Toolkit tk = Toolkit.getDefaultToolkit();

  public static final String DEFAULT_PROXY_SET = "false";
  public static final String DEFAULT_PROXY_HOST = "bchrelay4";
  public static final String DEFAULT_PROXY_PORT = "80";
  public static final String DEFAULT_PROXY_NOPROXY = "";
  /**
   *  Constant Specifying that the logging output will go to System.out.
   */
  public final static short CONSOLE = 50;
  /**
   *  Constant Specifying that the logging output will go to a spec'd file.
   */
  public final static short FILE = 51;
  /**
   *  Constant Specifying that the logging output will go to a
   *  spec'd OutputStream.
   */
  public final static short PIPE = 52;

  /**
   *  The Standard OutputStream.
   */
  private final static PrintStream STD_OUT = System.out;

  /**
   *  Description of the Field
   */
  static private String    logFileName_ = "AliveUrlLog.txt";
  /**
   *  Description of the Field
   */
  static private OutputStream userOut_ = STD_OUT;
  /**
   *  The stream that ALL logging ends upo getting directed to.
   */
  static private PrintStream logOut_ = null;
  /**
   *  Description of the Field
   */
  static private File      logFile_ = null;
  /**
   *  Description of the Field
   */
  static private short     outSpot_ = FILE;
  /**
   * A constant that tells us how many sequential errors to accept before
   * calling the external Script.
   **/
  static private final short     ACCEPTABLE_NUMBER_ERRORS = 3;
  /**
   * An extra Delay after a script execution to wait before checking again.
   **/
  static private final int     EXTRA_DELAY_TIME = 600000; //10min
  /**
   * A class varthat tells us how many sequential errors have occured.
   **/
  static private short numSequentialErrors_ = 0;
  /**
   * This is the supervisor flag that toggles running the external script
   * execution.
   **/
  static private boolean enableExecScript_ = false;
  static private boolean enableJavaX10_ = true;
  static private boolean externalScriptWasExecuted_ = false;
  static private boolean areWePlayingMusic = true;
  static private boolean areWeSendingEmail_ = true;
  static private boolean areWeUsingProxy_ = false;
  static private boolean useProxyAuthentication_ = true;
  /**
   * A class var to record and error message to print out if any of the
   * validation checks on the properties fail.
   **/
  private static String errorMsg_ = "";

  /** The email addr to send notifications to if a recycle happens **/
  private static String emailTo_ = "tgutwin@webarts.bc.ca";

  /** the class Proxy Username to authenticate with. **/
  static private String proxyUsername_ = "YourProxyUserName";

  /** the class Proxy Password to authenticate with. **/
  static private String proxyPassword_ = "GetYourOwnPassword";

  /** the Proxy hostname. **/
  static private String proxyHost_ = DEFAULT_PROXY_HOST;

  /** the Proxy port. **/
  static private String proxyPort_ = DEFAULT_PROXY_PORT;

  /** The X10 Commands to send to the X10 engine **/

  private static String [] x10Cmd1_ = {"off","a","2"};
  private static String [] x10Cmd2_ = {"on","a","2"};



  /**
   *
   *  A simple/useless constructor for the sole purpose of providing the
   *  Authenticator impl to the net authentication mechanism.  Both the passed
   *  params can be null or "" - if they are the default class username and
   *  pass are used.
   *
   * @param  String proxyUser is the usernamer to pass to the proxy
   * @param  String proxyPass is the password to pass to the proxy
   */
  public AliveURL(String proxyUser, String proxyPass)
  {
    if (proxyUser != null && !proxyUser.equals(""))
      proxyUsername_ = proxyUser;
    if (proxyPass != null && !proxyPass.equals(""))
      proxyPassword_ = proxyPass;
  }


  /**
   *  Constructor for the AliveURL object
   *
   * @param  url  Description of the Parameter
   */
  public AliveURL(URL url)
  {
    if (url != null)
    {
      StringBuffer outStr = new StringBuffer();
      try
      {
        int respCode = 200;
        //initProxy();
        currDate.setTime(System.currentTimeMillis());
        outStr.append(currDate.toString());
        outStr.append(" ");
        outStr.append(url.getHost());
        outStr.append(url.getPath());
        Properties systemProperties = System.getProperties();
        if (systemProperties.getProperty("http.proxyHost") != null &&
            !systemProperties.getProperty("http.proxyHost").equals(""))
        {
          outStr.append(" proxy ");
          outStr.append(systemProperties.getProperty("http.proxyHost"));
          outStr.append(":");
          outStr.append(systemProperties.getProperty("http.proxyPort"));
        }
        System.out.print(outStr.toString());
        if (url.getProtocol().equals("http"))
        {
          HttpURLConnection connection =
              (HttpURLConnection) url.openConnection();

          respCode = connection.getResponseCode();
          outStr.append(" --> ResponseCode: " );
          outStr.append(respCode);
          outStr.append(" = ");
          outStr.append(connection.getResponseMessage());
          System.out.print(" --> ResponseCode: " + respCode);
          System.out.println(" = " + connection.getResponseMessage());
          if (respCode == HttpURLConnection.HTTP_NOT_FOUND )
          {
            int headerCount = 1;
            while (connection.getHeaderFieldKey(headerCount) != null)
            {
              System.out.print("     "+connection.getHeaderFieldKey(headerCount));
              System.out.println(" = "+connection.getHeaderField(headerCount++));
            }
          }

          if (respCode != 200)
          {
            if(areWePlayingMusic)
            {
              playErrorMusic();
            }
            numSequentialErrors_++;
            if (numSequentialErrors_ > ACCEPTABLE_NUMBER_ERRORS)
              callExternalScript();
          }
          else
          {
            unsetExternalScriptWasExecuted_();
            numSequentialErrors_ = 0;
          }
        }
        else
        {
          URLConnection connection = url.openConnection();
          outStr.append(" --> Successful");
          System.out.println(" --> Successful");
          unsetExternalScriptWasExecuted_();
          numSequentialErrors_ = 0;
        }
      }
      catch (IOException ex)
      {
        String args = ex.getMessage();
        numSequentialErrors_++;
        System.out.println(" --> Unsuccessful ("+numSequentialErrors_+")");
        System.out.println(args);
        outStr.append(" --> Unsuccessful("+numSequentialErrors_+")");
        outStr.append(args);
        if(areWePlayingMusic)
        {
          playErrorMusic();
          }
        if (numSequentialErrors_ > ACCEPTABLE_NUMBER_ERRORS)
          callExternalScript();
      }
      logEntry(outStr.toString());
    }
  }


  /**
   * Sets the to email address for email notice of the no-connection.
   *
   * @param emailTo the email addr to use
   **/
  public void setEmailTo(String emailTo)
  {
    this.emailTo_ = emailTo;
  }


  /**
   * emailTo_ Getter.
   *
   * @return the emailTo_ field.
   **/
  public String getEmailTo()
  {
    return emailTo_;
  }


/**
  * The public set method to set the enableExecScript_ class field.
  *
  * @param enableExecScript is the value to use to set the class field to.
  *
  **/
public void setEnableExecScript(boolean enableExecScript)
{
  this.enableExecScript_ = enableExecScript;
}


/**
  * The public get method to return the enableExecScript_ class field.
  *
  * @return  the class field: enableExecScript_
  *
  **/
public boolean getEnableExecScript()
{
  return enableExecScript_;
}


public void setExternalScriptWasExecuted_()
{
  this.externalScriptWasExecuted_ = true;
}


public void unsetExternalScriptWasExecuted_()
{
  this.externalScriptWasExecuted_ = false;
}


public void setExternalScriptWasExecuted_(boolean externalScriptWasExecuted_)
{
  this.externalScriptWasExecuted_ = externalScriptWasExecuted_;
}


public boolean getExternalScriptWasExecuted_()
{
  return externalScriptWasExecuted_;
}


  /**
   *  Does the gruntwork to get the proxy properties set.
   **/

  public static void initProxy()
  {
    // Set up the proxy settings if needed
    Properties sysProps = System.getProperties();
    String tmpUseproxy  = sysProps.getProperty("proxySet");
    // System.out.println("tmpUseproxy="+tmpUseproxy);
    if (tmpUseproxy != null && !tmpUseproxy.equals("null") && !tmpUseproxy.equals(""))
      areWeUsingProxy_ = (tmpUseproxy.toLowerCase().equals("true")?true:false);


    if (areWeUsingProxy_)
    {
      System.out.println("Initializing the proxy settings");
      // check if the user had something defined in the Sys Props via the cmdline.
      String tmpUser  = sysProps.getProperty("http.proxyUser");
      String tmpPass  = sysProps.getProperty("http.proxyPassword");
      String tmpHost  = sysProps.getProperty("http.proxyHost");
      String tmpPort  = sysProps.getProperty("http.proxyPort");

      if (tmpUser != null && !tmpUser.equals(""))
        proxyUsername_ = tmpUser;
      if (tmpPass != null && !tmpPass.equals(""))
        proxyPassword_ = tmpPass;
      if (tmpHost != null && !tmpHost.equals(""))
        proxyHost_ = tmpHost;
      if (tmpPort != null && !tmpPort.equals(""))
        proxyPort_ = tmpHost;

      if (useProxyAuthentication_)
      {
        System.out.println("Authenticating the proxy.");
        Authenticator.setDefault(new AliveURL(proxyUsername_, proxyPassword_));
      }
      sysProps.put("proxySet", "true");
      sysProps.put("http.proxyHost", proxyHost_);
      sysProps.put("http.proxyPort", proxyPort_);
      sysProps.put("noProxy",
        "www-bcg.bcg.ada.com,*.ada.com,149.154.64.245,149.154.64.245:8080");
    }

  }


   /**
   *  Impl for Authenticator so an authorizing proxy will work.
   **/

  protected PasswordAuthentication getPasswordAuthentication()
  {
    return new PasswordAuthentication(
        proxyUsername_, proxyPassword_.toCharArray());
  }


  /**
   *  Execs an external script/application when an error occurs..
   */
  private void callExternalScript()
  {
    boolean testingOnly = false;

    // 1st cycle the server power OFF
    String cmdScript = "nice.exe";
    Vector v = new Vector();
    v.add("/D");
    v.add("G:\\apps\\x10\\X10_cmd.cmd");
    v.add("B2");
    v.add("OFF");
    if (enableExecScript_)
    {
      executeNativeApp(cmdScript, v);
      setExternalScriptWasExecuted_();
    }
    if (enableJavaX10_)
    {
      //System.out.println("Calling Java X10 Command Off");
      //SendX10 sendX10 = new SendX10("com.jpeterson.x10.module.CM17A");
      //sendX10.transmit(0, x10Cmd1_);
      String x10HouseCode = "B";
      String x10DeviceNumber = "1";
      String x10Command = "off";
      if (!testingOnly) (new ca.bc.webarts.tools.X10FireCracker()).sendX10Command(x10HouseCode, x10DeviceNumber, x10Command );
      if (areWeSendingEmail_)
        sendAnEmail(emailTo_, "AliveURL Notification", "AliveURL Sent X10 Command ( "+
                         x10HouseCode + x10DeviceNumber +" "+x10Command +") - "+(new Date()).toString());
      setExternalScriptWasExecuted_();
    }

    // wait for the command to execute
    mySleep(15000);

    // The cycle the server power back On
    v= new Vector();
    v.add("/D");
    v.add("G:\\apps\\x10\\X10_cmd.cmd");
    v.add("B2");
    v.add("ON");
    if (enableExecScript_)
      executeNativeApp(cmdScript, v);
    if (enableJavaX10_)
    {
      try
      {
        //System.out.println("Calling Java X10 Command On");
        //SendX10 sendX10 = new SendX10("com.jpeterson.x10.module.CM17A");
        //sendX10.transmit(0, x10Cmd2_);
        String x10HouseCode = "B";
        String x10DeviceNumber = "1";
        String x10Command = "on";
        if (!testingOnly) (new ca.bc.webarts.tools.X10FireCracker()).sendX10Command(x10HouseCode, x10DeviceNumber, x10Command );
        if (areWeSendingEmail_)
          sendAnEmail(emailTo_, "AliveURL Notification", "AliveURL Sent X10 Command ( "+
                         x10HouseCode + x10DeviceNumber +" "+x10Command +") - "+(new Date()).toString());
      }
      catch (java.lang.UnsatisfiedLinkError x10Ex)
      {
        System.out.println("Exception thrown... trying again after 60 seconds.");
        // wait for the command to execute
        mySleep(60000);
        //SendX10 sendX10 = new SendX10("com.jpeterson.x10.module.CM17A");
        //sendX10.transmit(0, x10Cmd2_);
        String x10HouseCode = "A";
        String x10DeviceNumber = "2";
        String x10Command = "off";
        if (!testingOnly) (new ca.bc.webarts.tools.X10FireCracker()).sendX10Command(x10HouseCode, x10DeviceNumber, x10Command );
        if (areWeSendingEmail_)
          sendAnEmail(emailTo_, "AliveURL Notification", "AliveURL Sent X10 Command ( "+
                         x10HouseCode + x10DeviceNumber +" "+x10Command +") - "+(new Date()).toString());

      }
    }
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   *
   * @param appParms and extra commandline parameters to tag onto the end of the
   *                 commandline that gets executed.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  private static int executeNativeApp(String executableLocation,
                                      Vector appParms)
  {
    int retVal = -1;
    int cmdParms = 0;
    if (appParms != null)
      cmdParms = appParms.size();
    String [] cmds = new String [cmdParms+1];
    cmds[0] = executableLocation;
    System.out.print("AutoUpdateApp: Executing: "+ cmds[0]);
    for (int i=1; i <= cmdParms; i++)
    {
      cmds[i] = (String) appParms.elementAt(i-1);
      System.out.print(" " + cmds[i]);
    }
    System.out.println("");

    // Start the app... This starts a new process
    try
    {
      Runtime runtime = Runtime.getRuntime();
      Process p = runtime.exec(cmds);

      // capture any output we get
      // any error message?
      StreamGobbler errorGobbler = new
        StreamGobbler(p.getErrorStream(), "RMT APP ERR:");

      // any output?
      StreamGobbler outputGobbler = new
        StreamGobbler(p.getInputStream(), "RMT APP OUT:");

      // kick them off
      errorGobbler.start();
      outputGobbler.start();

      // now wait for the process to end
      try
      {
        p.waitFor();
      }
      catch (InterruptedException intEx)
      {
        // no biggie
      }
      retVal = p.exitValue();
      errorGobbler.finishedGobbling_ = true;
      outputGobbler.finishedGobbling_ = true;
      p.destroy();
      p = null;
      runtime.gc();
    }
    catch (IOException ioEx)
    {
      errorMsg_ = "ERROR: An IO exception occured while attempting " +
        "execution of the " + executableLocation + " application.";
    }
    catch (SecurityException securityEx)
    {
      errorMsg_ = "ERROR: A Java Security Manager is in use and is " +
        "restricting execution of the " + executableLocation + " application.";
    }

    return retVal;
  }


  /**
   * Send a cycle email out to the existing class email addr.
    **/
  private void sendAnEmail()
  {
    sendAnEmail(getEmailTo());
  }


  /**
   * Send a cycle email out.
    **/
  private void sendAnEmail(String to)
  {
    sendAnEmail(to, "AliveURL Notification", "X10 Command Sent - "+currDate.toString());
  }


  /**
   * Send a cycle email out.
    **/
  private void sendAnEmail(String to, String subjectToSend, String msgToSend)
  {
    boolean debug = false;
    //String to = "tgutwin_sms@webarts.bc.ca";
    //String to = "tgutwin@webarts.bc.ca";
    String from = "tgutwin@webarts.bc.ca";
    String host = "aurora1.webarts.bc.ca";
    String msgText = msgToSend;

    // create some properties and get the default Session
    Properties props = new Properties();
    props.put("mail.smtp.host", host);
    if (debug)
    {
      props.put("mail.debug", "true");
    }

    Session session = Session.getDefaultInstance(props, null);
    session.setDebug(debug);

    try
    {
      // create a message
      Message msg = new MimeMessage(session);
      msg.setFrom(new InternetAddress(from));
      InternetAddress[] address = {new InternetAddress(to)};
      msg.setRecipients(Message.RecipientType.TO, address);
      msg.setSubject(subjectToSend);
      msg.setSentDate(new Date());
      // If the desired charset is known, you can use
      // setText(text, charset)
      msg.setText(msgText);

      Transport.send(msg);
    }
    catch (MessagingException mex)
    {
      System.out.println("\n--Exception handling in AliveURL.java");

      mex.printStackTrace();
      System.out.println();
      Exception ex = mex;
      do
      {
        if (ex instanceof SendFailedException)
        {
          SendFailedException sfex = (SendFailedException) ex;
          Address[] invalid = sfex.getInvalidAddresses();
          if (invalid != null)
          {
            System.out.println("    ** Invalid Addresses");
            if (invalid != null)
            {
              for (int i = 0; i < invalid.length; i++)
              {
                System.out.println("         " + invalid[i]);
              }
            }
          }
          Address[] validUnsent = sfex.getValidUnsentAddresses();
          if (validUnsent != null)
          {
            System.out.println("    ** ValidUnsent Addresses");
            if (validUnsent != null)
            {
              for (int i = 0; i < validUnsent.length; i++)
              {
                System.out.println("         " + validUnsent[i]);
              }
            }
          }
          Address[] validSent = sfex.getValidSentAddresses();
          if (validSent != null)
          {
            System.out.println("    ** ValidSent Addresses");
            if (validSent != null)
            {
              for (int i = 0; i < validSent.length; i++)
              {
                System.out.println("         " + validSent[i]);
              }
            }
          }
        }
        System.out.println();
      } while ((ex = ((MessagingException) ex).getNextException())
           != null);
    }

  }

  /**
   *  Initializes the logOut_ Stream based on the outSpot specifired by the user.
   */
  static private void initLogOut()
  {
    switch (outSpot_)
    {
      case FILE:
        if (logFile_ != null)
        {
          try
          {
            logOut_ = new PrintStream(new FileOutputStream(logFile_), true);
          }
          catch (IOException ioEx)
          {
            STD_OUT.println("Error Creating Logfile:\n  " + ioEx.getMessage());
            outSpot_ = CONSOLE;
            initLogOut();
          }
        }
        else
        {
          outSpot_ = CONSOLE;
          initLogOut();
        }
        break;
      case PIPE:
        logOut_ = new PrintStream(userOut_, true);
        break;
      default: // default is CONSOLE
        logOut_ = new PrintStream(STD_OUT, true);
    }
  }

  /**
   *  Generic uncategorized log entry.
   *
   * @param  value  The String to dump into the Log.
   */
  static private void logEntry(String value)
  {
    if (logOut_ != null )
    {
      //value = createCurrentTimeStamp() + ":" + msgSpacing_ + value;
      logOut_.println(value);
    }
  }


  /**  Plays the error music file */
  private void playErrorMusic()
  {
    tk.beep();
    tk.beep();
    if (errorMusic != null)
    {
      //  System.out.println(" --> Nice Music URL");
      // play error music
      playback = new Playback(errorMusic);
      playback.start();
    }
    else if (errorMusicFile != null)
    {
      //  System.out.println(" --> Nice Music File");
      // play error music
      playback = new Playback(errorMusicFile);
      playback.start();
    }
  }


  /**
   *  A method to simply abstract the Try/Catch required to put the current
   *  thread to sleep for the specified time in ms.
   *
   * @param  waitTime  the sleep time in milli seconds (ms).
   * @return           boolean value specifying if the sleep completed (true) or
   *      was interupted (false).
   */
  private static boolean mySleep(long waitTime)
  {
    boolean retVal = true;

    /*
     *  BLOCK for the spec'd time
     */
    try
    {
      Thread.sleep(waitTime);
    }
    catch (InterruptedException iex)
    {
      retVal = false;
    }
    return retVal;
  }


  /**
   *  The main program for the AliveURL class
   *
   * @param  args  The command line arguments
   */
  public static void main(String[] args)
  {
    String emailAddr = null;
    try
    {
      if (args.length > 0)
      {
        short options = 0;
        logFile_ = new File(logFileName_);
        initLogOut();

        // set up the proxy ONCE here for evermore.
        AliveURL.initProxy();


        while (true)
        {
          emailAddr = null;
          if (args[0].toUpperCase().startsWith("-M"))
          {
            // A music file was spec'd
            options = 1;
            if (args[0].substring(2).startsWith("http") ||
                args[0].substring(2).startsWith("ftp") ||
                args[0].substring(2).startsWith("file:/"))
            {
              try
              {
                errorMusic = new URL(args[0].substring(2));
                errorMusicFile = null;
                //  System.out.println("Got Our Error Music URL: " +
                //  errorMusic.toString());
              }
              catch (MalformedURLException badUrl)
              {
                System.out.println("Can't Get ERROR MUSIC URL");
                errorMusic = null;
              }
            }
            else
            {
              // assume it is a file path
              try
              {
                errorMusicFile = new File(args[0].substring(2));
              }
              catch (NullPointerException badUrl)
              {
                System.out.println("Can't Get ERROR MUSIC FILE");
                errorMusicFile = null;
              }
            }
          }
          else if (args[0].toUpperCase().startsWith("-E"))
          {
            options = 1;
            emailAddr = args[0].substring(2);
          }
          else if (args.length >1 && args[1].toUpperCase().startsWith("-M"))
          {
            // A music file was spec'd
            options = 2;
            if (args[1].substring(2).startsWith("http") ||
                args[1].substring(2).startsWith("ftp") ||
                args[1].substring(2).startsWith("file:/"))
            {
              try
              {
                errorMusic = new URL(args[1].substring(2));
                errorMusicFile = null;
                //  System.out.println("Got Our Error Music URL: " +
                //  errorMusic.toString());
              }
              catch (MalformedURLException badUrl)
              {
                System.out.println("Can't Get ERROR MUSIC URL");
                errorMusic = null;
              }
            }
            else
            {
              // assume it is a file path
              try
              {
                errorMusicFile = new File(args[1].substring(2));
              }
              catch (NullPointerException badUrl)
              {
                System.out.println("Can't Get ERROR MUSIC FILE");
                errorMusicFile = null;
              }
            }
          }
          else if (args.length >1 && args[1].toUpperCase().startsWith("-E"))
          {
            options = 2;
            emailAddr = args[1].substring(2);
          }
          else
          {
            // it was not the error music... so use it as a URL to check
            try
            {
              if (useURL)
              {
                errorMusic = new URL(errorMusicUrlStr);
              }
              else
              {
                errorMusicFile = new File(errorMusicFileStr);
              }
              // System.out.println("Got Our Error Music URL.");
            }
            catch (MalformedURLException badUrl)
            {
              System.out.println("Can't Get ERROR MUSIC URL");
              errorMusic = null;
            }
            catch (NullPointerException badUrl)
            {
              System.out.println("Can't Get ERROR MUSIC FILE");
              errorMusicFile = null;
            }
          }


          // now do the check!
          int extraDelay = 0;
          AliveURL checker = null;
          URL url = null;
          for (int i = options; i < args.length; i++)
          {
            url = new URL(args[i]);
            checker = new AliveURL(url);
            if (checker.getExternalScriptWasExecuted_() )
              // add an extra 10 minutes before checking again
              extraDelay = EXTRA_DELAY_TIME;
          }
          System.out.println("----------------------------------------"+
                             (extraDelay>0?" ExtraDelay="+extraDelay/1000:""));
          mySleep(checkDelay + extraDelay);
          if (extraDelay>0 && checker != null)
          {
            if (emailAddr != null)
              checker.sendAnEmail(emailAddr, "AliveURL Notification", "AliveURL Resuming Checking - "+(new Date()).toString());
            else if (areWeSendingEmail_)
              checker.sendAnEmail(emailTo_, "AliveURL Notification", "AliveURL Resuming Checking - "+(new Date()).toString());
            checker.unsetExternalScriptWasExecuted_();
          }
          extraDelay = 0;
          checker = null;
          System.gc();
        }
      }
      else
      {
        URL url = new URL("http://www.webarts.bc.ca");
        while (true)
        {
          try
          {
            if (useURL)
            {
              errorMusic = new URL(errorMusicUrlStr);
            }
            else
            {
              errorMusicFile = new File(errorMusicFileStr);
            }
            //  System.out.println("Got Our Error Music URL.");
          }
          catch (MalformedURLException badUrl)
          {
            System.out.println("Can't Get ERROR MUSIC URL");
            errorMusic = null;
          }
          catch (NullPointerException badUrl)
          {
            System.out.println("Can't Get ERROR MUSIC FILE");
            errorMusicFile = null;
          }
          AliveURL checker = new AliveURL(url);
          int extraDelay = 0;
          if (checker.getExternalScriptWasExecuted_() )
            extraDelay = EXTRA_DELAY_TIME; // add an extra 10 minutes before checking again
          System.out.println("----------------------------------------");
          mySleep(checkDelay+extraDelay);
          if (extraDelay>0  && checker != null)
          {
            if (emailAddr != null)
              checker.sendAnEmail(emailAddr, "AliveURL Notification", "AliveURL Resuming Checking - "+(new Date()).toString());
            else if (areWeSendingEmail_)
              checker.sendAnEmail(emailTo_, "AliveURL Notification", "AliveURL Resuming Checking - "+(new Date()).toString());
            checker.unsetExternalScriptWasExecuted_();
          }
          checker = null;
          extraDelay = 0;
          System.gc();

        }
      }
    }
    catch (MalformedURLException ex)
    {
      String msg = ex.getMessage();
      System.out.println(msg);
    }
  }

/*
  private static void initProxy2()
  {

    boolean httpEnabled = areWeUsingProxy_;
    Properties sysProps = System.getProperties();
    if (!httpEnabled)
    {
      sysProps.remove("proxySet");
      sysProps.remove("proxyHost");
      sysProps.remove("proxyPort");
      sysProps.remove("http.proxyHost");
      sysProps.remove("http.proxyPort");
      sysProps.remove("http.nonProxyHosts");
      Authenticator.setDefault(null);
    }
    else
    {
      if (sysProps.getProperty("http.proxySet") == null ||
          sysProps.getProperty("http.proxySet").equals(""))
        System.setProperty("http.proxySet", DEFAULT_PROXY_SET);

      if (sysProps.getProperty("http.proxyHost") == null ||
          sysProps.getProperty("http.proxyHost").equals(""))
        System.setProperty("http.proxyHost", DEFAULT_PROXY_HOST);

      if (sysProps.getProperty("http.proxyPort") == null ||
          sysProps.getProperty("http.proxyPort").equals(""))
        System.setProperty("http.proxyPort", DEFAULT_PROXY_PORT);

      if (sysProps.getProperty("http.nonProxyHosts") == null ||
          sysProps.getProperty("http.nonProxyHosts").equals(""))
        System.setProperty("http.nonProxyHosts", DEFAULT_PROXY_NOPROXY);

      // set proxy authentication
      String username = sysProps.getProperty("http.proxyUser");
      String password = sysProps.getProperty("http.proxyPassword");
      if (username == null ||
          username.equals(""))
        username = "";

      if (password == null ||
          password.equals(""))
        password = "";

      if(username == null || username.length()==0)
      {
        Authenticator.setDefault(new FirewallAuthenticator(null));
      }
      else
      {
        PasswordAuthentication pw = new PasswordAuthentication(
          username,password.toCharArray()
        );
        Authenticator.setDefault(new FirewallAuthenticator(pw));
      }
    }
  }


  // FirewallAuthenticator class
  static class FirewallAuthenticator extends Authenticator
  {
    PasswordAuthentication pw;

    public FirewallAuthenticator(PasswordAuthentication pw)
    {
      this.pw = pw;
    }

    protected PasswordAuthentication getPasswordAuthentication()
    {
      return pw;
    }
  }
*/

  /**
   *  Write data to the OutputChannel.
   *
   * @author     unknowntgutwin
   */
  public class Playback implements Runnable
  {

    final static int BUFFER_SIZE = 16384;
    SourceDataLine line;
    Thread thread;
    URL urlToPlay = null;
    File fileToPlay = null;
    AudioInputStream audioInputStream = null;


    /**
     *  Constructor for the Playback object
     *
     * @param  url  Description of the Parameter
     */
    public Playback(URL url)
    {
      urlToPlay = url;
    }


    /**
     *  Constructor for the Playback object
     *
     * @param  f  Description of the Parameter
     */
    public Playback(File f)
    {
      fileToPlay = f;
    }


    /**
     *  Description of the Method
     *
     * @param  msg  Description of the Parameter
     */
    private void reportStatus(String msg)
    {
      if (msg != null)
      {
        System.out.println(msg);
      }
    }


    /**
     *  Description of the Method
     *
     * @param  file  Description of the Parameter
     */
    public void createAudioInputStream(File file)
    {
      if (file != null && file.isFile())
      {
        try
        {
          createAudioInputStream(file.toURL());
        }
        catch (MalformedURLException ex)
        {
          audioInputStream = null;
        }
      }
      else
      {
        reportStatus("Audio file required.");
      }
    }


    /**
     *  Description of the Method
     *
     * @param  url  Description of the Parameter
     */
    public void createAudioInputStream(URL url)
    {
      if (url != null)
      {
        try
        {
          //   reportStatus("\nLoading AudioURL Stream " + url);
          InputStream urlStream = url.openStream();
          //   reportStatus("   InputStream is " + (urlStream==null?"null":"Valid"));
          audioInputStream = AudioSystem.getAudioInputStream(urlStream);
        }
        catch (UnsupportedAudioFileException ex)
        {
          reportStatus(ex.toString());
        }
        catch (IOException ex)
        {
          ex.printStackTrace();
        }
      }
      else
      {
        reportStatus("Audio file required.");
      }
    }


    /**  Description of the Method */
    public void start()
    {
      thread = new Thread(this);
      thread.setName("Playback");
      thread.start();
    }


    /**  Description of the Method */
    public void stop()
    {
      thread = null;
    }


    /**
     *  Description of the Method
     *
     * @param  message  Description of the Parameter
     */
    private void shutDown(String message)
    {
      if (message != null)
      {
        System.err.println(message);
      }
    }


    /**  Main processing method for the Playback object */
    public void run()
    {

      // reload the file if loaded by file
      if (fileToPlay != null)
      {
        createAudioInputStream(fileToPlay);
      }

      // reload the file if loaded by file
      if (urlToPlay != null)
      {
        createAudioInputStream(urlToPlay);
      }

      // make sure we have something to play
      if (audioInputStream == null)
      {
        shutDown("No loaded audio to play back");
        return;
      }
      // reset to the beginnning of the stream
      try
      {
        audioInputStream.reset();
      }
      catch (Exception e)
      {
        shutDown("Unable to reset the stream\n" + e);
        return;
      }

      // get an AudioInputStream of the desired format for playback
      AudioFormat format = audioInputStream.getFormat();
      AudioInputStream playbackInputStream = AudioSystem.getAudioInputStream(format, audioInputStream);

      if (playbackInputStream == null)
      {
        shutDown("Unable to convert stream of format " + audioInputStream + " to format " + format);
        return;
      }

      // define the required attributes for our line,
      // and make sure a compatible line is supported.

      DataLine.Info info = new DataLine.Info(SourceDataLine.class,
          format);
      if (!AudioSystem.isLineSupported(info))
      {
        shutDown("Line matching " + info + " not supported.");
        return;
      }

      // get and open the source data line for playback.

      try
      {
        line = (SourceDataLine) AudioSystem.getLine(info);
        line.open(format, BUFFER_SIZE);
      }
      catch (LineUnavailableException ex)
      {
        shutDown("Unable to open the line: " + ex);
        return;
      }

      // play back the captured audio data

      int frameSizeInBytes = format.getFrameSize();
      int bufferLengthInFrames = line.getBufferSize() / 8;
      int bufferLengthInBytes = bufferLengthInFrames * frameSizeInBytes;
      byte[] data = new byte[bufferLengthInBytes];
      int numBytesRead = 0;

      // start the source data line
      line.start();

      while (thread != null)
      {
        try
        {
          if ((numBytesRead = playbackInputStream.read(data)) == -1)
          {
            break;
          }
          int numBytesRemaining = numBytesRead;
          while (numBytesRemaining > 0)
          {
            numBytesRemaining -= line.write(data, 0, numBytesRemaining);
          }
        }
        catch (Exception e)
        {
          shutDown("Error during playback: " + e);
          break;
        }
      }
      // we reached the end of the stream.  let the data play out, then
      // stop and close the line.
      if (thread != null)
      {
        line.drain();
      }
      line.stop();
      line.close();
      line = null;
      shutDown(null);
    }

  }
  // End class Playback
}