//#include <iostream>
#include "musrCounter.hh"
#include "TCanvas.h"

typedef std::map<int,int> debugEventMapType;
debugEventMapType debugEventMap;
Bool_t bool_debugingRequired;

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

musrCounter::musrCounter(int CHANNEL_NR, char CHANNEL_NAME[200], char CHANNEL_TYPE, float E_THRESH, int TIME_SHIFT) {
  //  pointerToAnalysis=this;
  counterNr = CHANNEL_NR;
  strcpy(counterName,CHANNEL_NAME);
  counterType = CHANNEL_TYPE;
  couterEThreshold = E_THRESH;
  counterTimeShift = (Long64_t) TIME_SHIFT;
  std::cout<<"musrCounter::musrCounter: Creating counter "<<counterNr<<"  "<<counterName<<"  "<<counterType<<"  "<<couterEThreshold<<" "<<counterTimeShift<<std::endl;
  strcpy(TDC_histoName,"Unset");
  TDC_t0=0;
  TDC_t1=0;
  TDC_t2=0;
  TDC_histoNrAdd=0;
  antiCoincidenceTimeWindowMin=0;
  antiCoincidenceTimeWindowMax=0;
  coincidenceTimeWindowMin_M=0;
  coincidenceTimeWindowMax_M=0;
  coincidenceTimeWindowMin_P=0;
  coincidenceTimeWindowMax_P=0;
  maxCoincidenceTimeWindow=0;
  strcpy(TDC_histoNameAdd,"Unset");
  doubleHitN=0;
  numberOfMuonCandidates=0;
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

musrCounter::~musrCounter() {}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void musrCounter::SetTDChistogram(char hName[200],int t0,int t1,int t2,int hNr,char hNameAdd[200]) {
  strcpy(TDC_histoName,hName);
  TDC_t0=t0;
  TDC_t1=t1;
  TDC_t2=t2;
  TDC_histoNrAdd=hNr;
  strcpy(TDC_histoNameAdd,hNameAdd);
  std::cout<<"TDC_histogram: "<<TDC_histoName<<" "<<TDC_t0<<" "<<TDC_t1<<" "<<TDC_t2<<" "<<TDC_histoNrAdd<<" "<<TDC_histoNameAdd<<std::endl;
  histTDC = new TH1D(TDC_histoName,TDC_histoName,t2,0.,float(t2));
}
//================================================================
void musrCounter::FillTDChistogram(Double_t variable, Double_t vaha) {
  histTDC->Fill(variable,vaha);
}

//================================================================
void musrCounter::DrawTDChistogram() {
  char canvasName[501]; 
  sprintf(canvasName,"c%s",TDC_histoName);
  TCanvas* cTmp = new TCanvas(canvasName,canvasName);
  histTDC->Draw();
}

//================================================================
void musrCounter::FillHitInCounter(Double_t edep, Long64_t timeBin, Long64_t timeBin2, Int_t kEntry, Int_t eveID, Int_t iDet, Int_t detectorID){
  //cDEL  std::cout<<"FillHitInCounter: timeBin="<<timeBin<<"   timeBin2="<<timeBin2<<"    counterTimeShift="<< counterTimeShift<<std::endl;
  //cDEL  std::cout<<"                                                FillHitInCounter  I: timeBin-counterTimeShift="<<timeBin-counterTimeShift<<"   timeBin2-counterTimeShift="<<timeBin2-counterTimeShift<<std::endl;
  //  std::cout<<"musrCounter::FillHitInCounter:"<<counterNr<<std::endl;
  if (edep>=couterEThreshold) {

    hitInfo* hInfo = new hitInfo(kEntry,eveID,iDet,detectorID,edep,timeBin2-counterTimeShift);
    //cDEL    std::cout<<detectorID<<"                                                FillHitInCounter II: timeBin-counterTimeShift="<<timeBin-counterTimeShift<<"   timeBin2-counterTimeShift="<<timeBin2-counterTimeShift<<std::endl;
    hitMap.insert( std::pair<Long64_t,hitInfo*>(timeBin-counterTimeShift,hInfo) );
  }
}

//================================================================
void musrCounter::RemoveHitsInCounter(Long64_t timeBinLimit) {
  // Remove the obsolete hits (i.e. hits that happaned well before t0) from the Counter class
  if (hitMap.empty()) return;
  //  myPrintThisCounter();
  //  if (counterNr==1) {std::cout<<"ooooo1  timeBinLimit="<<timeBinLimit<<std::endl;  myPrintThisCounter();}
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {
    //    std::cout<<"  musrCounter::RemoveHitsInCounter:  counterNr="<<counterNr<<"  timeBinLimit="<<timeBinLimit<<"  maxCoincidenceTimeWindow="<<maxCoincidenceTimeWindow<<"    counterTimeShift="<<counterTimeShift<<std::endl;
    if ((it->first)>(timeBinLimit+maxCoincidenceTimeWindow-counterTimeShift)) return;  //note that maxCoincidenceTimeWindow is usually negative number
    else {
      //      std::cout<<"       Deleting hit from counter "<<counterNr<<",  time bin = "<<(it->first)<<std::endl;
      delete (it->second);
      hitMap.erase(it);
    }
  }
  //  if (counterNr==1) {std::cout<<"ooooo2"<<std::endl;  myPrintThisCounter();}
}

//================================================================
void musrCounter::RewindHitsInCounter(Long64_t timeBinsToRewind) {
  // Reset time in hits from the Counter class
  if (hitMap.empty()) return;
  
  hitMap_TYPE hitMap_TMP;
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {
    //    std::cout<<"musrCounter::RewindHitsInCounter: "<<std::endl;
    Long64_t tempBinT   = it->first;
    //    int    tempEvnr= it->second;
    //    hitMap_TMP.insert( std::pair<Long64_t,int>(tempBinT-timeBinsToRewind,tempEvnr) );
    hitInfo* tempEvnr= it->second;
    tempEvnr->RewindTimeBin2(timeBinsToRewind);
    hitMap_TMP.insert( std::pair<Long64_t,hitInfo*>(tempBinT-timeBinsToRewind,tempEvnr) );
  }
  hitMap.swap(hitMap_TMP);
}

//================================================================
Bool_t musrCounter::IsInCoincidence(Long64_t timeBin, char motherCounter, Bool_t ignoreHitsAtBinZero, Long64_t timeBinMinimum, Long64_t timeBinMaximum){
  // timeBin ... time bin, at which the coincidence is searched
  // counterTimeShiftOfRequestingCounter  ... time shift (in bin units) of the counter, for which the coincidence is searched
  // ignoreHitsAtBinZero  ... if "true", hits at timeBin will be ignored (needed for searching of coincidence of M counter 
  //                                     with other M counters  or P counters with other P counters)
  //                             "false" should be used for coincidence detectors and vetos.
  if (hitMap.empty()) return false;
  //  Long64_t timeBinToTest = timeBin;
  Long64_t timeBinMin;
  Long64_t timeBinMax;

  // If timeBinMinimum and timeBinMaximum are not specified, use internal time window of the detector (koincidence or veto detectors).
  // Otherwise use timeBinMinimum and timeBinMaximum (e.g.coincidence of a positron counter with other positron counters).
  if (timeBinMinimum!=-123456789)  timeBinMin = timeBin + timeBinMinimum;               // time window requested through "timeBinMinimum"
  else if (counterType == 'V')     timeBinMin = timeBin + antiCoincidenceTimeWindowMin; // this is veto detector
  else if (motherCounter=='M')     timeBinMin = timeBin + coincidenceTimeWindowMin_M;   // this is coinc. detector (or M counter) connected to M
  else if (motherCounter=='P')     timeBinMin = timeBin + coincidenceTimeWindowMin_P;   // this is coinc. detector connected to P

  if (timeBinMaximum!=-123456789)  timeBinMax = timeBin + timeBinMaximum;               // time window requested through "timeBinMinimum"
  else if (counterType == 'V')     timeBinMax = timeBin + antiCoincidenceTimeWindowMax; // this is veto detector
  else if (motherCounter=='M')     timeBinMax = timeBin + coincidenceTimeWindowMax_M;   // this is coinc. detector (or M counter) connected to M
  else if (motherCounter=='P')     timeBinMax = timeBin + coincidenceTimeWindowMax_P;   // this is coinc. detector connected to P

  //  Long64_t timeBinMin = (timeBinMinimum==-123456789) ? timeBin + coincidenceTimeWindowMin : timeBin + timeBinMinimum;
  //  Long64_t timeBinMax = (timeBinMaximum==-123456789) ? timeBin + coincidenceTimeWindowMax : timeBin + timeBinMaximum;
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {
    Long64_t timeBinOfCount_tmp = it->first;
    if ((timeBinOfCount_tmp >= timeBinMin) && (timeBinOfCount_tmp <= timeBinMax)) {
      if ((timeBin!=timeBinOfCount_tmp)||(!ignoreHitsAtBinZero)) {
	return true;
      }
    }
    else if (timeBinOfCount_tmp > timeBinMax) return false;
  }
  return false;
}

//================================================================
Bool_t musrCounter::GetNextGoodMuon(Int_t evtID, Long64_t timeBinMin, Long64_t& timeBinOfNextHit, Int_t& kEntry, Int_t& idet, Int_t& idetID, Double_t& idetEdep, Bool_t& doubleHitFound) {
  // This function searches for a good muon, i.e. the muon 
  //         1) belongs to the currently analysed event
  //         2) is in coincidence with all required coincidence detectors
  //         3) is not in coincidence with veto detectors
  //         4) is not in coincidence with other muons (more precisely - with hits in m-counter).
  // INPUT PARAMETERS:  evtID, timeBinMin
  // OUTPUT PARAMETERS: timeBinOfNextHit
  //
  // Loop over the hits in the counter
  //  std::cout<<" musrCounter::GetNextGoodMuon    timeBinMin="<<timeBinMin<<std::endl;
  if (hitMap.empty()) return false;
  if (counterType!='M') {std::cout<<"\n!!! FATAL ERROR !!! musrCounter::GetNextGoodMuon: not the muon counter! ==> S T O P !!!\n"; exit(1);}
  doubleHitFound = false;
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {

    Long64_t timeBinOfCount_tmp = it->first;
    timeBinOfNextHit = timeBinOfCount_tmp;
    if (timeBinOfCount_tmp <= timeBinMin) continue;   // This hit was already processed previously ==> skip it

    Int_t    eventNumber = (it->second)->eventIDnumber;
    if (eventNumber!=evtID) continue;          // This trigger hit does not correspond to the currently processed event
                                               //  ==> skip it, becuase it was already proceesed or will be processed in future
    numberOfMuonCandidates++;
    //    std::cout<<"*** "<<evtID<<"   eventNumber="<<eventNumber<<"   canditas="<<numberOfMuonCandidates<<std::endl;
    // Hit candidate was found.  Now check its coincidences and vetos
    for (counterMapType::const_iterator itCounter = koincidenceCounterMap.begin(); itCounter!=koincidenceCounterMap.end(); ++itCounter) {
      if (!( (itCounter->second)->IsInCoincidence(timeBinOfCount_tmp,'M') )) goto endOfThisHit;   // no coincidence found ==> skip hit 
    }
    for (counterMapType::const_iterator itCounter = vetoCounterMap.begin(); itCounter!=vetoCounterMap.end(); ++itCounter) {
      if ( (itCounter->second)->IsInCoincidence(timeBinOfCount_tmp,'M') ) goto endOfThisHit;   //  coincidence with veto found ==> skip hit 
    }
    // Check coincidences with other hits in the M counter
    // it is expected that there is only one M counter
    if (this->IsInCoincidence(timeBinOfCount_tmp,'M',true) ) {   //  coincidence with another M-counter hit ==> skip hit 
      doubleHitFound = true;
      //     std::cout<<"UJGUR double hit found"<<std::endl;
      goto endOfThisHit;   
    }

    kEntry   = (it->second)->eventEntry;
    idet     = (it->second)->det_i;
    idetID   = (it->second)->det_id;
    idetEdep = (it->second)->det_edep;
    //    timeBinOfNextHit = timeBinOfCount_tmp;
    return true;
    
    endOfThisHit:
    continue;
  }
  return false;
}

//================================================================
Int_t musrCounter::GetNextGoodPositron(Int_t evtID, Long64_t timeBinMin, Long64_t timeBinMax, Long64_t& timeBinOfNextGoodHit, Long64_t& timeBinOfNextGoodHit_phaseShifted, Int_t& kEntry, Int_t& idet, Int_t& idetID, Double_t& idetEdep, Bool_t& doubleHitFound) {
  // INPUT PARAMETERS:  evtID, timeBinMin
  // OUTPUT PARAMETERS: timeBinOfNextGoodHit
  //                    positronQuality = 0 ... no positron candidate found
  //                                    = 1 ... positron candidate found, but vetoed or not in a required coincidence with other detector
  //                                    = 2 ... good positron found
  // Loop over the hits in the counter
  Int_t positronQuality=0;
  if (bool_debugingRequired) {if (debugEventMap[evtID]>4) myPrintThisCounter(evtID);}
  if (hitMap.empty()) return 0;
  if (counterType!='P') {std::cout<<"\n!!! FATAL ERROR !!! musrCounter::GetNextGoodPositron: not the positron counter! ==> S T O P !!!\n"; exit(1);}
  doubleHitFound = false;
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {
    Int_t    eventNumber = (it->second)->eventIDnumber;
    Long64_t timeBinOfCount_tmp = it->first;
    if ((timeBinOfCount_tmp <= timeBinMin) || (timeBinOfCount_tmp > timeBinMax)) {
      if (bool_debugingRequired) {
	if (debugEventMap[evtID]>3) {std::cout<<"DEBUGEVENT:"<<evtID<<"\"GetNextGoodPositron\":  Hit out of data interval"<<std::endl;}
      }
      continue;   // This hit is out of the data interval ==> skip it
    }

    // Hit candidate was found.  Now check its coincidences and vetos
    positronQuality=1;
    for (counterMapType::const_iterator itCounter = koincidenceCounterMap.begin(); itCounter!=koincidenceCounterMap.end(); ++itCounter) {
      if (bool_debugingRequired) {
	if (debugEventMap[evtID]>4) { (itCounter->second)->myPrintThisCounter(evtID); }
      }
      if (!( (itCounter->second)->IsInCoincidence(timeBinOfCount_tmp,'P') )) {
	if (bool_debugingRequired) {
	  if (debugEventMap[evtID]>3) {std::cout<<"DEBUGEVENT:"<<evtID<<"\"GetNextGoodPositron\":  Coincidence required but not found"<<std::endl;}
	}
	goto endOfThisHit;   // no coincidence found ==> skip hit 
      }
    }
    for (counterMapType::const_iterator itCounter = vetoCounterMap.begin(); itCounter!=vetoCounterMap.end(); ++itCounter) {
      if ( (itCounter->second)->IsInCoincidence(timeBinOfCount_tmp,'P') ) {
	if (bool_debugingRequired) {
	  if (debugEventMap[evtID]>3) {std::cout<<"DEBUGEVENT:"<<evtID<<"\"GetNextGoodPositron\":  Coincidence vith veto detector found"<<std::endl;}
	}
	goto endOfThisHit;   //  coincidence with veto found ==> skip hit
      } 
    }
    // Check coincidences with other P counters    
    // Coincidences with other P counters must be checked in musrAnalysis.cxx
    //
    // ADD HERE THE CHECK THAT THE POSITRON IS FOUND WITHIN THE DATA INTERVAL, i.e. within <timeBinMin,timeBinMax>.
    // AND ALSO CHECK THAT THIS IS TRUE FOR THE COINCIDENCE WITH OTHER POSITRON COUNTERS!!!
    if (this->IsInCoincidence(timeBinOfCount_tmp,'P',true,timeBinMin,timeBinMax) ) {  //  coincidence with another P-counter hit ==> skip hit 
      	if (bool_debugingRequired) {
	  if (debugEventMap[evtID]>3) {std::cout<<"DEBUGEVENT:"<<evtID<<"\"GetNextGoodPositron\":  Coincidence with other positron candidate in the same counter."<<std::endl;}
	}
      doubleHitFound = true;
      //	std::cout<<"tttttttttttttttttttt doubleHitN="<<doubleHitN++<<std::endl;
      goto endOfThisHit;   
    }

    kEntry   = (it->second)->eventEntry;
    idet     = (it->second)->det_i;
    idetID   = (it->second)->det_id;
    idetEdep = (it->second)->det_edep;
    timeBinOfNextGoodHit = timeBinOfCount_tmp;
    timeBinOfNextGoodHit_phaseShifted = (it->second) -> timeBin2;
    if (bool_debugingRequired) {
      if (debugEventMap[evtID]>3) {std::cout<<"DEBUGEVENT:"<<evtID<<"\"GetNextGoodPositron\":  Good positron candidate found in this counter."<<std::endl;}
    }
    //cDEL    std::cout<<"timeBinOfNextGoodHit ="<<timeBinOfNextGoodHit<<"        timeBinOfNextGoodHit_phaseShifted = "<<timeBinOfNextGoodHit_phaseShifted<<std::endl;
    return 2;
    
    endOfThisHit:
    ;
    //    continue;
  }
  return positronQuality;
}

//================================================================
void musrCounter::SetCoincidenceTimeWindowOfAllCoincidenceDetectors(char motherCounter, Long64_t maxCoinc, Long64_t min, Long64_t max) {
  //  std::cout<<"QQQQQQQQQQQQQQQQQQQQQ koincidenceCounterMap.size()="<<koincidenceCounterMap.size()<<std::endl;
  for (counterMapType::const_iterator it = koincidenceCounterMap.begin(); it!=koincidenceCounterMap.end(); ++it) {
    Long64_t maxCoinc_AlreadySet = ((it->second)->GetMaxCoincidenceTimeWindow());
    if (maxCoinc < maxCoinc_AlreadySet)    (it->second)->SetMaxCoincidenceTimeWindow(maxCoinc);
 
    if      (motherCounter=='M') (it->second)->SetCoincidenceTimeWindow_M(min,max);
    else if (motherCounter=='P') (it->second)->SetCoincidenceTimeWindow_P(min,max);
    else {
      std::cout<<"musrCounter::SetCoincidenceTimeWindowOfAllCoincidenceDetectors ERROR: Strange motherCounter "
	       <<motherCounter<<"\n   ==> S T O P "<<std::endl; 
      exit(1);
    }
  }
}

//================================================================
void musrCounter::SetCoincidenceTimeWindowOfAllVetoDetectors(Long64_t maxCoinc, Long64_t min, Long64_t max) {
  for (counterMapType::const_iterator it = vetoCounterMap.begin(); it!=vetoCounterMap.end(); ++it) {
    Long64_t maxCoinc_AlreadySet = ((it->second)->GetMaxCoincidenceTimeWindow());
    if (maxCoinc < maxCoinc_AlreadySet)    (it->second)->SetMaxCoincidenceTimeWindow(maxCoinc);

    (it->second)->SetAntiCoincidenceTimeWindow(min,max);
  }
}

//================================================================
void musrCounter::myPrintThisCounter(Int_t evtID, Int_t detail) {
  Bool_t eventMixing=false;
  if ((hitMap.begin()==hitMap.end()) && (detail<=1) ) return;
  if (detail>1) std::cout<<"musrCounter::myPrintThisCounter:  counterNr = "<<counterNr<<":   ";
  else          std::cout<<"   counter = "<<counterNr<<":   ";
  for (hitMap_TYPE::iterator it = hitMap.begin(); it != hitMap.end(); ++it) {
    std::cout<<"\t"<<it->first<<"  "<<(it->second)->eventIDnumber<<",";
    if (evtID != (it->second)->eventIDnumber) {eventMixing=true;}
  }
  if (eventMixing) {std::cout<<"   Potential event mixing";}
  std::cout<<std::endl;
}

//================================================================