////////////////////////////////////////////////////////////////////////
/// \class RAT::DQTellieProc
///
/// \brief   Data quality TELLIE processor
///
/// \authors Martti Nirkko <m.nirkko@sussex.ac.uk> (since 2017)
///
/// 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
///   - 2019 01 29 - Martti Nirkko - Significant makeover, improved many plots and DQ checks
///
/// \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>
class TGraph2D;
class TH1D;
class TH1I;
class TVector3;
class TVector2;

#include <algorithm>
#include <sstream>
#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:
    /// @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 std::vector<TVector2>& directCircle, const std::vector<TVector2>& reflectedCircle, const TVector2& assumedFibreProject, const TVector2& actualFibreProject, const string& assumedFibre, int subRunIndex);
    /// Checks the correct fibre is firing.
    ///
    virtual void FibreCheck(int subRunIndex);

    // Fills PMT hemisphere around a certain point into a TGraph
    ///
    virtual void FillHemisphere(const TVector3& center, std::vector<float> &occupancy, TGraph2D* graph);

    /// Fits intansity profile with 2D Gaussian
    ///
    virtual void FitLightSpot(TGraph2D* graph, double radius, double cone, double* params);

    /// Checks whether the fibre is affected by belly plates
    ///
    virtual bool CheckBellyPlate(int subRunIndex);

    /// Draw a circle around a point in a plane orthogonal to an angle with N dots
    virtual void DrawCircle(const TVector3&, double, std::vector<TVector2>&, int);

    /// Gets rotation angles to transfer one 3D frame to another
    virtual void GetRotationAngles(const TVector3&, double&, double&);

    /// Display vector as a string
    virtual string printVector(const TVector3& v);

    /// 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
    /// max_idx to their corresponding indices.
    ///
    /// @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);
    /// Iterate over v to find its top 3 peaks
    virtual void GetTopIndices(std::vector<float> x, std::vector<float> y, size_t& early, size_t& prompt, size_t& late);
    /// 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> fTellieEvents; ///<number of pulses sent to TELLIE
    std::vector<int> fTellieCount; ///<counts TELLIE events
    std::vector<int> fStolenTriggerCount; ///<counts events stolen by other triggers
    std::vector<DS::EV> fStolenEvents; ///<events stolen by other triggers
    std::vector<DS::EV> fRecoveredEvents; ///<recovered events that were stolen
    int fMaxStolenTriggers; ///<maximum allowed consecutive stolen triggers

    unsigned int fMinRunLength; ///<minimum run length

    std::vector<int> fFailPulseSeparationCount; ///<counts number of events which have too large separation
    double fPulseSeparationThresh; ///<percentage required to pass pulse separation check
    double fPulseSeparationMin;
    double fPulseSeparationMax;
    double fTellieChipDelay;
    double fTACPromptHeightRatio; ///<Ratio between prompt TAC peak height and reflected light TAC height
    double fTACPromptHeightThresh; ///<Threshold ratio between potential and maximum prompt peak
    double fTACReflectedHeightThresh; ///<Threshold ratio between potential and maximum reflected peak
    double fTACPromptSigmaThresh; ///<Threshold width for prompt peaks
    double fTACReflectedSigmaThresh; ///<Threshold width for reflected peaks
    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 fTACEarlyOffsetLower;///< Lower bound on offset between prompt and early TAC peaks
    double fTACEarlyOffsetUpper;///< Upper bound on offset between prompt and early TAC peaks
    double fTACLateOffsetLower;///< Lower bound on offset between prompt and late TAC peaks
    double fTACLateOffsetUpper;///< Upper bound on offset between prompt and late TAC peaks
    int fTriggerBit; ///<Trigger bit for TELLIE events

    // Tick counts from 50 MHz clock
    std::vector<ULong64_t> fFirstEventClock50;
    std::vector<ULong64_t> fLastEventClock50;
    std::vector<ULong64_t> fPrevEXTAClock50;
    std::vector<ULong64_t> fCurEventClock50;
    std::vector<ULong64_t> fNomEventClock50;

    // Tick counts from 10 MHz clock
    std::vector<ULong64_t> fFirstEventClock10;
    std::vector<ULong64_t> fLastEventClock10;
    std::vector<ULong64_t> fPrevEXTAClock10;
    std::vector<ULong64_t> fCurEventClock10;
    std::vector<ULong64_t> fNomEventClock10;

    // Whether first event in subrun was set
    std::vector<bool> fNomEventClockSet;

    // Universal time (using 10 MHz clock?)
    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> fPrevEXTATime; ///<time of previous EXTA 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

    int fLastSubRunIndex;
    std::vector<int> fSubRunNumbers; ///Array of the subrun numbers
    std::vector<std::string> fRunMode; /// Run mode (Master/Slave)
    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> fPulseSeparationEfficiency;

    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> fPulseSeparationEfficiencyCheck;
    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<TH1D*> fTH1DPulseSeparationUT; ///<time profile of pulse separations (s)
    std::vector<TH1D*> fTH1DPulseSeparation50; ///<time profile of pulse separations (s)
    std::vector<TH1D*> fTH1DPulseSeparation10; ///<time profile of pulse separations (s)
    std::vector<TH1D*> fTH1DPulseSeparationStolen; ///<time profile of stolen pulse separations (s)
    std::vector<TH2D*> fTH2DPsupProjection; ///<psup projection hit map
    std::vector<TH2D*> fTH2DPsupOffline; ///<psup projection offline PMTs
    std::vector<TH1I*> fTH1IAllNHits; ///<histograms storing all NHits for each subrun
    std::vector<TH1I*> fTH1IExtaNHits; ///<histograms storing EXTA-NHits for each subrun
    std::vector<TVector3*> fFibrePositions;
  };

}// namespace RAT


#endif // DQTellieProc