////////////////////////////////////////////////////////////////////////
///
/// \class RAT::Classifiers::AlphaBetaClassifier
///
/// \brief Classify an event to be a Te130 0vbb or a BiPo beta+alpha pile-up
///        based on likelihood ratio
///
/// \author name Eric Marzec <marzece@sas.upenn.edu>
/// \author name Ziping Ye <zipingye@sas.upenn.edu> contact person
///
/// REVISION HISTORY:\n
///   - 2014/01/14 : Eric Marzec - New file
///   - 2015/04/15 : M Mottram: optimised method (assumes equal binning
///                  in time and energy).
///   - 2020/07/29 : Meng Luo - added nhit cut feature
///   - 2022/08/25 : Ziping Ye - added retrigger events for classification
///   - 2022/10/01 : Ziping Ye - added more FOMs
///
/// \details Calculates the likelihood for an event to be either a BiPo beta+alpha pile-up
///          or a Te130 two beta event, and returns the log( likelihood-ratio )
///
///          The retrigger event of any N100HI triggered event is also taken into account
///
////////////////////////////////////////////////////////////////////////

#ifndef __RAT_Classifiers_AlphaBetaClassifier_
#define __RAT_Classifiers_AlphaBetaClassifier_

#include <RAT/OptimisedClassifier.hh>
#include <RAT/SeededClassifier.hh>
#include <RAT/DS/UniversalTime.hh>
#include <RAT/DU/TimeResidualCalculator.hh>
#include <RAT/FitterPMT.hh>

namespace RAT
{

namespace DS
{
  class FitResult;
}

namespace Classifiers
{

  class AlphaBetaClassifier : public OptimisedClassifier, public SeededClassifier
{

public:

  // Constructor, constructs object, allocates fLastEventUTime and fNHitCut
  AlphaBetaClassifier();

  // Destructor, destructs object, frees fLastEventUTime and fNHitCut
  virtual ~AlphaBetaClassifier();

  virtual std::string
  GetName() const  { return AlphaBetaClassifier::Name(); }

  static std::string
  Name() { return std::string( "AlphaBetaClassifier" ); }

  void Initialise( const std::string& param );

  void BeginOfRun( DS::Run& run );

  void EndOfRun( DS::Run& run );

  void DefaultSeed();

  void SetSeed(const DS::FitResult& seed);

  void SetI( const std::string& name, const int value );

  // void SetSeed(const DS::FitResult& seed);

  virtual std::vector<double> GetParams() const;

  virtual std::vector<double> GetPositiveErrors() const;

  virtual std::vector<double> GetNegativeErrors() const;

  virtual double operator() (const std::vector<double>& params);

  virtual void SetParams( const std::vector<double>& params);

  virtual void SetPositiveErrors( const std::vector<double>& errors);

  virtual void SetNegativeErrors( const std::vector<double>& errors);

  virtual DS::ClassifierResult
  GetClassification();

private:

  std::vector<double> fTimeResiduals;
  std::vector<double> fTimes, fBetaProbability, fAlphaProbability, fTwoBetaProbability;
  double fTimeStep;
  int fTimeStep_N;
  std::vector<double> fEnergies, fEnergyProbability;
  double fEnergyStep;
  int fEnergyStep_N;
  std::vector<double> fDeltaT, fDeltaTProbability;
  double fDeltaTStep;
  int fDeltaTStep_N;
  std::vector<double> fParams;
  std::vector<double> fPositiveErrors,fNegativeErrors;
  double fMinValue;
  std::string fIndex; ///< Optional index override
  bool fFitHypothesis; ///< This acts as a switch for fitting under a two beta hypothesis or a BiPo one.
  DU::Point3D fEventPos;
  double fEventTime;
  unsigned int fNHit; /// number of hits, sum over normal and retrigger events
  bool fRetrigger; /// true if the event is an automatic retrigger
  RAT::DS::UniversalTime fRetriggerCutoff; /// cutoff determining whether an event is a retrigger event
  RAT::DS::UniversalTime *fLastEventUTime; /// pointer to the time of the last event
  DU::Point3D fLastEventPos; /// fitted position of the last event
  double fLastEventTime;
  unsigned int fLastEventNHit;
  double fRetriggerDelayedTime;
  double fRetriggerCutoffD;
  ULong64_t fRollOverClock50;
  ULong64_t fLastEventUTimeClock50;
  double fLastEventTimeDifference;
  std::vector<FitterPMT> fLastEventPMTData;
  std::vector<FitterPMT> fAllPMTData;

  DU::TimeResidualCalculator fTRCalc;
  size_t fPSUPSystemId; // coordinate system id for Point3D

protected:

  size_t fNHitCut;

};

} //::Classifier

} //::RAT

#endif