#ifndef __JEEP__JTIMEKEEPER__
#define __JEEP__JTIMEKEEPER__

#include <limits>
#include <sys/select.h>
#include <unistd.h>

#include "JSystem/JTime.hh"
#include "JLang/JFileDescriptorMask.hh"
#include "JLang/JTimeval.hh"
#include "Jeep/JTimer.hh"


/**
 * \file
 * Scheduling of actions via fixed latency intervals.
 * \author mdejong
 */
namespace JEEP {}
namespace JPP { using namespace JEEP; }

namespace JEEP {

  using JSYSTEM::getLocalTime;
  using JLANG::JFileDescriptorMask;
  using JLANG::JTimeval;


  /**
   * Time keeper.
   * This class can be used to check whether elapsed time exceeds preset time interval or
   * to wait until preset time interval has elapsed.
   */
  class JTimekeeper {
  public:
    /**
     * Default constructor.
     */
    JTimekeeper() :
      interval   (0),
      total_delay(0),
      counter    (0)
    {
      reset();
    }


    /**
     * Constructor.
     *
     * \param  interval_us     interval time [us]
     */
    JTimekeeper(const long long int interval_us) :
      interval   (interval_us),
      total_delay(0),
      counter    (0)
    {
      reset();
    }


    /**
     * Get interval time.
     *
     * \return                 interval time [us]
     */
    long long int getInterval() const
    {
      return interval;
    }


    /**
     * Get total delay time.
     *
     * \return                 delay time [us]
     */
    long long int getDelay() const
    {
      return total_delay;
    }


    /**
     * Set interval time.
     *
     * \param  interval_us     interval time [us]
     */
    void setInterval(const long long int interval_us) 
    {
      interval = interval_us;
    }


    /**
     * Reset time.
     *
     * \param  t0              time [us]
     */
    void reset(const long long int t0)
    {
      this->t0          = t0;
      this->counter     = 0;
      this->total_delay = 0;
    }


    /**
     * Reset time.
     */
    void reset()
    {
      reset(getLocalTime());
    }
    

    /**
     * Check whether the number of time intervals has elapsed since
     * the last call to the reset method.
     * The number of intervals is equal to the number of calls this 
     * method returned true since the last call to the reset method.
     *
     * \return                 true if elapsed time exceeds interval time; else false
     */
    bool operator()() const
    {
      if (getLocalTime() >= t0 + (counter + 1) * interval) {

	++counter;

	return true;

      } else

	return false;
    }


    /**
     * Wait until the number of time intervals has elapsed since
     * the last call to the reset method.
     * The number of intervals is equal to the number of calls to
     * the method wait since the last call to the reset method.
     */
    void wait() const
    { 
      static const useconds_t MAXIMAL_SLEEP_TIME_US = std::numeric_limits<useconds_t>::max();

      long long int delay = t0  +  (counter + 1) * interval  -  getLocalTime();   // [us]

      while (delay > MAXIMAL_SLEEP_TIME_US && usleep(MAXIMAL_SLEEP_TIME_US) == 0) {

	total_delay += MAXIMAL_SLEEP_TIME_US;
	delay       -= MAXIMAL_SLEEP_TIME_US;
      }

      if (delay > 0 && usleep((useconds_t) delay) == 0) {
	total_delay += delay;
      }

      ++counter;
    }


    /**
     * Wait until the number of time intervals has elapsed since
     * the last call to the reset method or input data have become
     * available on one of the file descriptors in the given mask.
     * The number of intervals is equal to the number of calls to
     * the method wait since the last call to the reset method.
     * Note that the mask is overwritten following a select call.
     *
     * \param  mask            input mask
     * \return                 true if interrupted; else false
     */
    bool wait(JFileDescriptorMask& mask) const
    { 
      long long int t1    = getLocalTime();  
      long long int delay = t0  +  (counter + 1) * interval  -  t1;   // [us]

      // ensure one select call for each call to this method.

      if (delay < 0) {
	delay = 0;
      }

      JTimeval timeout((int) (delay/1000000), (int) (delay%1000000));

      if (mask.in_avail(timeout)) {

	total_delay += getLocalTime() - t1;
	
	return true;

      } else {

	++counter;

	total_delay += delay;

	return false;
      }
    }
    

  protected:
    long long int interval;               //!< interval time      [us]

  private:
    mutable long long int t0;             //!< t0 of elapsed time [us]
    mutable long long int total_delay;    //!< total delay time   [us]
    mutable long long int counter;        //!< interval counter
  };
}

#endif