/**
 @file Stopwatch.h
 
 @maintainer Morgan McGuire, http://graphics.cs.williams.edu
  
 @created 2005-10-05
 @edited  2009-05-10

 Copyright 2000-2009, Morgan McGuire.
 All rights reserved.
 */

#ifndef G3D_Stopwatch_h
#define G3D_Stopwatch_h

#include "G3D/platform.h"
#include "G3D/Queue.h"
#include "G3D/G3DGameUnits.h"
#include "G3D/g3dmath.h"

namespace G3D {

/**
  \brief Accurately measure durations and framerates.

  Example 1: For profiling code in the context of a rendering loop:
    <pre>
      sw.tick();
      ...timed code...
      sw.tock();

      screenPrintf("%f\n", sw.smoothFPS());
    </pre>


  Example 2: For profiling pieces of a sequence:
   <pre>
    Stopwatch sw;
    slowOperation();
    sw.after("slowOperation");
    kdTree.balance();
    sw.after("Balance tree");
   </pre>
 */
class Stopwatch {
private:

    std::string             myName;
    double                  startTime;
    std::string             prevMark;
    double                  prevTime;

    /** True between tick and tock */
    bool                    inBetween;

    /** The initial cycle count. */
    uint64                  cycleStart;

    /** The time at which tick was called. */
    RealTime                timeStart;

    /** The time at which the previous tock was called, -1 if never. */
    RealTime                lastTockTime;

    RealTime                lastDuration;
    int64                   lastCycleCount;

    /** Frames per second. */
    double                  m_fps;

    /** Weighted fps */
    double                  emwaFPS;
    double                  m_smoothFPS;

    /** Weighted duration */
    RealTime                emwaDuration;

    /** The overhead for calling into the class. */
    int64                   cycleOverhead;
   
    /** Called from the constructor. */
    void computeOverhead();

public:

    Stopwatch(const std::string& name = "Stopwatch");

    /** Returns the number of times that tick was called per wall-clock second; 
        e.g. frames-per-second. */
    double FPS() const {
        return m_fps;
    }

    /** Amount of time between the most recent tick and tock calls.  0 if tick has
        never been called. */
    RealTime elapsedTime() const {
        return lastDuration;
    }

    /** Time-smoothed value that is stable to the nearest 1%.
        This is useful if you are displaying elapsed time in real-time 
        and want a stable number.*/
    RealTime smoothElapsedTime() const {
        return emwaDuration;
    }

    /** Time-smoothed value of fps that is stable to the nearest integer for fps > 10 and 
      to the first decimal place for fps <= 10.
      This is useful if you
      are displaying the frame rate in real-time and want a stable (readable) number.*/
    double smoothFPS() const {
        return m_smoothFPS;
    }

    /** The elapsed cycle time between tick and tock.  An attempt is made to factor out all
        tick/tock overhead, so that back-to-back calls should return zero.  
        Unreliable on non-x86 platforms.*/
    uint64 elapsedCycles() const {
        return lastCycleCount;
    }

    /** Call at the beginning of the period that you want timed. */
    void tick();

    /** Call at the end of the period that you want timed. */
    void tock();

    
    /** Reset the start time used by after() and the emwa value.*/
    void reset();

    /** Call after an operation has completed, with the name of the operation, to
        print a debug message listing the time since the previous after() call. */
    void after(const std::string& s = "");

};

/** Because it is hard to remember the proper capitalization. */
typedef Stopwatch StopWatch;

}

#endif

