/**
 * @file
 * @author Christian Simon <csimon@physi.uni-heidelberg.de>
 * @since 2017-06-19
 */

#ifndef CBMTOFCOUNTER_H
#define CBMTOFCOUNTER_H 1

#include "Rtypes.h"
#include "TString.h"

#include <vector>
#include <map>

// Both gsl_min_fminimizer and gsl_root_fsolver are typedef'ed anonymous structs
// and can thus not be forward declared.
#include <gsl/gsl_min.h>
#include <gsl/gsl_roots.h>

class CbmTofSignalBuffer;
class CbmTofDigiTbPar;
class CbmTofPoint;
class CbmTofDigiExp;
class CbmTofHit;

class TGeoNode;
class TGeoPhysicalNode;

class TH1D;

typedef struct gsl_function_struct gsl_function;


/**
 * @brief ...
 * @author Christian Simon <csimon@physi.uni-heidelberg.de>
 * @since 2017-06-19
 * @version 1.0
 * @details ...
 */
class CbmTofCounter
{
  public:

    CbmTofCounter(Int_t iModuleType, Int_t iModuleIndex, Int_t iCounterIndex);

    virtual ~CbmTofCounter();

    const Int_t& GetModuleType() const {return fiModuleType;}
    const Int_t& GetModuleIndex() const {return fiModuleIndex;}
    const Int_t& GetCounterIndex() const {return fiCounterIndex;}
    const Int_t& GetCounterAddress() const {return fiCounterAddress;}
    const char* GetCentralNodePath() const {return fCentralNodePath.Data();}
    const TGeoNode* GetCounterNode() const {return fCounterNode;}
    const Bool_t& IsPadReadout() const {return fbPadReadout;}
    const Int_t& GetNumberReadoutElectrodes() const {return fiNumberReadoutElectrodes;}
    const Double_t& GetCellAcrossWidth() const {return fdCellAcrossWidth;}
    const Double_t& GetCellAlongWidth() const {return fdCellAlongWidth;}
    const Bool_t& GetCellsAlongX() const {return fbCellsAlongX;}
    const Int_t& GetNWalkBinsX() const {return fiNWalkBinsX;}
    const Double_t& GetMinimumToT() const {return fdMinimumToT;}
    const Double_t& GetMaximumToT() const {return fdMaximumToT;}
    const Double_t& GetPropagationVelocity() const {return fdPropagationVelocity;}
    const Double_t& GetRelaxationTimeConstant() const {return fdRelaxationTimeConstant;}
    const Double_t& GetCounterDarkRate() const {return fdCounterDarkRate;}
    const Double_t& GetAcrossPositionResidualSigma() const {return fdAcrossPositionResidualSigma;}
    const Double_t& GetAlongPositionResidualSigma() const {return fdAlongPositionResidualSigma;}
    const Double_t& GetTimeResidualSigma() const {return fdTimeResidualSigma;}

    void SetModuleType(Int_t iModuleType) {fiModuleType = iModuleType;}
    void SetModuleIndex(Int_t iModuleIndex) {fiModuleIndex = iModuleIndex;}
    void SetCounterIndex(Int_t iCounterIndex) {fiCounterIndex = iCounterIndex;}
    void SetCounterAddress(Int_t iCounterAddress) {fiCounterAddress = iCounterAddress;}
    void SetCentralNodePath(const char* cNodePath) {fCentralNodePath = cNodePath;}
    void SetBoxNodePath(const char* cNodePath) {fBoxNodePath = cNodePath;}
    void SetCounterNode(TGeoNode* tNode) {fCounterNode = tNode;}
    void SetSendChargesToMemory(Bool_t bMemory = kTRUE) {fbSendChargesToMemory = bMemory;}
    void SetCalibrateDigis(Bool_t bCalibration = kTRUE) {fbCalibrateDigis = bCalibration;}
    void SetToTWeights(Bool_t bWeights = kTRUE) {fbToTWeights = bWeights;}
    void SetEventTimeOffset(Double_t dOffset);
    void SetFileIndex(Int_t iIndex) {fiFileIndex = iIndex;}

    void MasterToLocal(const Double_t* dMasterCoordinates, Double_t* dLocalCoordinates) const;
    void LocalToMaster(const Double_t* dLocalCoordinates, Double_t* dMasterCoordinates) const;

    void MasterToLocalBox(const Double_t* dMasterCoordinates, Double_t* dLocalCoordinates) const;
    void LocalToMasterBox(const Double_t* dLocalCoordinates, Double_t* dMasterCoordinates) const;

    Bool_t IsContainedInBox(const Double_t* dLocalCoordinates) const;

    Bool_t Initialize(const CbmTofDigiTbPar* tTofDigiTbParSet);
    void ProcessPoint(const CbmTofPoint* tTofPoint);
    Int_t ReadOutChannelBuffers(Double_t dReadoutTime);

    void BuildClusterMC(std::vector<std::pair<CbmTofDigiExp*, Int_t>>& tDigiVector, CbmTofHit* tHit, Bool_t bCompatibilityMode);

    Int_t GenerateDarkRate(Double_t dStopTime);

    Double_t DistributeCharge(const Double_t& dTotalCharge, const Double_t& dChargeDistance,
                              const Double_t& dX1, const Double_t& dX2, const Double_t& dY1, const Double_t& dY2);
    Double_t ChargeLimit(const Double_t& dChargeDistance, const Double_t& dX1, const Double_t& dX2,
                         const Double_t& dY1, const Double_t& dY2);

    static Double_t NegativeLandau(Double_t x, void* params);
    static Double_t LandauThreshold(Double_t x, void* params);
    static Double_t LandauSignal(Double_t x, void* params);

    static void SetEnforceTwoSidedReadout(Bool_t bTwoSided = kTRUE) {fbEnforceTwoSidedReadout = bTwoSided;}
    static void SetIgnoreSignalInterference(Bool_t bIgnore = kTRUE) {fbIgnoreSignalInterference = bIgnore;}
    static void SetIgnoreChannelDeadTime(Bool_t bIgnore = kTRUE) {fbIgnoreChannelDeadTime = bIgnore;}

  protected:

  private:

    CbmTofCounter(const CbmTofCounter&);

    CbmTofCounter& operator=(const CbmTofCounter&);

    Int_t fiModuleType;
    Int_t fiModuleIndex;
    Int_t fiCounterIndex;
    Int_t fiCounterAddress;
    TString fCentralNodePath;
    TString fBoxNodePath;
    TGeoNode* fCounterNode; // not owned by this class!!!
    TGeoPhysicalNode* fCentralPN;
    TGeoPhysicalNode* fBoxPN;
    Bool_t fbPadReadout;
    Int_t fiNumberReadoutElectrodes;
    Double_t fdCellAcrossWidth;
    Double_t fdCellAlongWidth;
    Double_t fdGapAcrossWidth;
    Double_t fdGapAlongWidth;
    Bool_t fbCellsAlongX;
    Bool_t fbCellIndexingAlongAxis;
    Int_t fiNWalkBinsX;
    Double_t fdWalkBinWidth;
    Double_t fdMinimumToT;
    Double_t fdMaximumToT;
    Double_t fdSignalTimeOffset;
    Double_t fdPropagationVelocity;
    Double_t fdDigitizationJitterSigma;
    Double_t fdMaximumRuntimeOffset;
    Double_t fdToTTargetExpectationValue;
    Double_t fdToTTargetStandardDeviation;
    Double_t fdSignalEdgeRuntimeOffsetsSigma;
    Int_t fiMaximumClusterSize;
    Double_t fdChargeModus;
    Double_t fdChargeScaling;
    Double_t fdChargeDistance;
    Double_t fdDiscriminationJitterSigma;
    Double_t fdSignalTimeConstant;
    Double_t fdSignalThreshold;
    Double_t fdStripToTOffset;
    Double_t fdAvalancheJitterSigma;
    std::vector<Double_t> fdToTDistributionScaling;
    std::vector<Double_t> fdToTDistributionOffset;
    std::vector<Double_t> fdRuntimeCorrections;
    std::vector<std::vector<Double_t>> fdSlewingCorrections;
    std::vector<Double_t> fdRuntimeOffsets;
    std::vector<Double_t> fdSignalEdgeRuntimeOffsets;
    Double_t fdAcrossPositionResidualSigma;
    Double_t fdAlongPositionResidualSigma;
    Double_t fdTimeResidualSigma;
    Double_t fdHitDistanceScale;
    Double_t fdRelaxationTimeConstant;
    Double_t fdChannelDeadTime;
    Double_t fdCounterDarkRate;
    Double_t fdCalibrationCoefficient;
    Double_t fdWorkingCoefficient;
    Double_t fdLastDarkPointTime;
    Double_t fdMeanDarkPointInterval;
    Double_t fdEventTimeOffset;
    Bool_t fbTwoSidedReadout;
    Bool_t fbSendChargesToMemory;
    Bool_t fbCalibrateDigis;
    Double_t fdSignalParameters[4];
    gsl_function* fFindIntersection;
    gsl_function* fFindSlope;
    gsl_min_fminimizer* fMinimizer;
    gsl_root_fsolver* fRootFinder;
    Double_t fdLandauSignalMPV;
    Double_t fdChargeSamplingLimit;
    CbmTofSignalBuffer* fSignalBuffer;
    std::vector<Double_t> fdLastLeadingEdgeTime;
    std::vector<Double_t> fdLastTrailingEdgeTime;
    Bool_t fbToTWeights;
    Int_t fiDigiIndex;
    std::vector<std::map<Int_t, Double_t>> fDigiUnmergedLeadingEdgeToT;
    std::vector<Double_t> fdHitTimeContributions;
    Int_t fiFileIndex;

    static Bool_t fbEnforceTwoSidedReadout;
    static Bool_t fbIgnoreSignalInterference;
    static Bool_t fbIgnoreChannelDeadTime;

    ClassDef(CbmTofCounter,0)
};

#endif