/**CbmMuchNewSignal.cxx
 * @class CbmMuchNewSignal
 **@author Vikas Singhal <vikas@vecc.gov.in>
 **@since 17/05/16
 **@version 1.0
 **@brief Data class for an analog signal in the MUCH
 ** Simple data class used in the digitisation process of the MUCH. It describes
 ** an analog charge distribution produced in the MUCH GEM Detector and arriving at the
 ** readout. It contains time and charge information corresponding to the MUCH Pad.
 ** In the most general case, a signal can be produced by more than one
 ** MCPoint; that is why the MC reference is of type CbmMatch and not CbmLink.
 **
 **
 **
 **/
#include "CbmMuchDigi.h"
#include "CbmMuchAddress.h"
#include "CbmMuchDigiMatch.h"
#include "CbmMuchNewSignal.h"
#include "TMath.h"
#include "TRandom.h"

#include <memory>

using namespace std;

/*
CbmMuchNewSignal::CbmMuchNewSignal(CbmMuchNewSignal* signal)
	: TObject(),
	fAddress(signal->fAddress),
	fTimeStart(signal->fTimeStart),
	fTimeStop(signal->fTimeStop),
	fSignalShape(signal->fSignalShape)
{
}

CbmMuchNewSignal::CbmMuchNewSignal(const CbmMuchNewSignal& rhs)
	: TObject(),
	fAddress(rhs.fAddress),
	fTimeStart(rhs.fTimeStart),
	fTimeStop(rhs.fTimeStop),
	fSignalShape(rhs.fSignalShape),
	fMatch(rhs.fMatch)
{
}

CbmMuchNewSignal& CbmMuchNewSignal::operator=(const CbmMuchNewSignal& rhs)
{

	if (this != &rhs) {
	TObject::operator=(rhs);
	fAddress = rhs.fAddress;
	fTimeStop = rhs.fTimeStop;
	fTimeStart = rhs.fTimeStart;
	fSignalShape = rhs.fSignalShape;
	fMatch	= rhs.fMatch;
  }
  return *this;
}
*/


void CbmMuchNewSignal::MakeSignalShape(UInt_t charge, TArrayD shape) {
	Int_t bin0 = 0;
			//Int_t((fT0)/gkResponseBin);
	Int_t nbins = bin0+shape.GetSize();
	if (fSignalShape.GetSize()<nbins) fSignalShape.Set(nbins);
	for (Int_t j=0;j<shape.GetSize();j++)  fSignalShape[bin0 + j]+=charge*shape[j];
}
// -------------------------------------------------------------------------
//
//
// -------------------------------------------------------------------------
//Below function will add the Signal shapes of 2 signal

void CbmMuchNewSignal::MergeSignal(CbmMuchNewSignal* signal){

	if ( fTimeStart > signal->GetTimeStart() ) fTimeStart = signal->GetTimeStart();
	if ( fTimeStop < signal->GetTimeStop() ) fTimeStop = signal->GetTimeStop();

// Here implement adding of elements to the map
// If entry with starttime already exists add the charge,
// if not create an entry with time as index and charge as value

	
	
/*
	TArrayD SecondSignalShape = signal->GetSignalShape();
	fSignalShape.Set(fSignalShape.GetSize()+StopDiff);
	//std::cout<<"MergeSignal called and size of fSignalShape "<<fSignalShape.GetSize()<<endl;
	for (Int_t j=0;j<fSignalShape.GetSize()&&j<SecondSignalShape.GetSize();j++)
		  
		fSignalShape[j+StartDiff]=fSignalShape[j+StartDiff]+SecondSignalShape[j];
		//SignalShape will be added in the first signal at location from where second signal start.
*/
}

void CbmMuchNewSignal::AddNoise(UInt_t meanNoise){
    LOG(INFO) << "Function AddNoise called " << ++fCounter << " times." << FairLogger::endl;
//  LOG(INFO) << "Array Size: " << fSignalShape.GetSize() << FairLogger::endl;
	for (Int_t i=0;i<fSignalShape.GetSize();i++){
		fSignalShape[i]+=TMath::Abs(meanNoise*gRandom->Gaus());
  	}
}


Int_t CbmMuchNewSignal::GetMaxCharge(){
	Int_t max_charge = -1;
	for (Int_t i=0;i<fSignalShape.GetSize();i++){
		Int_t charge = fSignalShape[i];
		if (charge>max_charge) max_charge = charge;
	}
  return max_charge;
}


Int_t CbmMuchNewSignal::GetTimeStamp(Int_t threshold){
  //Int_t threshold = 10000;
  Int_t bin1 = -1;
  for (Int_t i=0;i<fSignalShape.GetSize();i++){
    if (bin1<0 && fSignalShape[i]>threshold) {
      bin1 = i;
//      return fTimeStart+bin1*gkResponseBin;
      return fTimeStart+bin1;
    }
  }
  return -1;
}
// -------------------------------------------------------------------------


ClassImp(CbmMuchNewSignal)