/*
    * The contents of this file are subject to the terms 
    * of the Common Development and Distribution License 
    * (the "License").  You may not use this file except 
    * in compliance with the License.
    * 
    * You can obtain a copy of the license at 
    * http://www.sun.com/cddl/cddl.html. 
    * See the License for the specific language governing 
   * permissions and limitations under the License.
   * 
   * When distributing Covered Code, include this CDDL 
   * HEADER in each file and include the License file at 
   * license.txt.  If applicable, add the following below 
   * this CDDL HEADER, with the fields enclosed by brackets 
   * "[]" replaced with your own identifying information: 
   * Portions Copyright [yyyy] [name of copyright owner]
   * 
   * Portions Copyright 2004 eBay, Inc.
   */
  package com.ebay.carad.os.vitalsigns.listeners;
  
  import java.net.InetAddress;
  import java.text.Format;
  import java.text.MessageFormat;
  import java.util.Date;
  
  import com.ebay.carad.os.vitalsigns.IDashboardAgent;
  import com.ebay.carad.os.vitalsigns.IDashboardReport;
  import com.ebay.carad.os.vitalsigns.IReportingListenerContainer;
  import com.ebay.carad.os.vitalsigns.ReportingException;
  import com.ebay.carad.os.vitalsigns.util.ExceptionUtil;
  import com.ebay.carad.os.vitalsigns.util.MailUtil;
  
  /***
   * <p>Report listener that can send email alerts for ReportingExceptions and for data
   * that is recorded that is out of the expected range.</p>
   * 
   * @author Jeremy Thomerson
   * @version $Id$
   */
  public class EmailAlertListener extends AbstractReportingListener {
  
      //private static final Logger LOGGER = Logger.getLogger(EmailAlertListener.class);
      private float mDataLevel = 0;
      private String mErrorType = "ERROR";
      
      private Format mExceptionMessageFormat = new MessageFormat(
              ""
              ); 
      
      private Format mLevelMessageFormat = new MessageFormat(
              "{2}\n\nReport ID {4} ({3}) recorded data of {1} which is above the error threshold ({5})\n\n{6}\n\nFrom machine: {7}"
              ); 
      
  
      private String mMailServer;
      private String[] mToAddresses;
      private String mFromAddress;
      private String mMessageSubject;
      
      private boolean rememberValues = false;
      
      private float lastObservedValue = 0;
      
      /***
       * If true, the listener will only send an email if the currently observed value is outside the threshold, AND
       * is "worse" than the last observed value. This is usually desired in situations where observed values are long-lived.
       * For example, if your report observes number of order exceptions in last 24 hours, but you want an email to be sent
       * when any errors are detected, you probably do not want to receive an email every time the report is run for 24 hours
       * after the first error is detected. Instead, you want to get an alert if any more errors are received than the last time
       * you looked. If enabled, the listener will compare the currently observed value to the last observed value, and send
       * an email only if the current value is outside of the threshold and worse than the last one. This option is OFF by default.
       * 
       * @param rememberValues if true, emails will only be sent when values got "worse" than last observation
       */
      public void setRememberValues(boolean rememberValues) {
  		this.rememberValues = rememberValues;
  	}
  
  	/***
       * Sets the address of the SMTP relay to use.
       * 
       * @param server IP address or hostname of SMTP relay
       */
      public void setMailServer(String server) {
          mMailServer = server;
      }
      
      /***
       * Sets the address that mail alerts will appear to come from.
       * 
       * @param address the address to send from
       */
      public void setFromAddress(String address) {
          mFromAddress = address;
      }
      
      /***
      * Sets the addresses that mail alerts will be sent to.
      * 
      * @param inToAddresses the "to" e-mail addresses
      */
     public void setToAddresses(String[] inToAddresses) {
         mToAddresses = inToAddresses;
     }
     
     /***
      * Sets the subject line for alerts sent by this handler.
      * 
      * @param inSubject subject line for alerts
      */
     public void setSubject(String inSubject) {
         mMessageSubject = inSubject;
     }
     
     public void alert(String msg) {
         try {
             MailUtil.sendMessage(new String[] { mFromAddress }, mToAddresses, mMessageSubject, msg, mMailServer);
         } catch (Exception ex) {
             ex.printStackTrace();
         }
     }
 
     /***
      * Receives parameters:
      * <pre> 
      * {
      *  0 : report.getPreviousData(), 
      *  1 : report.getThisRunData(), 
      *  2 : report.getTitle(),
      *  3 : report.getID(),
      *  4 : exception.getMessage(),
      *  5 : full exception details, including stack trace, as string
      *  6 : new Date().toString()
      * }
      * </pre>
      */
     public void reportingException(ReportingException exception, IReportingListenerContainer agent, IDashboardReport report) {
         Object[] params = new Object[] {
                 report.getPreviousData(),
                 report.getThisRunData(),
                 report.getTitle(),
                 new Integer(report.getID()),
                 exception.getMessage(),
                 getExceptionString(exception),
                 getLocalMachineName()
         };
         String msg = mExceptionMessageFormat.format(params);
         alert(msg);
     }
 
     /***
      * Receives parameters:
      * <pre> 
      * {
      *  0 : report.getPreviousData(), 
      *  1 : report.getThisRunData(), 
      *  2 : this.errorType (i.e. WARNING / ERROR),
      *  3 : report.getTitle(),
      *  4 : report.getID(),
      *  5 : this.dataLevel
      *  6 : new Date().toString()
      * }
      * </pre>
      */
     public void reportRan(IDashboardAgent agent, IDashboardReport report) {
         if (!isAlertNeeded(report)) { 
             return;
         }
         Object[] params = new Object[] { 
                 report.getPreviousData(),
                 report.getThisRunData(),
                 mErrorType,
                 report.getTitle(),
                 new Integer(report.getID()),
                 new Float(mDataLevel),
                 new Date().toString(),
                 getLocalMachineName()
         };
         String msg = mLevelMessageFormat.format(params);
         alert(msg);
     }
     
     private String getLocalMachineName() {
     	String ret = "unknown";
     	try {
     	    ret = InetAddress.getLocalHost().getHostName();
     	} catch(Exception ex) {
     	}
     	return ret;
     }
 
     private boolean isAlertNeeded(IDashboardReport report) {
         Float data = report.getThisRunData();
         if (data == null) {
             return false;
         }
         
         float dataVal = data.floatValue();
         boolean outOfThreshold = report.getMoreIsBetter() ? dataVal < mDataLevel : dataVal > mDataLevel;
         boolean ret = outOfThreshold;
 
         if (outOfThreshold) { // check if memory is turned on
         	if (rememberValues) { // only return true if this value got worse since our last observation.
         		ret = report.getMoreIsBetter() ? dataVal < lastObservedValue : dataVal > lastObservedValue;
         	}
         }
         
         lastObservedValue = dataVal; // remember for next time
 
         return ret;
     }
 
     private String getExceptionString(ReportingException exception) {
         return ExceptionUtil.fullDetailsMessage(exception);
     }
 
     public void setErrorType(String errorType) {
         mErrorType = errorType;
     }
     public void setThreshold(float dataLevel) {
         mDataLevel = dataLevel;
     }
 }