#ifndef __JDAQCHRONOMETER__
#define __JDAQCHRONOMETER__

#include <ostream>
#include <iomanip>

#include "JIO/JSerialisable.hh"
#include "JDAQ/JDAQRoot.hh"
#include "JDAQ/JDAQUTCExtended.hh"
#include "JDAQ/JDAQClock.hh"


namespace KM3NETDAQ {

  namespace {
    using JIO::JReader;
    using JIO::JWriter;
  }


  /**
   * DAQ chronometer.
   */
  class JDAQChronometer
  {
  public:
    /**
     * Default constructor.
     */
    JDAQChronometer() :
      run        (0),
      frame_index(0),
      timeslice_start()
    {}


    /**
     * Constructor.
     *
     * \param  runNumber     run number
     * \param  frameIndex    frame index
     * \param timesliceStart start of time slice
     */
    JDAQChronometer(const int runNumber,
		    const int frameIndex,
		    const JDAQUTCExtended timesliceStart) :
      run        (runNumber),
      frame_index(frameIndex),
      timeslice_start(timesliceStart)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQChronometer()
    {}


    /**
     * Get DAQ chronometer.
     *
     * \return                DAQ chronometer
     */
    const JDAQChronometer& getDAQChronometer() const 
    { 
      return *this; 
    }


    /**
     * Set DAQ chronometer.
     *
     * \param chronometer     DAQ chronometer
     */
    void setDAQChronometer(const JDAQChronometer& chronometer)
    { 
      *this = chronometer;
    }


    /**
     * Get run number.
     *
     * \return                run number
     */
    int getRunNumber() const 
    { 
      return run; 
    }


    /**
     * Get frame index.
     *
     * \return                frame index
     */
    int getFrameIndex() const 
    { 
      return frame_index; 
    }
    
    
    /**
     * Get start of timeslice
     *
     * \return                timeslice start
     */
    
    JDAQUTCExtended getTimesliceStart() const
    {
      return timeslice_start;
    }
    

    /**
     * Set run number.
     *
     * \param run             run number
     */
    void setRunNumber(const int run)
    { 
      this->run = run;
    }


    /**
     * Set frame index.
     *
     * \param frame_index     frame index
     */
    void setFrameIndex(const int frame_index)
    { 
      this->frame_index = frame_index;
    }

    
    /**
     * Set timeslice start time
     *
     * \param timeslice_start timeslice start time
     */
    
    void setTimesliceStart(const JDAQUTCExtended timeslice_start)
    {
      this->timeslice_start = timeslice_start;
    }
    

    /**
     * Read DAQ chronometer from input.
     *
     * \param  in             JReader
     * \param  chronometer    JDAQChronometer
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JDAQChronometer& chronometer)
    {
      in >> chronometer.run;
      in >> chronometer.frame_index;
      in >> chronometer.timeslice_start;

      return in;
    }


    /**
     * Write DAQ chronometer to output.
     *
     * \param  out           JWriter
     * \param  chronometer   JDAQChronometer
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JDAQChronometer& chronometer)
    {
      out << chronometer.run;
      out << chronometer.frame_index;
      out << chronometer.timeslice_start;
      
      return out;
    }


    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    static int sizeOf()
    {
      return (sizeof(int) +
	      sizeof(int) +
	      JDAQUTCExtended::sizeOf());
    }


    ClassDef(JDAQChronometer,2);


  protected:
    int run;
    int frame_index;
    JDAQUTCExtended timeslice_start;
  };


  /**
   * Print DAQ chronometer.
   *
   * \param  out           output stream
   * \param  chronometer   JDAQChronometer
   * \return               output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQChronometer& chronometer)
  {
    using namespace std;

    out << setw(8) << chronometer.getRunNumber();
    out << ' ';
    out << setw(8) << chronometer.getFrameIndex();
    
    return out;
  }


  /**
   * Get time of last RTS in ns since start of run for a given chronometer.
   *
   * \param  chronometer  chronometer
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const JDAQChronometer& chronometer)
  {
    return getTimeOfRTS(chronometer.getFrameIndex());
  }
}

#endif