////////////////////////////////////////////////////////////////////////
/// \class RAT::DQTellieProc
///
/// \brief   Data quality TELLIE processor
///
/// \authors James Waterfield <jw419@sussex.ac.uk>
//
///
/// REVISION HISTORY:
///   - 2014 11 26 - Matt Strait - Doxygen fixes
//    - 2016 06 14 - Mark Stringer - Fixes to handle multiple subruns in data
///   - 2016 07 20 - M. Mottram - Update for ROOT6 compatibility
//    - 2016 11 30 - Mark Stringer (James Waterfield) Changes to code made by James Waterfield for his Thesis, also removal of hardcoded values.
//    - 2017 02 08 - Mark Stringer - Bug Fixes to DB output and changing the filenames of the output images. Removal of the hardcoded trigger bit value
//                                   replaced with a value from DQCHECKS.ratdb
///
/// \details Checks TELLIE specific calibration runs.
///  Trigger efficiency, run length, NHit, fibre fired
///  time profiles are all checked by this processor.
///
////////////////////////////////////////////////////////////////////////

#ifndef __RAT_DQTellieProc__
#define __RAT_DQTellieProc__

#include <RAT/Processor.hh>
#include <RAT/DataQualityProc.hh>
#include <RAT/DB.hh>
#include <RAT/DBLink.hh>
#include <RAT/DU/PMTInfo.hh>
#include <RAT/DS/UniversalTime.hh>
#include <sstream>
class TH1D;
class TH1I;
class TVector3;
class TVector2;

#include <vector>

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

namespace RAT
{
  class DQTellieProc : public DataQualityProc
  {
  public:

    DQTellieProc();

    virtual ~DQTellieProc();

    ///
    /// @param[in] run DS::Run location in data structure
    virtual void BeginOfRun( DS::Run& run );
    /// Access event in run
    ///
    /// @param[in] run DS::Run location in data structure
    /// @param[in] ds  DS::Entry location in data structure
    virtual Processor::Result DSEvent( DS::Run& run, DS::Entry& ds );
    ///
    /// @param[in] run DS::Run location in data structure
    virtual void EndOfRun( DS::Run& run );

  protected:
    /// Checks hits of 2 PMTs on same panel to ensure
    /// maxPMT is not hot
    ///
    /// @param[in] maxPMT int LCN of highest hit PMT
    /// @return true = pmt is hot; fale pmt is not hot.
    virtual bool CheckNeighbours(int subRunIndex ,int maxPMT);
    /// @param[in] ds  DS::Entry location in data structure
    /// @param[in] ev  DS::EV  event location in data structure
    virtual Processor::Result Event( DS::Entry& ds, DS::EV& ev );
    /// Produces .png of PSUP projection hit map
    ///
    /// @param[in] directProject TVector2 central direct light spot on PSUP.
    /// @param[in] reflectedProject TVector2 central reflected light spot on PSUP.
    /// @param[in] lightOriginProject TVector2 calculated light origin on PSUP.
    virtual void PlotFibreCheck(const TVector2& directProject,const TVector2& reflectedProject,const  TVector2& lightOriginProject,int subRunIndex);
    /// Checks the correct fibre is firing.
    ///
    virtual void FibreCheck(int subRunIndex);
    /// Plots the time profile of the run (TAC ADC)
    ///
    /// @param[in] xPeaks std::vector<float> tac ADC of time peaks
    virtual void PlotTac(std::vector<float> xPeaks,int subRunIndex);
    /// Iterate over v to find its max and min values and assign min_idx and\n
    /// max index their relavent values.
    ///
    /// @param[in] v std::vector<float> vector to check min/max values
    /// @param[in] min_idx size_t index of minimum value of v
    /// @param[in] max_idx size_t index of maximum value of v
    virtual void MinMaxIndex(std::vector<float> v, size_t& min_idx, size_t& max_idx);
    /// Checks time profile of TAC
    ///
    virtual void TimingChecks(int subRunIndex);


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

    double fTrigCheckThresh; ///<percentage required to pass trigger check

    std::vector<int> fTellieCount; ///<counts TELLIE events
    std::vector<int> fTellieEvents; ///<number of pulses sent to TELLIE

    unsigned int fMinRunLength; ///<minimum run length

    std::vector<int> fFailPulseDelayCount; ///<counts number of events which have too large delay between them
    double fPulseDelayTol; ///<% Tolerance between the actual pulse frequency and the pulse frequency in the couchDB
    double fPulseDelayThresh; ///<percentage required to pass pulse delay check
    double fPulseDelayMin;
    double fPulseDelayMax;
    double fTellieChipDelay;
    double fTACPromptHeightRatio; ///<Ratio between prompt TAC peak height and reflected light TAC height
    double fTACPromptPeakLowerLimit; ///<Lower limit of the TAC value for the prompt peak
    double fTACPromptPeakUpperLimit; ///<Upper limit of the TAC value for the prompt peak
    double  fTACReflectedOffsetLower; ///< Smaller bound on offset between prompt TAC peak and reflected TAC peak
    double  fTACReflectedOffsetUpper; ///< Larger bound on offset between prompt TAC peak and reflected TAC peak
    int fTriggerBit; ///<Trigger bit for TELLIE events



    std::vector<DS::UniversalTime> fFirstEventTime; ///<time of first event for each subrun
    std::vector<DS::UniversalTime> fLastEventTime; ///<time of last event
    std::vector<DS::UniversalTime> fPrevEventTime; ///<time of previous event
    std::vector<DS::UniversalTime>fCurEventTime; ///<time of current event

    std::vector<int> fTelliePulseRate;

    std::vector<bool> fFirstEventTimeSet; ///<indicates first event time set
    std::vector<bool> fFirstTellieEventTimeSet; ///<indicates first TELLIE event time set

    int fMaxNHit; ///<maximum NHit allowed for run
    std::vector<int> fFailMaxNHitCount; ///<counts number that are above max NHit

    std::vector<double> fAvgNHit; ///<average NHit for the subrun
    double fMaxAvgNHit; ///<maximum allowed average NHit for the run

    std::vector<int> fSubRunNumbers; ///Array of the subrun numbers
    std::vector<std::string> fFibres; ///<List of Fibres used in run
    std::vector<std::string> fFibreFiringGuess; ///<Calculated fibre firing
    std::vector<int> fNPeaks;
    std::vector<double> fPromptPeakADCCount;
    std::vector<double> fPrePeakADCCount;
    std::vector<double> fLatePeakADCCount;
    std::vector<double> fSubRunLengths;
    std::vector<double> fPulseDelayEfficiency;

    std::vector<int> fPeakNumberCheck;
    std::vector<int> fPromptPeakADCCountCheck;
    std::vector<int> fPromptPeakAmplitudeCheck;
    std::vector<int> fPeakTimeSpacingCheck;
    std::vector<int> fTriggerCheck;
    std::vector<int> fSubRunLengthsCheck;
    std::vector<int> fPulseDelayEfficiencyCheck;
    std::vector<int> fMaxNHitCheck;
    std::vector<int> fAvgNHitCheck;
    std::vector<int> fCorrectFibreCheck;




    std::vector<std::vector<int> > fHitCount; ///<stores pmt hits
    std::vector<TH1D*> fTH1DLcnHits; ///<histogram of PMT hits vs. lcn
    std::vector<TH1D*> fTH1DTacCount; ///<time profile of run (TAC ADC)
    std::vector<TH1D*> fTH1DTacCountDirect; ///<time profile of run (TAC ADC)
    std::vector<TH1D*> fTH1DTacCountReflected; ///<time profile of run (TAC ADC)
    std::vector<TH1D*> fTH1DCalibTime; ///<time profile of run (ns)
    std::vector<TH2D*> fTH2DPsupProjection; ///<psup projection hit map
    std::vector<TH1I*> fTH1INHits; ///<histograms storing NHits for each subrun
    std::vector<TVector3*> fFibrePositions;
  };

}// namespace RAT


#endif // DQTellieProc