/*******************************************
 * PndEmcReadProto192Cern2012Data is a Fairtask to read
 * Data from the Proto60 and create PndEmcHits
 *
 * author: Christian Hammann <chammann@hiskp.uni-bonn.de>
 * Date: 8.1.2010
 *
 * ******************************************/

#include "PndEmcReadProto192Cern2012Data.h"
#include "FairRootManager.h"
#include "FairRuntimeDb.h"
#include "FairRun.h"
#include "TParticle.h"
#include "PndEmcMapper.h"
#include "PndEmcMultiWaveform.h"

#include "ProtoRawEvent.h"
#include "EventIOException.h"

PndEmcReadProto192Cern2012Data::PndEmcReadProto192Cern2012Data(const char * inputfilename, Bool_t StoreHits, Int_t debuglevel)
	:lStoreHits(StoreHits),lDebug(debuglevel),IsInit(kFALSE),signal(0),lOffset(0),lInputFileName(inputfilename),lEventCounter(0)  {
};

InitStatus PndEmcReadProto192Cern2012Data::Init(){
	
	FairRootManager* ioman = FairRootManager::Instance();
	if ( ! ioman ) {
		printf("-E- PndEmcHitProducer::Init: RootManager not instantiated!\n");
		return kFATAL;
	}

	lWaveArray = new TClonesArray("PndEmcMultiWaveform");
	ioman->Register("EmcMultiWaveform","Emc",lWaveArray,lStoreHits);

	lGeoPar->SetMapperVersion(1);
	lGeoPar->InitEmcMapper();

	lProtoEvent = new ProtoRawEvent;
	lProtoEvent->newInputArchive(lInputFileName);
	printf("PndEmcReadProto192Cern2012Data: Init successfull\n");

	lEventCounter = 0;

	IsInit = kTRUE;
	return kSUCCESS;
}

void PndEmcReadProto192Cern2012Data::SetParContainers() {

	// 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 Emc digitisation parameter container
	lDigiPar = (PndEmcDigiPar*) db->getContainer("PndEmcDigiPar");
  
	// Get Emc geometry parameter container
  	lGeoPar = (PndEmcGeoPar*) db->getContainer("PndEmcGeoPar");


	lGeoPassivePar = (PndGeoPassivePar *)db->getContainer("PndGeoPassivePar");
	lBaseParSet = (FairBaseParSet *)db->getContainer("FairBaseParSet");

	if(lDigiPar != NULL){
		printf("Got PndEmcDigiPar from database\n");
		lDigiPar->Print();
	} else {
		printf("could not get PndEmcDigiPar from database\n");
		abort();
	}


}

void PndEmcReadProto192Cern2012Data::SetIndexMap(const std::map<Int_t,Long_t> map){
	lIndexMap=map;
}

void PndEmcReadProto192Cern2012Data::SetWaveformMap(const std::map<Int_t,Long_t>map){
	lWaveformMap=map;
}

void PndEmcReadProto192Cern2012Data::Exec(Option_t *){
	if(!IsInit){
		printf("Not Initialised! You have to call Init() first.\n");
		return;
	}
	try{
			lProtoEvent->readFromArchive();
	}catch (EventIOException& except) {
		std::cerr << "reached end of file" << std::endl;
		std::cerr << except.what() << std::endl;
		std::cerr << "read " << lEventCounter << " Events" << std::endl;
		return;
	}
	if(lDebug > 2){
		std::cout << "read event " << lEventCounter << endl;
	}
	lEventCounter++;

	TClonesArray &WaveArrayRef = *lWaveArray;
//    printf("Size of Wavearray: %i ",WaveArrayRef.GetEntries());
	WaveArrayRef.Delete();
	PndEmcMultiWaveform *waveform;
	std::map<Long_t, PndEmcMultiWaveform *> wavemap;
	std::map<Long_t, PndEmcMultiWaveform *>::iterator it;
	Long_t detid;
	Bool_t avm_adc;
	Int_t wavelength;
	for(Int_t channel =0; channel < lProtoEvent->configuredChannels(); channel++){
		detid = lIndexMap[channel];
		if(detid!=0){
			if(detid==300000000){
				wavelength = 512; //lightpulser has 512 samples
			}else{
				wavelength = 256; // rest has 256 samples
			}
			it = wavemap.find(detid);
			if(it != wavemap.end()){
				waveform = (*it).second;
			}else{
				waveform = new (WaveArrayRef[WaveArrayRef.GetEntriesFast()]) PndEmcMultiWaveform(1,detid,wavelength,channel);
				wavemap.insert(std::pair<Long_t,PndEmcMultiWaveform*>(detid,waveform));
			}
			const std::vector<uint16_t> &tmpsignal = lProtoEvent->waveform(channel);
			signal.clear();
			avm_adc=kFALSE; //can be recognised by 16bit range
			for(Int_t j=0;j< wavelength;j++){
				if(tmpsignal[j]>36000){
					avm_adc=kTRUE;
				}
				if(avm_adc && tmpsignal[j] == 0){
					signal.push_back(65535); //avm adc reports overflow as 0. set to maximum to avoid problems
				} else {
					signal.push_back(tmpsignal[j]);
				}
			}
			waveform->SetWaveform(signal,signal.size(),lWaveformMap[channel]);
		}
	}
	delete lProtoEvent->trackingData();
	/*
	if(lDebug > 2){
		std::cout << WaveArrayRef.GetEntriesFast() << " Waveforms" << std::endl;
	}
	*/
}