#include <cmath>
#include <math.h>
#include <algorithm>
#include <vector>
#include <RAT/EventBuilderProc.hh>
#include <RAT/TriggerPulse.hh>
#include <RAT/TriggerSum.hh>
#include <RAT/DS/MCHit.hh>
#include <RAT/DS/MCPMT.hh>
#include <RAT/DS/EV.hh>
#include <RAT/DU/Utility.hh>
#include <RAT/DU/PMTInfo.hh>
#include <RAT/DB.hh>
#include <RAT/Log.hh>
#include <CLHEP/Random/RandGauss.h>
#include <CLHEP/Random/RandGeneral.h>
#include <CLHEP/Random/RandFlat.h>
#include <G4ThreeVector.hh>
#include <CLHEP/Units/SystemOfUnits.h>
#include <iostream>
using namespace CLHEP;

namespace RAT {

EventBuilderProc::EventBuilderProc() : Processor("EventBuilder"), fLdaq(0),fTriggerGateDB(0),fTriggerDelayDB(0),fFECDelay(0),fGTDelay(0),fCountPEs(false)
{

}


EventBuilderProc::~EventBuilderProc()
{
}

void EventBuilderProc::BeginOfRun(DS::Run &run) {
  fUnCal.BeginOfRun(run);
  fLdaq = DB::Get()->GetLink("DAQ");

  // delay of channel info from FE elec
  fFECDelay = fLdaq->GetD("triggerfecdelay");
  //delay of global trigger back to Front End
  fGTDelay = fLdaq->GetD("gtriggerdelay");
  fStore = fLdaq->GetZ("store_all_hits");

  fTriggerDelayDB = fFECDelay + fGTDelay;

  //width of trigger gate to collect hits
  fTriggerGateDB = fLdaq->GetD("triggergate");

  detail << "EventBuilderProc: Trigger constants loaded" << newline;
  detail << dformat(" Trigger Delay: %5.2f + %5.2f = %5.2f ns \n",fFECDelay, fGTDelay, fTriggerDelayDB);
  detail << dformat(" Trigger Gate:  %5.2f ns \n", fTriggerGateDB);

}

void EventBuilderProc::EndOfRun(DS::Run &run) {
  fUnCal.EndOfRun(run);
}

void EventBuilderProc::SetI( const string& param, const int value ) {
    if( param == string( "countpe" ) ) {
        fCountPEs = (value==1);
    }
}

EventBuilderProc::Result EventBuilderProc::DSEvent(DS::Run& run, DS::Entry& ds)
{

  // -- First check that the MC branch does exist. In case of real data it won't exist
  // Of course, I have no idea why people would run this processor on real data, but
  // better safe than sorry
  if (!run.GetMCFlag()) {
    warn << "EventBuilderProc::DSEvent : There is no MC branch for this Run. Most likely this is real data. Aborting..." << newline;
    warn << "EventBuilderProc::DSEvent : Check the options in your macro, and your input file." << newline;
    return Processor::ABORT;
  }

  DS::MC& mc = ds.GetMC();
  const DU::PMTInfo& pmtInfo = DU::Utility::Get()->GetPMTInfo();
  if( fCountPEs) {
    // This section is intended to be executed only with the GenPMTEff event
    // generator, which generates events initiated with a photon at the face of
    // each PMT.  It counts the number of PMTs with a photoelectron for which
    // the beginning of the track of the photon that produced the photoelectron
    // is within a small distance of the PMT position (the center of the PMT
    // face).  I.e., the photon that generated the photoelectron was created at
    // the face of the PMT that had the PE.

    double rConc = RAT::DB::Get()->GetLink( "CONCENTRATOR", "cRAT" )->
            GetDArray("rho_coord").back(); // Outer radius of concentrator
    Int_t nDirect = 0;
    // No. of PMTs with at least one photoelectron:
    Int_t nPEPMTs = mc.GetMCPMTCount();
    for(Int_t i=0; i<nPEPMTs; i++) {
        RAT::DS::MCPMT& refPEPMT = mc.GetMCPMT(i);
        UInt_t idPEPMT  = refPEPMT.GetID();
        TVector3 pmtPos = pmtInfo.GetPosition( idPEPMT );

        UInt_t nPE = refPEPMT.GetMCPECount(); // no. PEs in this PMT
        for(UInt_t j=0; j<nPE; j++) {
            UInt_t idTrk = refPEPMT.GetMCPE(j).GetPhotonTrackID();
            DS::MCTrack& refTrk = mc.GetMCTrack(idTrk);
            //  The first step specifies the origin of the track,
            //  and has zero length.
            RAT::DS::MCTrackStep& refFirstStep = refTrk.GetMCTrackStep(0);
            const TVector3 photonOrigin = refFirstStep.GetPosition();

            double separation = (pmtPos-photonOrigin).Mag();
            if(separation<1.1*rConc) nDirect++;
        }
    }
    mc.SetNumDirPE(nDirect);
  }     // if( fCcountPEs)

  //**********************************************************************
  // Right now this is the list of all MCHits (and they are
  // currently all set as normal tubes to make sorting easier)
  DS::MCHits originalMCHits = mc.GetUnbuiltMCHits();
  // We now empty the original and will add the real untrigger mchits to it
  DS::MCHits& untriggeredMCHits = mc.GetUnbuiltMCHits();
  untriggeredMCHits.PruneAllPMTs();

  std::vector<double> totalQs;
  for (size_t iev=0;iev<ds.GetEVCount();iev++){
    totalQs.push_back(0);
  }

  // loop over hits
  for (size_t i=0;i<originalMCHits.GetAllCount();i++){
    DS::MCHit mchit = originalMCHits.GetAllPMT(i);
    double hitTime = mchit.GetTime();
    DU::PMTInfo::EPMTType type = pmtInfo.GetType(mchit.GetID());

    int triggered = 0;
    for (size_t iev=0;iev<ds.GetEVCount();iev++){
      DS::MCEV& mcev = ds.GetMCEV(iev);
      double TriggerStopTime = mcev.GetGTTime() + fGTDelay;
      if (hitTime < TriggerStopTime && (TriggerStopTime-hitTime) < fTriggerGateDB){
        triggered = 1;

        // Generate random cell ID
        UShort_t cell = (UShort_t)(16*CLHEP::RandFlat::shoot());
        if(cell>15)cell=15;
        mchit.SetCellID(cell);
        totalQs[iev] += mchit.GetQHS(); //use QHS for this
        mcev.GetMCHits().AddPMT( mchit, type );
        break;
      }
    }
    // If fStore is set to true, we store all the MCHits in the
    // 'mcUnbuiltHits'. This can be useful when trying to look
    // at the trigger information, where one wants to look at all
    // hits for events the triggered and did not trigger the detector.
    if (!triggered || fStore){
      untriggeredMCHits.AddPMT( mchit, type );
    }
  }

  for (size_t iev=0;iev<ds.GetEVCount();iev++){
    DS::EV &ev = ds.GetEV(iev);
    DS::MCEV &mcev = ds.GetMCEV(iev);
    ev.SetTotalCharge(totalQs[iev]);
    double TriggerStopTime = mcev.GetGTTime() + fGTDelay;

    // Uncalibrate AND DIGITISE this event
    fUnCal.SetRun(run);
    fUnCal.UnCalibrateEvent(ds,iev,TriggerStopTime);

  } //end loop over triggers
  return OK;
}

// Handle FATAL errors
void EventBuilderProc::Die(std::string message, int flag_err, int info1, int info2, int return_code)
{
  warn << RED << "EventBuilder PROBLEM:" << CLR << newline;

  if(flag_err==1){ // NHit != 0
    warn<<"PMT ID "<<info2<<" has "<<info1<<" samples within a single trigger"<<newline;
    warn<<"This sample occurred at "<<message<<"ns before the GT"<<newline;
    warn<<"Something is wrong."<<newline;
    warn<<newline;
  }
  // This should not be here. It would be better to use Log::Die, since that gives a cleaner exit, no?
  Log::Die("Something went wrong with EventBuilderProc");
}


} // namespace RAT