#ifndef __JTRIGGERPARAMETERS__
#define __JTRIGGERPARAMETERS__

#include <istream>
#include <ostream>
#include <limits>

#include <TROOT.h>
#include <TObject.h>

#include "JROOT/JRoot.hh"
#include "JTools/JConstants.hh"

#include "JTrigger/JTrigger3DShower.hh"
#include "JTrigger/JTrigger3DMuon.hh"

#ifndef __CINT__
#include "JDetector/JTimeRange.hh"
#include "JROOT/JRootStreamer.hh"
#endif


namespace JTRIGGER {

  namespace {
    using JSIRENE::JTimeRange;
    using JTOOLS::getInverseSpeedOfLight;
    using JTOOLS::getIndexOfRefraction;
  }


  /**
   * Data structure for all trigger parameters.
   */
  class JTriggerParameters :
    public TObject
  {
  public:
    /**
     * Default constructor.
     */
    JTriggerParameters()
    {
      reset();
    }


    /**
     * Virtual destructor.
     */
    virtual ~JTriggerParameters()
    {}


    /**
     * Set detector dependent trigger parameters.
     *
     * \param  DMax_m          maximal distance between PMTs [m]
     */
    void set(const double DMax_m)
    {
      TMaxEvent_ns           = DMax_m * getIndexOfRefraction() * getInverseSpeedOfLight();
      trigger3DMuon.DMax_m   = DMax_m;
    }


    /**
     * Reset trigger parameters.
     */
    void reset()
    {
      trigger3DShower.reset();
      trigger3DMuon  .reset();

      highRateVeto_Hz = numeric_limits<double>::max();
      L2Min           =    2;
      ctMin           =   -1.0;
      TMaxLocal_ns    =   10.0;
      TMaxEvent_ns    = 5000.0;
      numberOfBins    = 1000;
      writeSummary    = true;
      writeL1         = false;
      writeTimeslices = false;
    }


    /**
     * Type conversion operators.
     */
    inline operator JTrigger3DShower::JParameters() const  { return trigger3DShower; }  //!< JTrigger3DShower parameters
    inline operator JTrigger3DMuon::JParameters()   const  { return trigger3DMuon; }    //!< JTrigger3DMuon   parameters


#ifndef __CINT__
    /**
     * Get time range of snapshot.
     *
     * \return            time range [ns]
     */
    JTimeRange getTimeRange() const
    {
      return JTimeRange(-TMaxEvent_ns, +TMaxEvent_ns);
    }


    /**
     * Read trigger parameters from input.
     *
     * \param  in         input stream
     * \param  parameters JTriggerParameters
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTriggerParameters& parameters)
    {
      JROOT::JRootStreamer::getInstance().read(in, parameters);

      return in;
    }


    /**
     * Write trigger parameters to output.
     *
     * \param  out        output stream
     * \param  parameters JTriggerParameters
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTriggerParameters& parameters)
    {
      JROOT::JRootStreamer::getInstance().write(out, parameters);

      return out;
    }
#endif

    ClassDef(JTriggerParameters,2);


    // Trigger specific parameters

    JTrigger3DShower::JParameters trigger3DShower;
    JTrigger3DMuon::JParameters   trigger3DMuon;


    // Global parameters

    double highRateVeto_Hz;    // high-rate veto [Hz]
    int    L2Min;              // minimal number of L0 hits for L2 
    double ctMin;              // minimal cosine angle    between PMT axes for L2
    double TMaxLocal_ns;       // maximal time difference between L0  hits for L1
    double TMaxEvent_ns;       // maximal time before and after event for snapshot
    int    numberOfBins;       // number of bins for lookup table of timeslice
    bool   writeSummary;       // write JDAQSummaryslice
    bool   writeL1;            // write JDAQTimeslice with L1 data
    bool   writeTimeslices;    // write JDAQTimeslices
  };
}

#endif