////////////////////////////////////////////////////////////////////////
/// \class RAT::DQTimeProc
///
/// \brief Data quality timing processor
///
/// \author Ashley R. Back <ab571@sussex.ac.uk>
///
/// REVISION HISTORY:\n
///   2014-11-28 : <a.r.back@qmul.ac.uk> - Updated for FTB processing
///   2016-01-28 : <ms711@sussex.ac.uk> - Added check between the 10Mhz clock and the Universal time.
///   2017-11-17 : <mm679@sussex.ac.uk> - Added extra parameters to be saved in the ratdb tables.
/// \details Executes all the data quality checks concerned with timing\n
///         and event rates. Calculates the event separation (delta-t)\n
///         between events and checks, for each, that it is positive\n
///         and greater than the trigger window. Also calculates the\n
///         average event rate, over the full run.
///
////////////////////////////////////////////////////////////////////////
#ifndef __RAT_DQTimeProc__
#define __RAT_DQTimeProc__

class TH1D;

#include <RAT/Processor.hh>
#include <RAT/DataQualityProc.hh>
#include <RAT/DS/UniversalTime.hh>
#include <RAT/DB.hh>
#include <RAT/DBLink.hh>

namespace RAT
{
  namespace DS
  {
    class Run;
    class Entry;
    class EV;
  }
}

#include <vector>

namespace RAT
{

  class DQTimeProc : public DataQualityProc
  {
  public:

    DQTimeProc();

    virtual ~DQTimeProc();

    virtual void BeginOfRun( DS::Run& run );

    struct TimingData
    {
      int fGTID; ///<to record GTID
      double fEventTime; ///<to record the timestamp (ns) for this event
      double fCount50DeltaT; ///<delta-t calculated from 50 MHz clock counts
      bool fFlagSeismic; ///<to flag seismic events (false by default)
      bool fFlagPGT; ///<to flag pulsedGT (PMT Noise) events (false by default)
      bool fFlagBubbler; ///<to flag bubbler events (false by default)
    };

    virtual Processor::Result DSEvent( DS::Run& run, DS::Entry& ds );

    virtual Processor::Result Event( DS::Entry& ds, DS::EV& ev );

    virtual void EndOfRun( DS::Run& run );

    unsigned long int DateTo10MhzClockTicks(DS::UniversalTime);

  private:
    TH1D* fPositiveDeltaTHist; ///<histogram of all positive delta-ts
    TH1D* fTrigWindowDeltaTHist; ///<histogram of delta-t around 400ns
    TH1D* fNegativeDeltaTHist; ///<histogram of all negative delta-ts
    TH1D* fNegativeDeltaGTIDHist; ///<histogram of GTID decrease delta-t
    TH1D* fCount10ResetDeltaTHist; ///<histogram of 10 MHz reset delta-ts
    TH1D* fCount50ResetDeltaTHist; ///<histogram of 50 MHz reset delta-ts
    TH1I * fUniversalTimeClockCountHist; ///<histogram of difference between calculated clock time from universal time and actual 10Mhz Clock time

    bool fFirstEvent; ///<first event marker
    double fPreviousEventTime; ///<timestamp for previous event
    unsigned long int fPreviousCount10; ///<10 MHz oscillator count at previous event
    unsigned long int fPreviousCount50; ///<50 MHz oscillator count at previous event
    int fPreviousGTID; ///<GTID of previous event
    int fNegativeDeltaTCount; ///<counter for negative delta-t
    int fNegativeDeltaGTIDCount; ///<counter for out of sync GTIDs
    int fCount10Resets; ///<counter for 10 MHz oscillator resets
    int fCount50Resets; ///<counter for 50 MHz oscillator resets
    int fTriggerWindowDeltaTCount; ///<counter for delta-t within trigger window
    int fRetriggerDeltaTCount; ///<counter for potential re-trigger delta-ts

    DBLinkPtr fDQChecks; ///<link to RATDB "DQCHECKS" table

    double fRunHeaderThresh; ///<Run Header Threshold from DQCHECKS
    double fClockForwardThresh; ///<Clock Forward Threshold from DQCHECKS
    double fEventSeparationThresh; ///<Event Separation Threshold from DQCHECKS
    double fRetriggersThresh; ///<Retriggers THreshold from DQCHECKS
    double fRoughCheckThresh; ///<Rough Check Threshold from DQCHECKS
    double fMinEventRate; ///<Minimum Event Rate from DQCHECKS
    double fMaxEventRate; ///<Maximum Event Rate from DQCHECKS

    bool f10MhzTimeCheck; ///<Check for universal time and 10Mhz Clock comp
    int f10MhzTimeCheckFails;

    double fFirstEventTime;

    std::vector<TimingData> fTimingDataRecords;
  };

}// namespace RAT

#endif // __RAT_DQTimeProc__