//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of class TpcMcToDigiTask
//      see TpcMcToDigiTask.hh for details
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Sebastian Neubert    TUM            (original author)
//
//
//-----------------------------------------------------------

// Panda Headers ----------------------

// This Class' Header ------------------
#include "TpcMcToDigiTask.h"

// C/C++ Headers ----------------------
#include <algorithm>
#include <iostream>
#include "assert.h"

#include "TGraph.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TCanvas.h"
#include "TLine.h"
#include "TApplication.h"
#include "TH1D.h"

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TpcDigiPar.h"
#include "TClonesArray.h"
#include "TpcSignal.h"
#include "TpcSample.h"
#include "TpcDigi.h"
#include "TpcDigiAge.h"
#include "TpcFrontend.h"
#include "TpcSimplePSAStrategy.h"
#include "TpcPSA_TOT1.h"
#include "TpcDigitizationPolicy.h"
#include "TpcCRRCPulseshape.h"
#include "TpcT2KPulseshape.h"
#include "TpcPSAplot.h"
#include "TpcPSA_TOT1.h"
#include "TpcPSA_INT1.h"
#include "PndDetectorList.h"
#include "McId.h"
#include "QAPlotCollection.h"
#include "TpcDriftedElectron.h"
#include "TpcPadPlane.h"
#include "TpcFrontend.h"



// Class Member definitions -----------


TpcMcToDigiTask::TpcMcToDigiTask()
: FairTask("TPC Electronics response", 0),
  fpersistence(kFALSE),
  fsamplePersistence(kFALSE),
  finitialized(kFALSE),
  fCount(0),
  finputBranchName("TpcSignal"),
  fsampleBranchName("TpcSample"),
  fdigiBranchName("TpcDigi"),
  finputArray(0),
  fdigiArray(0),
  fsampleArray(0),
  fpar(0),
  fUseDriftedElectrons(kFALSE),
  fpadPlane(NULL),
  frmin(5),
  frmax(15),
  fgain(1),
  ffrontend(NULL)

{

}


TpcMcToDigiTask::~TpcMcToDigiTask()
{

}


void TpcMcToDigiTask::SetParContainers() {

	std::cout<<"TpcMcToDigiTask::SetParContainers"<<std::endl;
	std::cout.flush();

	// Get run and runtime database
	FairRun* run = FairRun::Instance();
	if ( ! run ) Fatal("SetParContainers", "No analysis run");

	FairRuntimeDb* db = run->GetRuntimeDb();
	if ( ! db ) Fatal("SetParContainers", "No runtime database");

	// Get Tpc digitisation parameter container
	fpar= (TpcDigiPar*) db->getContainer("TpcDigiPar");
	if (! fpar ) Fatal("SetParContainers", "TpcDigiPar not found");
}


InitStatus TpcMcToDigiTask::Init()
{

	finitialized=kFALSE;
	//Get ROOT Manager
	FairRootManager* ioman= FairRootManager::Instance();

	if(ioman==0)
	{
		Error("TpcMcToDigiTask::Init","RootManager not instantiated!");
		return kERROR;
	}

	// Get input collection
	finputArray=(TClonesArray*) ioman->GetObject(finputBranchName);

	if(finputArray==0)
	{
		Error("TpcMcToDigiTask::Init","Input-array not found!");
		return kERROR;
	}

	// create and register output array
	std::cout<<"registering tpcdigi\n";
	fdigiArray = new TClonesArray("TpcDigi");
	ioman->Register(fdigiBranchName,"Tpc",fdigiArray,fpersistence);
	std::cout<<"registering tpcsample\n";
	fsampleArray = new TClonesArray("TpcSample");
	ioman->Register(fsampleBranchName,"Tpc",fsampleArray,fsamplePersistence);


	fgain=fpar->getGem()->gain();
	frmin=fpar->getRMin();
	frmax=fpar->getRMax();
	fpadPlane= fpar->getPadPlane();
	ffrontend= fpar->getFrontend();

	finitialized=kTRUE;
	std::cout<<"TpcMCToDigiTask::Init done\n";
	return kSUCCESS;
}


void TpcMcToDigiTask::Exec(Option_t* opt)
{
	if (fVerbose) std::cout<<"TpcMcToDigiTask::Exec for Evt " << fCount << std::endl;
	fCount++;
	// Reset output Array
	if(fdigiArray==0) Fatal("TpcMcToDigi::Exec)","No DigiArray");
	fdigiArray->Delete();

	if (fUseDriftedElectrons)
	{
		ExecFromDrifted();
	}


	return;
}

void TpcMcToDigiTask::StoreSamples(std::vector<TpcSample*> *samplelist)
{
	int iarray=fsampleArray->GetEntriesFast();
	for(int i=0;i<samplelist->size();i++) {
		TpcSample* s=new((*fsampleArray)[iarray+i]) TpcSample(*((*samplelist)[i]));
		s->setIndex(iarray+i);
		(*samplelist)[i]->setIndex(iarray+i);
	}
}

ClassImp(TpcMcToDigiTask)

void TpcMcToDigiTask::ExecFromDrifted()
{
	Int_t nd=finputArray->GetEntriesFast();
	std::vector< TpcSample* > samples;
	Int_t iarray=fdigiArray->GetEntriesFast();
	Int_t digicounter=0;
	for(Int_t id=0;id<nd;++id)
	{

		TpcDriftedElectron* elec=(TpcDriftedElectron*)finputArray->At(id);
		Double_t amp=fgain;

		std::vector<TpcPad*> hitPads;
		double xpos=elec->x();
		double ypos=elec->y();
		double r=sqrt(xpos*xpos+ypos*ypos);
		if(r<frmin || r>frmax) {
			//Warning("Exec","Avalanche outside of allowed region! r=%f",r);
			continue;
		}
		fpadPlane->GetPadList(xpos,ypos,0,hitPads);

		if (hitPads.size()==0)
			continue;

		//std::cout<<"number of hit pads: "<<hitPads.size()<<"\n";
		double clock=ffrontend->Clock(elec->t());
		McIdCollection mcid;
		mcid.AddID( McId(0,elec->mcTrackId(),elec->mcSecId()));
		samples.push_back(new TpcSample(clock,ffrontend->A2D(amp),hitPads[0]->padId(),mcid,id));
		//TpcDigi* digi=new TpcDigi(amp,elec->t(),hitPads[0]->padId(),mcid);
		//std::cout<<"filling digi "<<id<<" "<<iarray<<"\n";
		TpcDigi* dig=new((*fdigiArray)[iarray+digicounter]) TpcDigi(ffrontend->A2D(amp),clock,hitPads[0]->padId(),mcid);
		dig->index(iarray+digicounter);
		digicounter+=1;
	}

	if (fsamplePersistence)
		StoreSamples(&samples);
}