#ifndef __CHRONOMETER_HPP
#define __CHRONOMETER_HPP

#include <vector>
#include <ctime>
#include <ostream>
#include <stdint.h>

/**
 * \author cpellegrino
 */

class Chronometer
{
  std::vector<timespec> m_times;

 public:

  Chronometer() {}

  Chronometer(size_t N)
  {
    m_times.reserve(N);
    set();
  }

  void swap(Chronometer& original)
  {
    m_times.swap(original.m_times);
  }

  void set()
  {
    timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    m_times.push_back(ts);
  }

  void reset()
  {
    const size_t capacity = m_times.capacity();
    m_times.clear();
    m_times.reserve(capacity);
  }

  friend std::ostream& operator <<(std::ostream& stream, const Chronometer& ch);
};


inline uint64_t inMicroseconds(const timespec& time)
{
  return time.tv_sec * 1000000 + time.tv_nsec / 1000;
}

inline timespec operator -(const timespec& first, const timespec& second)
{
  timespec difference;
  difference.tv_sec  = first.tv_sec  - second.tv_sec;
  difference.tv_nsec = first.tv_nsec - second.tv_nsec;

  if (difference.tv_nsec < 0)
  {
    difference.tv_nsec = 1000000000 + difference.tv_nsec;
    --difference.tv_sec;
  }

  return difference;
}

const static char separator = ' ';

inline std::ostream& operator <<(std::ostream& stream, const Chronometer& ch)
{
  stream << ch.m_times[0].tv_sec << separator << ch.m_times[0].tv_nsec;

  for (unsigned int i = 0, e = ch.m_times.size() - 1; i < e; ++i)
  {
    stream << separator << inMicroseconds(ch.m_times[i + 1] - ch.m_times[i]);
  }

  return stream;
}

#endif