//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of class TpcElectronicsTask
//      see TpcElectronicsTask.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 "TpcElectronicsTask.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"


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


TpcElectronicsTask::TpcElectronicsTask()
  : FairTask("TPC Electronics response", 0),
    fpersistence(kFALSE),
    fsamplePersistence(kFALSE),
    finitialized(kFALSE),
    fqa(NULL),
    fCount(0),
    fPSATimeCalib(2.8),
    fpsai(-1),
    fsignalBranchName("TpcSignal"),
    fsampleBranchName("TpcSample"),
    fdigiBranchName("TpcDigi"),
    fshaper("CRRC"),
    fsignalArray(0),
	fdigiArray(0),
	fsampleArray(0),
	fpar(0),
	fsampleAmpH(0),
	fmeanDigiTH(0),
	fnSampRelSig(0),
	fpsa(0),
	ffrontend(0),
	fpulseshape(0),
	fzdepTimeCalib(kFALSE),
	fp1(0),fp2(0),fp3(0),fp4(0),fp5(0),fp6(0)
{

}


TpcElectronicsTask::~TpcElectronicsTask()
{
  if(fpsa!=0)delete fpsa;
}


void TpcElectronicsTask::SetParContainers() {

  std::cout<<"TpcElectronicsTask::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 TpcElectronicsTask::Init()
{
	
  finitialized=kFALSE;
  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();

  if(ioman==0)
  {
    Error("TpcElectronicsTask::Init","RootManager not instantiated!");
    return kERROR;
  }
  
  // Get input collection
  fsignalArray=(TClonesArray*) ioman->GetObject(fsignalBranchName);
  
  if(fsignalArray==0)
  {
    Error("TpcElectronicsTask::Init","Signal-array not found!");
    return kERROR;
  }
  
  // create and register output array
  fdigiArray = new TClonesArray("TpcDigi"); 
  ioman->Register(fdigiBranchName,"Tpc",fdigiArray,fpersistence);
  
  fsampleArray = new TClonesArray("TpcSample");
  ioman->Register(fsampleBranchName,"Tpc",fsampleArray,fsamplePersistence);

  
  //TODO: Get this from Database!
  ffrontend= fpar->getFrontend();

  if(fshaper=="CRRC"){
    fpulseshape= new TpcCRRCPulseshape(ffrontend->tdiff(),
                                       ffrontend->tint(),
                                       ffrontend->tsig());
  }
  else if(fshaper=="T2K"){
    fpulseshape= new TpcT2KPulseshape(ffrontend->tdiff());
  }
  else  {
    Error("TpcElectronicsTask::Init",
          "Choose a proper pulseshape! Currently supported: CRRC, T2K");
    return kERROR;
  }

  Int_t psa;
  if (fpsai!=-1)
    psa=fpsai;
  else
    psa=fpar->getPSA();

  if( psa == 0)	{
    fpsa= new TpcSimplePSAStrategy(ffrontend->psaThreshold());
    std::cout << "Using Simple PSA strategy!" << std::endl;
  }
  else if( psa == 1)	{
    TpcPSA_TOT1* mypsa= new TpcPSA_TOT1();

    if (fzdepTimeCalib)
    	mypsa->setTimeCalibParams(fp1,fp2,fp3,fp4,fp5,fp6);
    else
    	mypsa->setTimeCalib(fPSATimeCalib);

    mypsa->setSamplePersistence(fsamplePersistence);
    fpsa=mypsa;
    std::cout << "Using PSA_TOT strategy!" << std::endl;
    std::cout << "with time calibration const c="<<fPSATimeCalib << std::endl;
  }  
  else if( psa == 2){
    fpsa= new TpcPSA_INT1();
    ((TpcPSA_INT1*)fpsa)->setSamplePersistence(fsamplePersistence);
    ((TpcPSA_INT1*)fpsa)->setSaturationThreshold(ffrontend->psaThreshold());

    if (fzdepTimeCalib)
    	((TpcPSA_INT1*)fpsa)->setTimeCalibParams(fp1,fp2,fp3,fp4,fp5,fp6);
    else
    	((TpcPSA_INT1*)fpsa)->setTimeCalib(fPSATimeCalib);

    std::cout << "Using PSA_INT strategy!";
    std::cout << "with time calibration const c="<<fPSATimeCalib << std::endl;
  }
  else	{
    Error("TpcElectronicsTask::Init",
          "PSA strategy index not valid.");
    return kERROR;
  }

  // check in QA plots
  if(fqa!=NULL){
    double maxSamp=ffrontend->adcmax()/ffrontend->adcstep();
    fsampleAmpH=fqa->getTH1D("SamplAmp","Sample amplitudes",1000,0,maxSamp);
    fmeanDigiTH=fqa->getTH1D("MeanDigiT","Mean Digi t - Mean Signal t",1000,-20,20);
  }
  
  finitialized=kTRUE;
  return kSUCCESS;
}


void TpcElectronicsTask::Exec(Option_t* opt)
{
  if (fVerbose) std::cout<<"TpcElectronicsTask::Exec for Evt " << fCount << std::endl;
  fCount++;
  // Reset output Array
  if(fdigiArray==0) Fatal("TpcElectronics::Exec)","No DigiArray");
  fdigiArray->Delete();
  if(fsamplePersistence)	{
    if(fsampleArray==0) Fatal("TpcElectronics::Exec)","No SampleArray");
    fsampleArray->Delete();
  }
	
  //partition data according to pads
  if (fVerbose) std::cout<<"Building up padmap ...";
  std::map<unsigned int,std::vector<TpcSignal*> > padmap;
  std::map<unsigned int, std::vector<int> > sigIdMap;

  Int_t ns=fsignalArray->GetEntriesFast();
  for(Int_t is=0;is<ns;++is){
    TpcSignal* sig=(TpcSignal*)fsignalArray->At(is);
    unsigned int id=sig->padId();
    //if(padmap[id]==NULL)padmap[id]=new std::vector<TpcSignal*>;
    padmap[id].push_back(sig);
    sigIdMap[id].push_back(is);
  }
  if (fVerbose) std::cout<<"finished. "<<padmap.size()<<" pads hit"<<std::endl;
  int tenpercent=padmap.size()/10;
  if(tenpercent==0)tenpercent=1;
  // cleanup fsignal_array;
  //fsignalArray->Clear();

  // process each pad individually:
  std::map<unsigned int,std::vector<TpcSignal*> >::iterator padIt=padmap.begin();
  int counter=0;
  while(padIt!=padmap.end()){
    if(fVerbose && counter++%tenpercent==0){
      std::cout<<".";
      std::cout.flush();
    }
    // --- ADC ------------------------------------------
    std::vector<TpcSignal*>* sv=&padIt->second;
    std::vector<TpcSample*> samplelist;
    TpcDigitizationPolicy().Digitize(sv,&samplelist,ffrontend,fpulseshape);

    //PresetNullSample(&samplelist);
    if(fsamplePersistence)	{
      StoreSamples(&samplelist);
    }

    
    // make some statistics of signals
    int nsig=sv->size();
    double meansigt=0;
    for(int i=0;i<nsig;++i){
      meansigt+=(*sv)[i]->t();
    }
    if(nsig>0)meansigt/=nsig;
    
    //for(int isig=0; isig<nsig;++isig)delete(*sv)[isig];
    //    sv->clear();
    // std::cout<<samplelist.size()<<" samples created!"<<std::endl;

    // --- PSA ------------------------------------------
    std::vector<TpcDigi*> digis;
    fpsa->Process(samplelist,digis,ffrontend->psaThreshold());



    int nsamp=samplelist.size();
    int ndigi=digis.size();

    if(fqa!=NULL){
      for(int i=0;i<nsamp;++i){
        fsampleAmpH->Fill(samplelist[i]->amp());
      }
    }
    /*
      for(int i=0;i<digis.size();i++) {
      std::cout << digis[i]->amp() << " " << digis[i]->t() << " " << digis[i]->padId() << std::endl;
      }




      for(int iSig=0;iSig<nsig;iSig++) {
      std::cout << ((*sv)[iSig])->t() << " " 
      << ffrontend->ClockFine( ((*sv)[iSig])->t() ) 
      << std::endl;
      }



      if(nsamp>0) {
      TpcPSAplot myplot(&samplelist,&digis,sv,ffrontend);
      myplot.Draw();
      }
    */
	  
    //
    
    
    sv->clear();
    // cleanup samples

    for(int isamp=0;isamp<nsamp;++isamp)delete samplelist[isamp];
    samplelist.clear();

    //copy data into digi_array (TClonesvector)
    //    int ndigi=digis.size();
    double meandigit=0;
    int iarray=fdigiArray->GetEntriesFast();
    for(int idigi=0;idigi<ndigi;++idigi) {
      TpcDigi* dig=new((*fdigiArray)[iarray+idigi]) TpcDigi(*(digis[idigi]));
      dig->index(iarray+idigi);
      delete digis[idigi]; // clean up temporay store
      meandigit=dig->t();
    }
    if(ndigi>0){
      meandigit/=ndigi;
      double dt=meandigit-meansigt;
      if(fqa!=0)fmeanDigiTH->Fill(dt);
    }
    
    ++padIt;
  } // end loop over hit pads
  
  if (fVerbose) std::cout<<std::endl<<fdigiArray->GetEntriesFast()<<" Digis created"<<std::endl;
  return;
}

void  TpcElectronicsTask::PresetNullSample(std::vector<TpcSample*> *samplelist)
{
  //set a zero sample before the first sample in the vector, so that the alternative psa will always 	
  //find the first maximum 
  if(samplelist->size()>0)	{	
    TpcSample *pFirstSample=*(samplelist->begin());
    int t=pFirstSample->t();
    unsigned int PadID=pFirstSample->padId();
    McIdCollection m=pFirstSample->mcId();
    TpcSample *pS=new TpcSample(t-1,0,PadID,m);
    samplelist->insert(samplelist->begin(),pS);
  }
}


void TpcElectronicsTask::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);

  }
}

void TpcElectronicsTask::WriteHistograms(){
  if(!finitialized || fqa==NULL)return;
  TFile* outfile=FairRootManager::Instance()->GetOutFile();
	
  outfile->mkdir("TpcElectronicsTask");
  outfile->cd("TpcElectronicsTask");
	
  fsampleAmpH->Write();
	
}

ClassImp(TpcElectronicsTask)