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

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

// Collaborating Class Headers --------
#include "TError.h"
#include "TpcSignal.h"
#include "TpcSignalAge.h"
#include "TpcSample.h"
#include "McIdCollection.h"
#include "TpcFrontend.h"
#include "TpcAbsPulseshape.h"

// C/C++ Headers ----------------------
#include "assert.h"
#include <limits>
#include <iostream>
#include <algorithm>
using std::numeric_limits;
using std::vector;

// Class Member definitions -----------
void
TpcDigitizationPolicy::Digitize(vector< TpcSignal* >* Signals,
		vector< TpcSample* >* Samples,
		const TpcFrontend* Frontend,
		const TpcAbsPulseshape* pulseshape){

	// Digitize
	// TODO: Refactorize the PadID out of this function!
	// Sort Signals according to PadID while preserving time order in one Pad
	unsigned int dummySampleIndex=0;
	std::sort(Signals->begin(),Signals->end(),TpcSignalComparePadID());
	// when using TpcElectronicsTask this should not be necessary

	double tstep=Frontend->dt();
	double t=0;
	int clock=0;
	int sigId=-1;
	double nextsignalt=std::numeric_limits<double>::max();
	int nextsignalclock=std::numeric_limits<int>::max();

	assert(pulseshape!=0);

	std::vector<TpcSignal*>::iterator it_Padbegin=Signals->begin();
	std::vector<TpcSignal*>::iterator it_Padend=Signals->begin();
	unsigned int iPadbegin=0;
	unsigned int iPadend=0;
	unsigned int nSignals=Signals->size();

	unsigned int PadID=(*it_Padbegin)->padId();
	double tint=Frontend->tint();				//use for a rough estimate on how many samples should be at least tried
	const int nMinSamplesTrys = (int)(tint/tstep);		// necessary because if only one signal is there, the time of this signal
	// will be to early to get something else from pulseshape->value than zero
	while(iPadend<nSignals)
	{
		unsigned int newPadID=(*Signals)[iPadend]->padId();
		if(newPadID!=PadID || iPadend+1==nSignals)
		{
			sort(it_Padbegin+iPadbegin,it_Padend+(iPadend+1),TpcSignalAge());
			t=Frontend->TimeAtClock((*Signals)[iPadbegin]->t());
			clock=Frontend->Clock((*Signals)[iPadbegin]->t());
			unsigned int iSig=iPadbegin;
			while(iSig<=iPadend)
			{//loop over signals on one pad
				if(iSig<iPadend)
				{
					nextsignalt=Frontend->TimeAtClock((*Signals)[iSig+1]->t());
					nextsignalclock=Frontend->Clock((*Signals)[iSig+1]->t());
				}
				int nSamplesTrys=0;
				while(t<nextsignalt || iSig==iPadend )
				{
					//add all valid pulseshapes
					double amp=0;
					unsigned int i;
					McIdCollection mcid;
					for(i=iPadbegin; i<=iSig; ++i)
					{
						TpcSignal* sig=(*Signals)[i];
						double ampcontrib=pulseshape->value(t ,sig->amp(),sig->t());
						sigId=sig->index();
						amp+=ampcontrib;
						mcid.AddID(sig->mcId(),ampcontrib);
					}

					if(amp>Frontend->adcThreshold())
					{
						mcid.Renormalize();
						Samples->push_back(new TpcSample(clock,
								Frontend->A2D(amp),
								PadID,
								mcid,dummySampleIndex));
						Samples->back()->setSigId(sigId);
						++dummySampleIndex;
					}
					else if (nSamplesTrys > nMinSamplesTrys)
					{
						t=nextsignalt;
						clock=nextsignalclock;
						break;
					}
					t +=tstep;
					clock=(clock+1)%Frontend->maxSamples();
					nSamplesTrys++;
				}
				++iSig;

			}// end loop over Signals on one pad

			// cleanup signals on current pad
			//iSig=iPadbegin;
			//while(iSig<iPadend){
			//if((*Signals)[iSig]!=NULL){
			//  delete(*Signals)[iSig];
			//  (*Signals)[iSig]=NULL;
			//}
			//++iSig;
			//}

			// start new signalform
			PadID=newPadID;
			iPadbegin=iPadend;
		}
		++iPadend;
	} //end loop over signals
}