#include <string>
#include <iostream>
#include <iomanip>

#include "TRandom3.h"

#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/online/JDAQTimeslice.hh"

#include "JTimeslice/JEventTimeslice.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorSimulator.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JPMTParametersMap.hh"
#include "JDetector/JK40DefaultSimulator.hh"
#include "JDetector/JPMTDefaultSimulator.hh"
#include "JDetector/JCLBDefaultSimulator.hh"
#include "JTrigger/JBuildL1.hh"
#include "JTrigger/JTrigger3DShower.hh"
#include "JTrigger/JTriggerParameters.hh"
#include "JTrigger/JTimesliceRouter.hh"
#include "JTrigger/JTriggerBits.hh"
#include "JTrigger/JTriggeredEvent.hh"
#include "JTrigger/JEventOverlap.hh"
#include "JTrigger/JEventToolkit.hh"
#include "JTrigger/JSummaryRouter.hh"
#include "JTrigger/JK40RunByRunSimulator.hh"
#include "JTrigger/JPMTRunByRunSimulator.hh"
#include "JTrigger/JCLBRunByRunSimulator.hh"
#include "JDAQ/JHighRateVeto.hh"

#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"


namespace {

  using namespace JPP;

  /**
   * Auxiliary class to generate background for specific module.
   */
  class JK40Simulator_t :
    public JK40DefaultSimulatorInterface
  {
  public:
    /**
     * Constructor.
     *
     * \param  module          module
     * \param  R_Hz            singles rate [Hz]
     */
    JK40Simulator_t(const int module, const double R_Hz) :
      module(module),
      R_Hz(R_Hz)
    {}

    /**
     * Get singles rate as a function of PMT.
     *
     * \param  pmt             PMT identifier
     * \return                 rate [Hz]
     */
    virtual double getSinglesRate(const JPMTIdentifier& pmt) const
    {
      if (pmt.getModuleID() == this->module)
        return R_Hz;
      else
        return 0.0;
    }

    /**
     * Get multiples rate as a function of optical module.
     *
     * \param  module          optical module identifier
     * \param  M               multiplicity (M >= 2)
     * \return                 rate [Hz]
     */
    virtual double getMultiplesRate(const JModuleIdentifier& module, const int M) const
    {
      return 0.0;
    }

    /**
     * Get probability of coincidence.
     *
     * \param  ct              cosine space angle between PMT axes
     * \return                 probability
     */
    virtual double getProbability(const double ct) const
    {
      return 0.0;
    }

    int    module;
    double R_Hz;
  };
}


/**
 * \file
 * Test program for snapshot data.
 *
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;

  UInt_t   seed;
  int      debug;

  try { 

    JParser<> zap("Test program for snapshot data.");
    
    zap['S'] = make_field(seed)                = 0;
    zap['d'] = make_field(debug)               = 3;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }

  gRandom->SetSeed(seed);


  const double QE = 0.5;
  
  JDetector detector;

  detector.setVersion(JDetectorVersion::V3);

  detector.push_back(getModule<JKM3NeT_t>(1000));
  detector.push_back(getModule<JKM3NeT_t>(2000));

  // set object identifiers

  for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
    for (JModule::iterator pmt = module->begin(); pmt != module->end(); ++pmt) {
      pmt->setID(module->getID() + pmt->getID());
    }
  }

  const JModuleRouter moduleRouter(detector);

  JDetectorSimulator  simbad(detector);
  JSummaryRouter      summaryRouter;
  JPMTParametersMap   pmtParameters;

  pmtParameters.setQE(QE);
  
  DEBUG(detector);

  JTriggerParameters  parameters;

  parameters.trigger3DShower.enabled         = true;
  parameters.trigger3DShower.numberOfHits    = 1;
  parameters.trigger3DShower.numberOfModules = 1;
  parameters.TMaxEvent_ns                    = 100.0e3;

  parameters.set(getMaximalDistance(detector));

  DEBUG(parameters);


  // create summary data

  const double rate_Hz = 2 * HIGH_RATE_VETO_HZ;

  try {
    simbad.reset(new JK40Simulator_t(detector[1].getID(), rate_Hz));
    simbad.reset(new JPMTDefaultSimulatorInterface());
    simbad.reset(new JCLBDefaultSimulator());
  }
  catch(const JException& error) {
    FATAL(error.what() << endl);
  }

  JSummaryslice summary(JDAQChronometer(), simbad);

  if (debug >= debug_t) {
    summary.print(cout, true);
  }

  summaryRouter.update(&summary);

  try {    
    simbad.reset(new JK40RunByRunSimulator(summaryRouter, 0.0));
    simbad.reset(new JPMTRunByRunSimulator(summaryRouter, pmtParameters, detector));
    simbad.reset(new JCLBRunByRunSimulator(summaryRouter));
  }
  catch(const JException& error) {
    FATAL(error.what() << endl);
  }
  
  summaryRouter.correct(dynamic_cast<const JPMTDefaultSimulatorInterface&>(simbad.getPMTSimulator()));

  const JTimeRange period(-parameters.TMaxEvent_ns,
			  +parameters.TMaxEvent_ns);

  ASSERT(rate_Hz * period.getLength() * NUMBER_OF_PMTS > 100, "Estimated number of background hits.");

  const int run         = 1;
  const int frame_index = 1;


  const double T_ns[] = { 0.5 * (getMaximalTime(rate_Hz) + 0.0),                  // w/o  high-rate veto
			  0.5 * (getMaximalTime(rate_Hz) + getFrameTime()) };     // with high-rate veto

  // generate events

  vector<Evt> enigma;

  for (int i = 0; i != sizeof(T_ns)/sizeof(T_ns[0]); ++i) {

    for (size_t module = 0; module != detector.size(); ++module) {

      enigma.push_back(Evt());

      enigma.rbegin()->mc_t = getTimeOfFrame(frame_index)  +  T_ns[i];

      for (JModule::const_iterator pmt = detector[module].begin(); pmt != detector[module].end(); ++pmt) {

	Hit hit;

	hit.id      =  enigma.rbegin()->mc_hits.size() + 1;
	hit.pmt_id  =  pmt->getID();
	hit.t       =  0.0;
	hit.a       =  1.0;

	enigma.rbegin()->mc_hits.push_back(hit);
      }
    }
  }


  typedef JSuperFrame1D<double>   JSuperFrame1D_t;
  typedef JSuperFrame2D<double>   JSuperFrame2D_t;
  typedef JTimeslice   <double>   JTimeslice_t;

  JBuildL1<double>  buildL1(parameters);

  JTimesliceRouter  timesliceRouter(parameters.numberOfBins);

  const JTrigger3DShower trigger3DShower(parameters);


  for (size_t i = 0; i != enigma.size(); ++i) {

    DEBUG("Test " << i << endl);

    const Evt& evt = enigma[i];

    const JDAQChronometer chronometer(detector.getID(), run, frame_index, JDAQUTCExtended(getTimeOfFrame(frame_index)));

    const JEventTimeslice timeslice(chronometer, simbad, evt, period);

    DEBUG(timeslice);

    timesliceRouter.configure(timeslice);

    JTimeslice_t timesliceL1(timeslice.getDAQChronometer());

    for (JDAQTimeslice::const_iterator frame = timeslice.begin(); frame != timeslice.end(); ++frame) {

      const JModule&   module = moduleRouter.getModule(frame->getModuleID());

      JSuperFrame2D_t& buffer = JSuperFrame2D_t::demultiplex(*frame, module);

      timesliceL1.push_back(JSuperFrame1D_t(frame->getDAQChronometer(),
					    frame->getModuleIdentifier(),
					    module.getPosition()));
      
      buildL1(JSuperFrame1D_t::multiplex(buffer), back_inserter(*timesliceL1.rbegin()));
    }

    JTriggerInput  trigger_input(timesliceL1);
    JTriggerOutput trigger_output;

    trigger3DShower(trigger_input, back_inserter(trigger_output));

    trigger_output.merge(JEventOverlap(parameters.TMaxEvent_ns));


    DEBUG("Number of events " << trigger_output.size() << endl);

    switch (i) {

    case 0:         // first  half of time slice
      ASSERT(trigger_output.size() == 1, "Number of events");
      break;

    case 1:         // first  half of time slice
      ASSERT(trigger_output.size() == 0, "Number of events");
      break;

    case 2:         // second half of time slice
      ASSERT(trigger_output.size() == 1, "Number of events");
      break;

    case 3:         // second half of time slice
      ASSERT(trigger_output.size() == 0, "Number of events");
      break;
    }


    for (JTriggerOutput::const_iterator event = trigger_output.begin(); event != trigger_output.end(); ++event) {

      ASSERT(JTimeRange(evt.mc_t - parameters.TMaxEvent_ns, 
			evt.mc_t + parameters.TMaxEvent_ns).overlap(getTimeRange(*event)));

      const JTriggeredEvent tev(*event,
				timesliceRouter,
				moduleRouter,
				parameters.TMaxLocal_ns,
				getTimeRange(parameters));
      
      map<int, int> zmap;

      for (JDAQEvent::const_iterator<JDAQSnapshotHit> hit = tev.begin<JDAQSnapshotHit>(); hit != tev.end<JDAQSnapshotHit>(); ++hit) {
	zmap[hit->getModuleID()] += 1;
      }

      switch (i) {

      case 0:         // first  half of time slice
	ASSERT(zmap[detector[0].getID()] != 0, "Number of signal hits.");
	ASSERT(zmap[detector[1].getID()] != 0, "Number of background hits.");
	break;

      case 1:
	FATAL("Ghost event.");

      case 2:         // second half of time slice
	ASSERT(zmap[detector[0].getID()] != 0, "Number of signal hits.");
	ASSERT(zmap[detector[1].getID()] == 0, "Number of background hits.");
	break;

      case 3:
	FATAL("Ghost event.");
      }
    }
  }

  return 0;
}