//This Class
#include "PndMvdRatesTask.h"
//MVD
#include "PndSdsMCPoint.h"
#include "PndSdsDigiStrip.h"
#include "PndSdsDigiPixel.h"
#include "PndMvdRatesStrip.h"
#include "PndMvdRatesPixel.h"
//FAIR
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRuntimeDb.h"
#include "FairContFact.h"
#include "FairGeoNode.h"
#include "FairGeoVector.h"
//ROOT
#include "TClonesArray.h"
#include "TArrayD.h"
#include "TVector2.h"
#include "TString.h"
#include "TObjString.h"
#include "TGeoManager.h"
#include "TList.h"
#include "TH1F.h"
#include "TRandom.h"
#include <map>
#include <string>


// -----   Default constructor   -------------------------------------------
PndMvdRatesTask::PndMvdRatesTask() :
  FairTask("MVD Strip Digi Producer(PndMvdRatesTask)")
{
  fBranchMCName   = "MVDPoint";
  fBranchStripDigiName   = "MVDStripDigis";
  fBranchPixelDigiName   = "MVDPixelDigis";
  // fNameHisto = "TimeDistribution";
  fTimeDistr = 0;
}
// -------------------------------------------------------------------------


// -----   TH1F constructor   -------------------------------------------
PndMvdRatesTask::PndMvdRatesTask(TH1F *h) :
  FairTask("MVD Strip Digi Producer(PndMvdRatesTask)")
{
 fBranchMCName   = "MVDPoint";
  fBranchStripDigiName   = "MVDStripDigis";
  fBranchPixelDigiName   = "MVDPixelDigis";
  //  fNameHisto = "TimeDistribution";
  fTimeDistr = h;
}
// -------------------------------------------------------------------------


// -----   Destructor   ----------------------------------------------------
PndMvdRatesTask::~PndMvdRatesTask()
{
}
// -------------------------------------------------------------------------


InitStatus PndMvdRatesTask::ReInit()
{
  return kSUCCESS;
}


// -----   Public method Init   --------------------------------------------
InitStatus PndMvdRatesTask::Init()
{ 

  
  // FairRun* ana = FairRun::Instance();

  FairRootManager* ioman = FairRootManager::Instance();

  //  fGeoH = new PndGeoHandling();

  TDatime dt;

  UInt_t seed = dt.Get();

  gRandom->SetSeed(seed);

  fPointArray = (TClonesArray*) ioman->GetObject(fBranchMCName);
  if ( ! fPointArray )
    {
      std::cout << "-W- PndMvdRatesTask::Init: "
		<< "No SDSMCPoint array!" << std::endl;
      return kERROR;
  }

  fDigiStripArray = (TClonesArray*) ioman->GetObject(fBranchStripDigiName);
 if ( ! fDigiStripArray )
    {
      std::cout << "-W- PndMvdRatesTask::Init: "
		<< "No DigiStrip array!" << std::endl;
      return kERROR;
  }

 fDigiPixelArray = (TClonesArray*) ioman->GetObject(fBranchPixelDigiName);
 if ( ! fDigiPixelArray )
    {
      std::cout << "-W- PndMvdRatesTask::Init: "
		<< "No DigiPixel array!" << std::endl;
      return kERROR;
  }
 
//  // Look for TH1F where the time distribution is stored
//  // if it is not found, default setting swill be used

//  fTimeDistr = (TH1F*) ioman->GetObject(fNameHisto);
//  if ( ! fTimeDistr )
//     {
//       std::cout << "Time distribution not found, using default settings" << std::endl;
//       fTimeDistr = 0;
//     }
 

 // Create and register output arrays

 
 fRatesPixelArray = new TClonesArray("PndMvdRatesPixel");
 ioman->Register("MVDRatesPixel", "MVD", fRatesPixelArray, kTRUE);

 fRatesStripArray = new TClonesArray("PndMvdRatesStrip");
 ioman->Register("MVDRatesStrip", "MVD", fRatesStripArray, kTRUE);

 fAbsEvtTime = 0;
 nEv = 0;

 fStripDeadTime.clear();
 fPixelDeadTime.clear();
  
 return kSUCCESS;
}
// -------------------------------------------------------------------------



// -----   Public method Exec   --------------------------------------------
void PndMvdRatesTask::Exec(Option_t* opt)
{
  
  // Reset output array
  fRatesStripArray->Delete();
  fRatesPixelArray->Delete();
  nEv++;
   
  PndSdsMCPoint *point = NULL;
  PndSdsDigiStrip *stripd = NULL;
  PndSdsDigiPixel *pixeld = NULL;

  // Looping on strip digis, getting corresponding MC info and storing in the output array

  Int_t nStripDigis = fDigiStripArray->GetEntriesFast();

  Int_t buff = 0,ibis = 0, buff2 = 0, itris = 0;

  GenEvtStart();

  if ((nEv%10)==0)
    {
      cout << "\n---------------------------------------" << endl;
      cout << "start: " << fAbsEvtTime << endl;
      cout << "---------------------------------------" << endl;
    }

  std::string StripName,PixelName;
  Int_t buffString,buffPixel; // nameSensor_FE_channel
  Bool_t status = 1; // posible to store or not the digi


  // strips /////////////////////////////////////


  for (Int_t i1 = 0 ; i1 < nStripDigis ; i1++)
    {
      stripd = (PndSdsDigiStrip*) fDigiStripArray->At(i1);
      buff = stripd->GetIndex();
      
      if (buff >= 0)
	{
	  point = (PndSdsMCPoint*) fPointArray->At(buff);
      
	  buffString = (stripd->GetSensorID());

	  //	  cout << "NOME: " << fGeoH->GetPath(stripd->GetDetName()) << endl;

	  StripName = Form("%d%d_%d",buffString,stripd->GetFE(),stripd->GetChannel());
	  //cout << StripName.c_str() << " " << stripd->GetFE() << " " << stripd->GetChannel() << endl;

	  if (!fStripDeadTime[StripName])
	    {
	      fStripDeadTime[StripName] = GenDeadTimeStrip(stripd->GetCharge());
	      status = 1;
	    }
	  else
	    {
	      if ((fStripDeadTime[StripName]) <= fAbsEvtTime)
		{
		  fStripDeadTime[StripName] = GenDeadTimeStrip(stripd->GetCharge());
		  status = 1;
		}
	      else
		{
		  status = 0;
		}
	    }

	  new ((*fRatesStripArray)[ibis]) PndMvdRatesStrip(stripd,point,fAbsEvtTime,status);

	  ibis++;
	}
	else
	{	
		cout << "Illegal index: Â" << buff << endl;
	}	
    }
  

 // Looping on pixel digis, getting corresponding MC info and storing in the output array

  // pixels /////////////////////////////////////

  Int_t nPixelDigis = fDigiPixelArray->GetEntriesFast();


  for (Int_t i2 = 0 ; i2 < nPixelDigis ; i2++)
    {
      pixeld = (PndSdsDigiPixel*) fDigiPixelArray->At(i2);
      buff2 = pixeld->GetIndex();
      
      if (buff2 >= 0)
	{
 	  point = (PndSdsMCPoint*) fPointArray->At(buff2);
	  	 
 	  buffPixel = (pixeld->GetSensorID());

 	  PixelName = Form("%d%d_%d_%d",buffPixel,pixeld->GetFE(),pixeld->GetPixelRow(),pixeld->GetPixelColumn());

	  cout << PixelName << endl;

	  if (!fPixelDeadTime[PixelName])
	    {
	      fPixelDeadTime[PixelName] = GenDeadTimePixel(pixeld->GetCharge());
	      cout << "Time: " << fAbsEvtTime << " fixing dead time: " << GenDeadTimePixel(pixeld->GetCharge()) << endl;
	 
	      status = 1;
	    }
	  else
	    {
	      if ((fPixelDeadTime[PixelName]) <= fAbsEvtTime)
		{
		  fPixelDeadTime[PixelName] = GenDeadTimePixel(pixeld->GetCharge());
		  status = 1;
		  cout << "*************************" << endl;
		}
	      else
		{
		  status = 0;
	
		  cout << "Event " << nEv << " entry: " << buff2  <<" Dead Time: " << fPixelDeadTime[PixelName] << " time " << fAbsEvtTime << endl;
		}
	    }

 	  new ((*fRatesPixelArray)[itris]) PndMvdRatesPixel(pixeld,point,fAbsEvtTime,status);
	
 	  itris++;
	}
	else
	{	
		cout << "Illegal Index: " << buff2 << endl;
 	}
    }
  


}

Double_t PndMvdRatesTask::GetEventStep()
{

   if (fTimeDistr==0)
    { // default time distribution

      // simple approach...

      // return (50.); // in ns

      // nicer:

      return (gRandom->PoissonD(50.));
     
    }

  else
    {

      return (fTimeDistr->GetRandom());

    }
  
}

Double_t PndMvdRatesTask::GenEvtStart()
{

  fAbsEvtTime = (fAbsEvtTime + GetEventStep());

  return fAbsEvtTime;

}

Double_t PndMvdRatesTask::GenDeadTimeStrip(Double_t charge)
{

  Double_t deadT = charge/(1.e4);

  Double_t Thr = 100; // maximum dead time

  if (deadT > Thr) deadT = Thr;

  return (fAbsEvtTime+deadT);

}

Double_t PndMvdRatesTask::GenDeadTimePixel(Double_t charge)
{
  
  Double_t ReadTime = 10*(1./(155.e6))*1.e9; // in ns
  // ten internal clock steps, where clock is at 155 MHz

  // charge is in e, let's convert it into fC

  charge = charge * 1.602176487e-4; // C(e) = 1.602176487e-19 C = 1.602176487e-4 fC

  Double_t ToT = 152./charge; // where charge is in fC and Tot in ns
 
  Double_t Thr = 20000.; // maximum dead time in ns -> 20 microsec

  if ((ReadTime+ToT) > Thr) return (fAbsEvtTime+Thr);
  else
    return (fAbsEvtTime+ReadTime+ToT);
 
}

ClassImp(PndMvdRatesTask);