/*
    ~ Copyright 2006-2007 Nicolas De Loof.
    ~
    ~ Licensed under the Apache License, Version 2.0 (the "License");
    ~ you may not use this file except in compliance with the License.
    ~ You may obtain a copy of the License at
    ~
    ~      http://www.apache.org/licenses/LICENSE-2.0
    ~
   ~ Unless required by applicable law or agreed to in writing, software
   ~ distributed under the License is distributed on an "AS IS" BASIS,
   ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License.
   */
  package org.jmonit.features;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import org.jmonit.events.DataMonitoredEvent;
  import org.jmonit.events.MonitoringEvent;
  import org.jmonit.reporting.Visitable;
  import org.jmonit.reporting.Visitor;
  
  /**
   * Computes some statistics from monitored datas.
   * 
   * @author <a href="mailto:nicolas.deloof@gmail.com">Nicolas De Loof</a>
   */
  public class Statistics
      extends AbstractFeature<Statistics>
      implements Visitable
  {
      /** hits counter */
      private long hits;
  
      /** Total counter */
      private long total;
  
      /** Min value counter */
      private long min;
  
      /** Max value counter */
      private long max;
  
      /** total of squares */
      private long squares;
  
      /**
       * {@inheritDoc}
       * 
       * @see org.jmonit.events.MonitoringEventListener#onMonitoringEvent(org.jmonit.events.MonitoringEvent)
       */
      public void onMonitoringEvent( MonitoringEvent event )
      {
          if ( event instanceof DataMonitoredEvent )
          {
              DataMonitoredEvent data = (DataMonitoredEvent) event;
              added( data.getData() );
          }
      }
  
      /**
       * {@inheritDoc}
       */
      public synchronized void added( long value )
      {
          total += value;
          squares += value * value;
          if ( hits == 0 || min > value )
          {
              min = value;
          }
          if ( hits == 0 || max < value )
          {
              max = value;
          }
          hits++;
      }
  
      /**
       * @return the hits
       */
      public long getHits()
      {
          return hits;
      }
  
      /**
       * @return the max
       */
      public long getMax()
      {
          return max;
      }
  
      public synchronized double getMean()
      {
         if ( hits == 0 )
         {
             return Double.NaN;
         }
         return ( (double) total ) / hits;
     }
 
     /**
      * @return the min
      */
     public long getMin()
     {
         return min;
     }
 
     /**
      * Compute the standard deviation (measures the dispersion of values around
      * the average value) = sqrt( variance )
      * 
      * @return the standard deviation
      */
     public double getStandardDeviation()
     {
         return Math.sqrt( getVariance() );
     }
 
     /**
      * @return the total
      */
     public long getTotal()
     {
         return total;
     }
 
     /**
      * Computes the
      * {@link http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance}
      * unbiased variance.
      * <p>
      * 
      * @return the variance
      */
     public synchronized double getVariance()
     {
         long n = hits;
         if ( n <= 1 )
         {
             return Double.NaN;
         }
         double sumOfSqr = squares;
         double sum = total;
         double mean = getMean();
         return ( sumOfSqr - sum * mean ) / ( n - 1 );
     }
 
     public void clear()
     {
         hits = 0;
         max = 0;
         min = 0;
         squares = 0;
         total = 0;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.spi.Plugin#getFeature()
      */
     public Statistics getFeature()
     {
         return this;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.jmonit.reporting.Visitable#accept(org.jmonit.reporting.Visitor)
      */
     public synchronized void accept( Visitor visitor )
     {
         Map<String, Object> attributes = new HashMap<String, Object>();
         attributes.put( "hits", getHits() );
         attributes.put( "mean", getMean() );
         attributes.put( "min", getMin() );
         attributes.put( "max", getMax() );
         attributes.put( "standardDeviation", getStandardDeviation() );
         attributes.put( "total", getTotal() );
         visitor.visit( attributes );
     }
 
     public static final org.jmonit.spi.Factory<Statistics> FACTORY =
         new org.jmonit.spi.Factory<Statistics>()
         {
             public Statistics newPluginInstance()
             {
                 return new Statistics();
             }
         };
 
     /**
      * {@inheritDoc}
      * 
      * @see java.lang.Object#toString()
      */
     public String toString()
     {
         StringBuffer stb = new StringBuffer( "Statistics" );
         stb.append( "[\n" );
         stb.append( "  hits    = " ).append( this.hits ).append( "\n" );
         stb.append( "  total   = " ).append( this.total ).append( "\n" );
         stb.append( "  min     = " ).append( this.min ).append( "\n" );
         stb.append( "  max     = " ).append( this.max ).append( "\n" );
         stb.append( "  mean    = " ).append( getMean() ).append( "\n" );
         stb.append( "  std.dev = " ).append( getStandardDeviation() ).append( "\n" );
         stb.append( "]" );
         return stb.toString();
     }
 }