#ifndef _mevt_ModuleRecData_h_
#define _mevt_ModuleRecData_h_

#include <utl/ErrorLogger.h>
#include <utl/Trace.h>
#include <utl/TimeStamp.h>
#include <utl/ShadowPtr.h>

namespace mevt {

  class Module;

  /**
   * \class ModuleRecData ModuleRecData.h "mevt/ModuleRecData.h"
   * \brief Module level reconstruction data.
   * This class contains all data required by the muon reconstruction
   *
   * \author Rodolfo Federico Gamarra
   * \author Diego Ravignani
   * \date 08 Mar 2009
   * \date 09 Mar 2015
   * \ingroup mevt
   */
  class ModuleRecData {

  public:
  /**
   * \brief Number of windows with a signal in a module
   *
   * Windows on corresponds to the time time bin that has been labelled as containing a signal  
   * Not to be confused with the number of muons that can be higher due to the pile-up of muons 
   * in a single window
   *
   * Non-modifying accessor.
   */
    utl::TraceUI& GetChannelsOn();
    const utl::TraceUI& GetChannelsOn() const;
    void MakeChannelsOn();
    bool HasChannelsOn() const;

    unsigned int GetNumberOfChannelsOn() const;
    unsigned int GetMaxChannelsOn() const;

    bool IsEmpty() const {return GetMaxChannelsOn()==0;}
    bool IsGood() const {return 0<GetMaxChannelsOn() && GetMaxChannelsOn()<fSegmentation;}
    bool IsSaturated() const {return GetMaxChannelsOn()==fSegmentation;} 

    /**
     * \brief Return user defined saturation limit.
     *
     *  This flag may be different from IsSaturated() returned value which 
     *  controls the "hardware" module saturation (non-recoverable) imposed
     *  by the 64 bars segmentation. In turns, this flag is set and used by 
     *  the LDF fitting procedure and may be lower than segmentation if desired.
     */
    void SetSaturationFlag(const bool satFlag) {fSaturationFlag = satFlag;}
    bool SaturationFlag() const {return fSaturationFlag;}

    /**
     * \brief Return the timestamp associated with the start of the ChannelsOn trace.
     *
     * The timestamp of the first bin of the trace. The start time was made an optional field
     * to deal with situations when it cannnot be set for some problem like the GPS data of the 
     * SD station associated to this module cannot be retrieved. Furthermore it must be possible to
     * check if this field is present or not. A shadow pointer for the time stamp was implemented 
     * to cater for this requirement.
     */
    utl::TimeStamp GetChannelsOnStartTime() const {return *fChannelsOnStartTime;}
    /**
     * \brief Sets the timestamp associated with the start of the ChannelsOn trace.
     */ 
    void SetChannelsOnStartTime (const utl::TimeStamp& t) {fChannelsOnStartTime = new utl::TimeStamp(t);}
    /**
     * \brief Check for the presence of the time stamp
     */     
    bool HasChannelsOnStartTime() const {return fChannelsOnStartTime;}


  /**
   * \brief Number of estimated muons in a module
   *
   * The number of muons estimated in the module usually computed as a maximum likelihood estimator.
   * The estimated number of muons is not a correction as interpreted originally but some function
   * of the "windows on" in each time bin. The function to set the estimated number of muons is left
   * to the user code, this class just implements a data holder. 
   * 
   */

    void SetNumberOfEstimatedMuons(const double m) { fNumberOfEstimatedMuons=m; }
    double GetNumberOfEstimatedMuons() const { return fNumberOfEstimatedMuons; }

    void SetNumberOfMuonsErrorHigh(const double e) { fNumberOfMuonsErrorHigh=e; }
    double GetNumberOfMuonsErrorHigh() const { return fNumberOfMuonsErrorHigh; }    

    void SetNumberOfMuonsErrorLow(const double e) { fNumberOfMuonsErrorLow=e; }
    double GetNumberOfMuonsErrorLow() const { return fNumberOfMuonsErrorLow; }

  /**
   * \brief The lower limit to the number of muons in a module
   *
   * The low limit of muons provides a valid option to the minimum bound to muons
   * specially useful for saturated modules, where the number of muons and therefore
   * the error bars size are infinite
   *
   */  
    void SetNumberOfMuonsLowLimit(const double e) { fNumberOfMuonsLowLimit=e; }
    double GetNumberOfMuonsLowLimit() const { return fNumberOfMuonsLowLimit; }

    void SetActiveArea(const double area) {fActiveArea = area;}
    double GetActiveArea() const {return fActiveArea;}

  /**  The denstiy is calculated as the number of estimated muons divided by the active area of 
   *   the module. Note that the density in the detector plane is provided here. It has to be 
   *   divided by the cosine of the zenith angle to pass it to the shower plane as needed by the 
   *   lateral distribution function. This conversion has to be done in the calling code since
   *   the detector does not know about zenith angles.
   */

    double GetMuonDensity() const { return fNumberOfEstimatedMuons/fActiveArea; }
    double GetMuonDensityErrorHigh() const { return fNumberOfMuonsErrorHigh/fActiveArea; }
    double GetMuonDensityErrorLow() const { return fNumberOfMuonsErrorLow/fActiveArea; }     

    void SetSegmentation( size_t nm ) { fSegmentation = nm; }
    size_t GetSegmentation() const { return fSegmentation; }

    void SetWindowSize( unsigned int ws ) { fWindowSize = ws; }
    unsigned int GetWindowSize() const { return fWindowSize; }

    void SetLDFResidual(const double LDFresidual) { fLDFResidual = LDFresidual; }    
    double GetLDFResidual() const { return fLDFResidual; }

    // Methods to access the pattern matches vector
    const std::vector<double>& GetPatternMatchTimes() const {return fPatternMatchTimes;}
    std::vector<double>& GetPatternMatchTimes() {return fPatternMatchTimes;}
    void AddPatternMatchTime(double t) {fPatternMatchTimes.push_back(t);}

  private:

    ModuleRecData();
    ~ModuleRecData() { }
   
   /**
   * \brief The module detection area
   *
   * The detection area is used here. It correspond to the sum of the areas of the working 
   * channels. The detection area is less than the module nominal area if there are
   * faulty channels in the event. 
   */   
    double fActiveArea; 
  /* 
   *   Number of scintillator with a signal per time window
   *   from this field the numbers of windows on and estimated muons are calculated 
   */  
    utl::ShadowPtr<utl::TraceUI> fChannelsOn;
    utl::ShadowPtr<utl::TimeStamp> fChannelsOnStartTime;

  /**
   * \brief The pattern match times vector stores the times of all 
   *  matches in the module found by the counting algorithm. In the case of 
   *  few matches this is a proxy for the number of muons, for larger signals
   *  the pile-up has to be considered. Times are measured in nanoseconds from the
   *  trace start.   
   */ 
    std::vector<double> fPatternMatchTimes;

     size_t fSegmentation;
   // Length of the inhibition window in number of bins of a channel trace  
     unsigned int fWindowSize;
     double fLDFResidual;
     bool fSaturationFlag;
     double fNumberOfEstimatedMuons;
     double fNumberOfMuonsErrorHigh;
     double fNumberOfMuonsErrorLow;
     double fNumberOfMuonsLowLimit;

  /*
   * Like sevt::StationRecData nothing said about
   * operator= and copy-construction: let the compiler
   * generate'em.
   */   
  /**
   * \brief Friendship to allow construction.
   */ 
    friend class Module;
  /**
   * \brief Frienship to allow destruction.
   *
   * Depends on the innards of mevt::Module.
   */
    friend class utl::ShadowPtr<ModuleRecData>;
  };

}

#endif