#ifndef _fevt_ChannelRecData_h_
#define _fevt_ChannelRecData_h_

#include <utl/ShadowPtr.h>
#include <utl/Trace.h>
#include <utl/MultiTrace.h>

#include <fevt/FdConstants.h>

#include <set>

namespace fevt {

  /*! 
    \class ChannelRecData ChannelRecData.h "fevt/ChannelRecData.h"
    \brief Fluorescence Detector Channel Reconstructed Data Event
    
    \author Ralf Ulrich
    \date Fri Apr 28 04:25:19 ART 2006
    \version $Id: ChannelRecData.h 16182 2010-04-13 18:43:29Z rulrich $	 
    \author Viviana Scherini 15.05.06 added tools for saturation recovery
    \ingroup fevt
  **/

  class ChannelRecData {

  public:
    /** Reconstructed FADC trace */
    utl::TraceI& GetFADCTrace(const FdConstants::LightSource source = FdConstants::eTotal)
    { return fFADCTrace->GetTrace(source); }
    const utl::TraceI& GetFADCTrace(const FdConstants::LightSource source = FdConstants::eTotal) const
    { return fFADCTrace->GetTrace(source); }

    /**   Add a source of Type Telescope::LightSource
     *   /example AddSource(Telescope::eDirect); */
    void MakeFADCTrace(unsigned int size, double binning,
		       const FdConstants::LightSource source= FdConstants::eTotal);
    void MakeFADCTrace(const utl::TraceI& t,
		       const FdConstants::LightSource source= FdConstants::eTotal);
        
    /// Check that source /par source is present
    bool HasFADCTrace(const FdConstants::LightSource source) const
    { return fFADCTrace->HasLabel(source); }
    
    /** An iterator over the available FADC trace sources.
	Returns a pair<int,TraceI *> when dereferenced */
    typedef utl::MultiTraceI::Iterator FADCTraceIterator;
    typedef utl::MultiTraceI::ConstIterator ConstFADCTraceIterator;

    /// First std::pair<int source, TraceD* trace>
    FADCTraceIterator FADCTracesBegin() { return fFADCTrace->Begin(); }
    ConstFADCTraceIterator FADCTracesBegin() const { return fFADCTrace->Begin(); }

    /// Last std::pair<int source, TraceD* trace>
    FADCTraceIterator FADCTracesEnd() { return fFADCTrace->End(); }
    ConstFADCTraceIterator FADCTracesEnd() const { return fFADCTrace->End(); }

    /// \brief check saturation flag for this channel
    bool ChannelIsSaturated() const { return fIsSaturated; }
    /// \brief set saturation flag for this channel
    void SetChannelSaturated() { fIsSaturated = true; }

    /// \brief set first saturated bin for this channel
    void SetFirstSatBin(const int fsb) { fFirstSatBin = fsb; }
    /// \brief set last saturated bin for this channel
    void SetLastSatBin(const int lsb) { fLastSatBin = lsb; }

    /// \brief find first saturated bin for this channel
    int GetFirstSatBin() const { return fFirstSatBin; }
    /// \brief find last saturated bin for this channel
    int GetLastSatBin() const { return fLastSatBin; }
    
    /// Check if bin is (low gain) saturated
    bool IsSaturated(const int bin) const { return bin>=fFirstSatBin && bin<=fLastSatBin; }
    
    /// Add one de-saturated bin to this trace
    void AddDeSaturatedBin(const int bin);
    /// Check if bin is de-saturated
    bool IsDeSaturated(const int bin) const;
    
    /// \brief set baseline
    void SetBaseLine(double baseline) { fBaseLine = baseline; }
    /// \brief get baseline
    double GetBaseLine() const { return fBaseLine; }

  private:
    /// \brief default ctor: ensure fIsSaturated flag is set to false
    ChannelRecData() :
      fBaseLine(0.),
      fIsSaturated(false),
      fFirstSatBin(0),
      fLastSatBin(0)
    { }

    ~ChannelRecData() { }

    utl::InitializedShadowPtr<utl::MultiTraceI> fFADCTrace;

    friend class Channel;
    friend class utl::ShadowPtr<ChannelRecData>;

    double fBaseLine;
    bool fIsSaturated;
    int fFirstSatBin;
    int fLastSatBin;

    std::set<unsigned int> fDeSaturedBins;
  };

}

#endif