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

#ifndef CBMTOFMEMORY_H
#define CBMTOFMEMORY_H 1

#include "Rtypes.h"
#include "TMutex.h"
#include "TCondition.h"

#include <map>
#include <vector>

class CbmTofCounter;
class CbmTofCharge;
class TThread;

/**
 * @brief Optionally multi-threaded memory buffer for CbmTofCharge objects.
 * @author Christian Simon <csimon@physi.uni-heidelberg.de>
 * @since 2017-06-01
 * @version 1.0
 * @details ...
 */
class CbmTofMemory
{
  public:

    virtual ~CbmTofMemory();

    static CbmTofMemory* Instance();

    void ClearMemory();

    Double_t GetMemoryCoefficient(const Int_t& iAddress, const Double_t& dCharge, const Double_t& dTime, const Double_t& dAcrossPosition,
                                  const Double_t& dAlongPosition, const Double_t& dDistanceScale, const Double_t& dTimeConstant, const Double_t& dChargeLimit);

    void Initialize(const std::map<Int_t,CbmTofCounter*>& CounterMap);

    void SetNThreads(Int_t iNThreads);
    void SetRemoveHitsFromMemory(Bool_t bRemove) {fbRemoveHitsFromMemory = bRemove;}
    void SetHitRemovalCriterion(Double_t dCriterion) {fdHitRemovalCriterion = dCriterion;}

    void Finish();

  protected:
  
  private:

    CbmTofMemory();

    CbmTofMemory(const CbmTofMemory&);

    CbmTofMemory& operator=(const CbmTofMemory&);

    static void cleanup(void* arg);
    static void* process(void* arg);

    static CbmTofMemory* fgInstance;
    static const Int_t fiMaximumNThreads = 55;
    static Int_t fiThreadIndices[fiMaximumNThreads];
    static TMutex fDoMutex;
    static TCondition fDoSummation;
    static TMutex fFinishedMutex;
    static TCondition fFinishedSummation;
    static Bool_t fbNoSummation[fiMaximumNThreads];
    static Bool_t fbNotFinished;
    static Double_t fdCurrentMemoryCoefficient;
    static Double_t fdCurrentMCHitTime;
    static Double_t fdCurrentMCAcrossStripPosition;
    static Double_t fdCurrentMCAlongStripPosition;
    static std::vector<std::vector<CbmTofCharge>>* fCurrentCounterMemory;
    static Bool_t fbRemoveHitsFromMemory;
    static Double_t fdHitRemovalCriterion;
    static Int_t fiActualNThreads;
    static Int_t fiFinishedThreads;
    static Double_t fdChargeSamplingLimit;
    static Double_t fdHitDistanceScale;
    static Double_t fdRelaxationTimeConstant;
    std::map<Int_t, std::vector<std::vector<CbmTofCharge>>> fCounterMemory;
    std::map<Int_t, Int_t> fiNCounterHits;
    std::vector<TThread*> fThreadPool;
    Bool_t fbRunMultiThreaded;
    Bool_t fbIsInitialized;

    ClassDef(CbmTofMemory,1)
};

#endif