/////////////////////////////////////////////////////////////
//  PndDchDigiProducer
//  Filler of PndDchDigi
///////////////////////////////////////////////////////////////// 

#include "PndDchDigiProducer.h"

#include "PndDchDigi.h"
#include "PndDchPoint.h"
#include "PndDchMapper.h"
#include "PndDchDrifter.h"

#include "CbmRootManager.h"
#include "CbmRunAna.h"
#include "CbmRun.h"

#include "TClonesArray.h"	
#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TVector3.h"

#include <vector>

using std::cout;
using std::endl;
using std::vector;

// Default constructor
PndDchDigiProducer::PndDchDigiProducer() :
  CbmTask("Ideal DCH digi Producer") { 
}

// Destructor 
PndDchDigiProducer::~PndDchDigiProducer() {
  if(fDigiArray){
    fDigiArray->Delete();
    delete fDigiArray;
  }
}

// Public method Init 
InitStatus PndDchDigiProducer::Init() {
 
  cout << "PndDchDigiProducer::Init()... " << endl;
  
  // Get RootManager
  CbmRootManager* ioman = CbmRootManager::Instance();
  if ( ! ioman ) {
    cout << "-E- PndDchDigiProducer::Init():\n\t "
	 << "RootManager not instantiated!" << endl;
    return kFATAL;
  }
  fMapper     = PndDchMapper::Instance();
  fDrifter    = PndDchDrifter::Instance("d2t.dat",1.);
  
  // Get input array
  fPointArray = (TClonesArray*) ioman->GetObject("PndDchPoint");
  if ( ! fPointArray ) {
    cout << "-W- PndDchDigiProducer::Init(): "
	 << "No EmcPoint array!" << endl;
    return kERROR;
  }
  
  // Create and register output array
  fDigiArray = new TClonesArray("PndDchDigi");
  ioman->Register("PndDchDigi","Dch",fDigiArray,kTRUE);
  
  cout << "-I- PndDchDigiProducer: Intialization successfull" << endl;
  
  return kSUCCESS;

}

// Public method Exec 
void PndDchDigiProducer::Exec(Option_t* opt) {

  // Reset output array
  if ( ! fDigiArray ) Fatal("Exec", "No DigiArray");
  fDigiArray->Clear();
   
  // Loop over PndDchPoints...
  PndDchPoint* point  = 0;
  Int_t nPoints = fPointArray->GetEntriesFast();
  Double_t pointTime;
  for (Int_t iPoint=0; iPoint<nPoints; iPoint++) {
    point  = (PndDchPoint*) fPointArray->At(iPoint);
    //... and register the Digis you want
    if (ToBeOrNotToBe(point)) {
      Int_t nAdded = AddDigis(point, iPoint);
      cout<<"PndDchDigiProducer::Exec(...):\n\t";
      cout<< "For this point I added "<< nAdded<< " digis"<<endl;
    }
  }
}

// Private method AddDigi
Int_t PndDchDigiProducer::AddDigis(PndDchPoint* point, Int_t refIndex) {
  TClonesArray& clref = *fDigiArray;
  Int_t size = clref.GetEntriesFast();
  Double_t timeStamp = point->GetTime();
  Int_t     plane     = point->GetPlane();
  Int_t     chamber   = point->GetChamber();
  Double_t driftTime;
  vector<Int_t> wires;
  vector<Double_t> distances;
  Int_t nDigis = fMapper->GetFiredWires(wires, distances, point);
  for (Int_t i=0; i<nDigis; i++){
    Int_t     wire      = wires[i];
    if(fDrifter->CalculateDriftTime(driftTime,distances[i])){
    PndDchDigi* digi = new(clref[size]) PndDchDigi( timeStamp, plane, chamber,
				      wire, driftTime, refIndex);
    digi->Print("");
    size++;
    } else {
      cout<< "wrong drift time"<<endl;
    } 
  }
  return nDigis;
}

// Private method ToBeOrNotToBe digitised
Bool_t PndDchDigiProducer:: ToBeOrNotToBe(const PndDchPoint* point) const {
  Double_t  detID   = point->GetDetectorID();
  Double_t  trackID = point->GetTrackID();
  PndDchDigi* digi = 0;
  PndDchPoint* itspoint = 0;
  Int_t nDigis = fDigiArray->GetEntriesFast();
  for (Int_t i=0; i<nDigis; i++){
    digi = (PndDchDigi*) fDigiArray->At(i);
    itspoint = (PndDchPoint*) fPointArray->At(digi->GetRefIndex());
    if (detID == itspoint->GetDetectorID() &&
	trackID == itspoint->GetTrackID())
      return kFALSE;
  } 
  return kTRUE;
}

ClassImp(PndDchDigiProducer)