/*
      Copyright 2009 Ramon Servadei
   
      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 fulmine.util.log;
  
  import static fulmine.util.Utils.COMMA_SPACE;
  
  import java.util.TimerTask;
  
  import org.apache.commons.logging.Log;
  
  import fulmine.Domain;
  import fulmine.Type;
  import fulmine.event.EventFrameExecution;
  import fulmine.event.IEventManager;
  import fulmine.model.IModelManager;
  import fulmine.model.container.IContainer;
  import fulmine.model.field.LongField;
  
  /**
   * A standard implementation. This logs statistics at the INFO level and updates
   * an information container. The information container (or 'info record') is
   * created lazily to get around some startup lifecycle sequence clashes between
   * the {@link IEventManager} and {@link IModelManager} that compose the context.
   * <p>
   * The statistics are grouped into 'interval' and 'total' groups. The interval
   * group is for statistics in the last sampling interval whilst the total group
   * maintains statistics for all sampling intervals since sampling began.
   * 
   * @author Ramon Servadei
   */
  public final class Statistics extends TimerTask implements IStatistics,
      Runnable
  {
      private final static Log LOG = new AsyncLog(Statistics.class);
  
      private static final String TOTAL_POPPED = "totalPopped";
  
      private static final String POPPED = "popped";
  
      private static final String QUEUE_SIZE = "Q size";
  
      private static final String MAX = "max Q time (usec)";
  
      /** The maximum latency on the queue in an interval, measured in microseconds */
      long max;
  
      /** The number of items pushed onto the queue in an interval */
      long queueSize;
  
      /** The number of items popped off the queue in an interval */
      long popped;
  
      /** The number of items popped off the queue across all intervals */
      long totalPopped;
  
      /** The last time stats were logged */
      long lastStatisticsLogTime = System.currentTimeMillis();
  
      /**
       * System property to define the time period (in milliseconds) for logging.
       * 
       * @see #DEFAUL_TIME_PERIOD
       */
      public final static String TIME_PERIOD_PROPERTY =
          Statistics.class.getSimpleName() + ".timePeriod";
  
      /** The default log time period */
      public final static String DEFAUL_TIME_PERIOD = "10000";
  
      /** The time period in milliseconds for logging statistics */
      public static final long TIME_PERIOD =
          Integer.parseInt(System.getProperty(TIME_PERIOD_PROPERTY,
              DEFAUL_TIME_PERIOD));
  
      /** The information container identity */
      private final String infoRecordIdentity;
  
      /**
       * Used to create the info record, this is done lazily because a container
       * can't be created during the initialisation phase of a context
       */
      private final IModelManager context;
  
      /** The information container to update */
      private IContainer infoRecord;
  
     /**
      * Standard constructor
      * 
      * @param infoRecordIdentity
      *            the identity for the information container record
      * @param context
      *            the context, used to lazily create the info record
      */
     public Statistics(String infoRecordIdentity, IModelManager context)
     {
         super();
         this.infoRecordIdentity = infoRecordIdentity;
         this.context = context;
     }
 
     public void processEvent(long elapsedTimeMicroSecs)
     {
         this.max = Math.max(elapsedTimeMicroSecs, this.max);
     }
 
     public void intervalFinished(final int queueSize, final int popped)
     {
         this.popped += popped;
         this.queueSize = queueSize;
     }
 
     /**
      * Helper method that performs all the work to update the 'info record' with
      * the current statistics.
      */
     private void updateInfoRecord()
     {
         if (this.context != null && this.context.isActive())
         {
             if (this.infoRecord == null)
             {
                 this.infoRecord =
                     this.context.getLocalContainer(this.infoRecordIdentity,
                         Type.SYSTEM, Domain.FRAMEWORK);
                 this.infoRecord.add(new LongField(MAX));
                 this.infoRecord.add(new LongField(QUEUE_SIZE));
                 this.infoRecord.add(new LongField(POPPED));
                 this.infoRecord.add(new LongField(TOTAL_POPPED));
             }
             this.infoRecord.beginFrame(new EventFrameExecution());
             try
             {
                 this.infoRecord.getLongField(MAX).set(this.max);
                 this.infoRecord.getLongField(QUEUE_SIZE).set(this.queueSize);
                 this.infoRecord.getLongField(POPPED).set(this.popped);
                 this.infoRecord.getLongField(TOTAL_POPPED).set(this.totalPopped);
             }
             finally
             {
                 this.infoRecord.endFrame();
             }
         }
     }
 
     /**
      * @return a string with max, queueSize, popped, totalPopped
      */
     @Override
     public final String toString()
     {
         StringBuilder sb = new StringBuilder(80);
         sb.append(this.max).append(COMMA_SPACE);
         sb.append(this.queueSize).append(COMMA_SPACE);
         sb.append(this.popped).append(COMMA_SPACE);
         sb.append(this.totalPopped).append(COMMA_SPACE);
         return sb.toString();
     }
 
     /**
      * Handles updating the info record with the statistics.
      */
     public void run()
     {
         this.totalPopped += this.popped;
 
         if (LOG.isInfoEnabled())
         {
             final String data = toString();
             StringBuilder sb =
                 new StringBuilder(data.length()
                     + this.infoRecordIdentity.length() + 8);
             sb.append(infoRecordIdentity).append("(stats) ");
             sb.append(data);
             LOG.info(sb.toString());
         }
         updateInfoRecord();
 
         // reset stats
         this.max = 0;
         this.popped = 0;
     }
 }