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

// C/C++ Headers ----------------------
#include <algorithm>
#include <iostream>

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "TClonesArray.h"
#include "TpcSample.h"
#include "TpcDigi.h"
#include "TpcDigiAge.h"
#include "TpcSampleAge.h"
#include "TpcFrontend.h"
#include "TpcSimplePSAStrategy.h"
#include "TpcPSA_TOT1.h"
#include "TpcPSA_INT1.h"
//#include "TpcPSA_AD1.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TpcDigiPar.h"
#include "TpcT2KPulseshape.h"
#include "TpcCRRCPulseshape.h"
#include "TpcPadPlane.h"


// Class Member definitions -----------
void
TpcPSATask::SetParContainers() {

  if (fVerbose) {
    std::cout<<"TpcPSATask::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");
}


TpcPSATask::TpcPSATask()
  : FairTask("TPC Pulse shape analyser"), fpersistence(kFALSE), fpeak(100), fopt(0),
    fPads(0), fSamplePersistence(kFALSE),fVerbose(kFALSE)
{
  fsampleBranchName = "TpcSample";
  fDigiOutName = "TpcDigi";
}


TpcPSATask::~TpcPSATask()
{  
  if(ffrontend!=NULL)delete ffrontend;
  if(fpsa!=NULL)delete fpsa;
    
  clearSampleMap();
}

InitStatus
TpcPSATask::Init()
{
  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();
  fPadPlane = fpar->getPadPlane();
  fPads = fPadPlane->GetNPads();
  
  if(ioman==0)
    {
      Error("TpcPSATask::Init","RootManager not instantiated!");
      return kERROR;
    }
  
  // Get input collection
  fsampleArray=(TClonesArray*) ioman->GetObject(fsampleBranchName);
  
  if(fsampleArray==0)
    {
      Error("TpcPSATask::Init","Sample-array not found!");
      return kERROR;
    }
  
  // create and register output array
  fdigiArray = new TClonesArray("TpcDigi"); 
  ioman->Register(fDigiOutName,"Tpc",fdigiArray,fpersistence);

  
  //TODO: Get this from Database
  //  ffrontend= new TpcFrontend(10,    // AdcThreshold
  //		     2048, // adcmax
  //		     11,     // adcbits
  //		     20,     // SamplingFreq_Mhz
  //		     0,      // t0
  //			     16,     // timebits
  //		     10);     // PSAthreshold

  ffrontend = (TpcFrontend*) fpar->getFrontend();
  //fpulseshape= new TpcT2KPulseshape(fpeak);
  fpulseshape= new TpcCRRCPulseshape(ffrontend->tdiff(),
                                        ffrontend->tint(),
                                        ffrontend->tsig());
  
   if( fpar->getPSA() == 0) {
  	fpsa= new TpcSimplePSAStrategy(ffrontend->psaThreshold());
	  if (fVerbose) std::cout << "Using Simple PSA strategy!" << std::endl;
   }
   else if( fpar->getPSA() == 1){
     fpsa= new TpcPSA_TOT1();
     ((TpcPSA_TOT1*)fpsa)->setSamplePersistence(fSamplePersistence);
     ((TpcPSA_TOT1*)fpsa)->setSaturationThreshold(ffrontend->psaThreshold());
     if (fVerbose) {
       std::cout << "Using PSA_TOT strategy!";
       // if (fopt) {fpsa->setOpt(fopt); std::cout << " with " << fopt << "nb of empty samples allowed.";}
       std::cout << std::endl;
     }
   }   else if( fpar->getPSA() == 2){
      fpsa= new TpcPSA_INT1();
      ((TpcPSA_INT1*)fpsa)->setSamplePersistence(fSamplePersistence);
      ((TpcPSA_INT1*)fpsa)->setSaturationThreshold(ffrontend->psaThreshold());
      if (fVerbose) {
        std::cout << "Using PSA_INT strategy!";
        // if (fopt) {fpsa->setOpt(fopt); std::cout << " with " << fopt << "nb of empty samples allowed.";}
        std::cout << std::endl;
      }
   } else return kERROR;
   return kSUCCESS;
}


void
TpcPSATask::Exec(Option_t* opt)
{
  if (fVerbose) std::cout<<"TpcPSATask::Exec"<<std::endl;
  
  clearSampleMap();
  // Reset output Array
  if(fdigiArray==0) Fatal("TpcPSA::Exec)","No DigiArray");
  fdigiArray->Delete();
  // delete Samples created by PresetNullSample
  while(!nullSamples.empty()) delete nullSamples.back(), nullSamples.pop_back();


  // Sort samples according to padid (create several vectors of samples)
  Int_t ns=fsampleArray->GetEntriesFast();
  for(Int_t is=0;is<ns;++is){
    TpcSample* mysample=(TpcSample*)fsampleArray->At(is);
    unsigned int id=mysample->padId();
    if(id<0 || id>fPads)
      continue;
    if(fSampleMap[id]==NULL)fSampleMap[id]=new std::vector<TpcSample*>;
    fSampleMap[id]->push_back(mysample);
  }
  if (fVerbose) std::cout<< "Found " << fSampleMap.size() << " hit pads" << std::endl;

  // output vector
  std::vector <TpcDigi*> digis;
  // loop over pads
  std::map<unsigned int,std::vector<TpcSample*>* >::iterator padit=fSampleMap.begin();
  while(padit!=fSampleMap.end()){
    
    // get vector of samples in first pad
    std::vector<TpcSample*>* vecSa=padit->second;
    // sort samples in time
    sort(vecSa->begin(),vecSa->end(),TpcSampleAge());
    // pass samplelist to psa
    unsigned int ndigibefore=digis.size();
    if(vecSa->size()!=0)
      {
        PresetNullSample(vecSa);
        //std::cout << "Pad " << padit->first
        //	  << ": Processing " << vecSa->size() << " samples with PSA (th";
        fpsa->Process(*vecSa,digis,ffrontend->psaThreshold());
        //unsigned int ndigiafter=digis.size();
        //std::cout <<ffrontend->psaThreshold() << ") -- " 
        //	  << ndigiafter-ndigibefore << " Digis created."<<std::endl;
      }
    
    ++padit; // increase iterator 
  } // end loop over pads
  
  
  //sort digis in time;
  if (fVerbose) std::cout<<"sort Digis in time ... ";
  sort(digis.begin(),digis.end(),TpcDigiAge());
  if (fVerbose) std::cout<<"finished"<<std::endl;
  
  //copy data into digi_array (TClonesArray)
  int ndigi=digis.size();
  for(int idigi=0;idigi<ndigi;++idigi) {
    TpcDigi* digiClone = new((*fdigiArray)[idigi]) TpcDigi(*(digis[idigi]));
    digiClone->index(idigi);
    delete digis[idigi]; // clean up temporay store
  }

  if (fVerbose) std::cout<<ndigi<<" Digis created"<<std::endl;
  return;
}


void  TpcPSATask::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);
    nullSamples.push_back(pS);
  }
}


void TpcPSATask::clearSampleMap(){
  //delete vectors (but not TpcSamples) and clear sampleMaps
  std::map<unsigned int,std::vector<TpcSample*>* >::iterator secIt=fSampleMap.begin();
  while(secIt!=fSampleMap.end()){
    (secIt->second)->clear();
    delete secIt->second;
    ++secIt;
  }
  fSampleMap.clear();
}



ClassImp(TpcPSATask)