/**
*    Copyright 2011, Big Switch Networks, Inc. 
*    Originally created by David Erickson, Stanford University
* 
*    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 net.floodlightcontroller.counter;

import java.util.Date;


/**
 * This is a simple counter implementation that doesn't support data series.
 * The idea is that floodlight only keeps the realtime value for each counter,
 * statd, a statistics collection daemon, samples counters at a user-defined interval
 * and pushes the values to a database, which keeps time-based data series. 
 * @author Kanzhe
 *
 */
public class SimpleCounter implements ICounter {

  protected CounterValue counter;
  protected Date samplingTime;
  protected Date startDate;
  
  /**
   * Factory method to create a new counter instance.  
   * 
   * @param startDate
   * @return
   */
  public static ICounter createCounter(Date startDate, CounterValue.CounterType type) {
    SimpleCounter cc = new SimpleCounter(startDate, type);
    return cc;
  }
  
  /**
   * Factory method to create a copy of a counter instance.  
   * 
   * @param startDate
   * @return
   */
  public static ICounter createCounter(ICounter copy) {
    if (copy == null ||
        copy.getCounterDate() == null ||
        copy.getCounterValue() == null) {
        return null;
    }

     SimpleCounter cc = new SimpleCounter(copy.getCounterDate(),
            copy.getCounterValue().getType());
     cc.setCounter(copy.getCounterDate(), copy.getCounterValue());
     return cc;
  }
  
  /**
   * Protected constructor - use createCounter factory method instead
   * @param startDate
   */
  protected SimpleCounter(Date startDate, CounterValue.CounterType type) {
    init(startDate, type);
  }
  
  protected void init(Date startDate, CounterValue.CounterType type) {
    this.startDate = startDate;
    this.samplingTime = new Date();
    this.counter = new CounterValue(type);
  }
  
  /**
   * This is the key method that has to be both fast and very thread-safe.
   */
  @Override
  synchronized public void increment() {
    this.increment(new Date(), (long)1);
  }
  
  @Override
  synchronized public void increment(Date d, long delta) {
    this.samplingTime = d;
    this.counter.increment(delta);
  }
  
  synchronized public void setCounter(Date d, CounterValue value) {
      this.samplingTime = d;
      this.counter = value;
  }
  
  /**
   * This is the method to retrieve the current value.
   */
  @Override
  synchronized public CounterValue getCounterValue() {
    return this.counter;
  }

  /**
   * This is the method to retrieve the last sampling time.
   */
  @Override
  synchronized public Date getCounterDate() {
    return this.samplingTime;
  }
  
  /**
   * Reset value.
   */
  @Override
  synchronized public void reset(Date startDate) {
    init(startDate, this.counter.getType());
  }
  
  @Override
  /**
   * This method only returns the real-time value.
   */
  synchronized public CountSeries snapshot(DateSpan dateSpan) {
    long[] values = new long[1];
    values[0] = this.counter.getLong();
    return new CountSeries(this.samplingTime, DateSpan.DAYS, values);
  }
}