//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//     Reader for t2k data for the gemTPCdecoding program
//
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Maxence Vandenbroucke    TUM            (original author)
//      Felix Boehmer            TUM  
//
//-----------------------------------------------------------


// Panda Headers ----------------------

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

// C/C++ Headers ----------------------
#include <vector>
#include <map>

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "TClonesArray.h"
#include "TVector3.h"
#include "TpcDigiMapper.h"
#include "TpcDigiPar.h"
#include "TH1.h"
#include "TFile.h"

#include "FairRunAna.h"
#include "FairRuntimeDb.h"
 

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

ClassImp(TpcDataReaderTask)


TpcDataReaderTask::TpcDataReaderTask()
: fPersistence(kFALSE), fCutoff(0),
  fEventNb(0), fSpillNb(0), fLoop(0), fEventId(0),
  fRunNr(0), fTimeStamp(0)
  
{
  fSampleBranchName = "TpcSample";
  fFile = "TBtest/run.root";
  fEv=NULL; //not setting this to 0 gives a segfault. ROOT is fully awesome
}

TpcDataReaderTask::~TpcDataReaderTask()
{;}

InitStatus
TpcDataReaderTask::Init()
{
  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();
  
  if(ioman==0)
    {
      Error("TpcDataReaderTask::Init","RootManager not instantiated!");
      return kERROR;
    }
  
  // Get input data
  FairRun* run = FairRun::Instance();
  if ( ! run ) Fatal("SetParContainers", "No analysis run");

  FairRuntimeDb* db = run->GetRuntimeDb();
  if ( ! db ) Fatal("SetParContainers", "No runtime database");

  TpcDigiPar* fpar= (TpcDigiPar*) db->getContainer("TpcDigiPar");
  if (! fpar ) Fatal("SetParContainers", "TpcDigiPar not found");
  samthr=fpar->getSamThr();
  //fPadplane= fPar->getPadPlane();
 
  fIntree = new TChain("tpcEvent");
  fIntree->Add(fFile.Data());//before AddFile
  fIntree->SetBranchAddress("tpcEvent", &fEv);
  TFile* hfile = new TFile(fFile.Data());
  TH1D* hsigma=(TH1D*)hfile->Get("SigmaFpnPadIDGlobalRef");
  for (int i=0;i<hsigma->GetNbinsX();i++)
    {
      sigmas.push_back((double)hsigma->GetBinContent(i));
    }
  hfile->Close();
  std::cout<<sigmas.size()<<" sigmas saved"<<std::endl;

  if(fIntree->IsZombie()) {
    std::cout << "TpcDataReaderTask::Init data file/tree "<< fFile 
	      << " couldn't be loaded -> abort" <<std::endl;
    Error("TpcDataReaderTask::Init","Data file not found");
    return kERROR;
  }

  if (fVerbose)
    std::cout<<"Number of Entries in Chain: "<<fIntree->GetEntries()<< std::endl;
  
  // create and register output array
  fSampleOutArray = new TClonesArray("TpcSample");
  fEventIdOutArray = new TClonesArray("TpcEventIdentifier");
  ioman->Register("TpcSample","Tpc",fSampleOutArray,fPersistence);
  ioman->Register("TpcEventIdentifier","Tpc", fEventIdOutArray, kTRUE);
    
  return kSUCCESS;
}

//EXEC
void TpcDataReaderTask::Exec(Option_t* opt)
{
  if (fVerbose) std::cout << "TpcDataReaderTask::Exec" << std::endl;
  
  // Reset output Arrays
  if(fSampleOutArray==0) 
    Fatal("TpcDataReaderTask::Exec()","No SampleOutArray");
  
  fSampleOutArray->Delete();
  fEventIdOutArray->Delete();
  
  const std::vector<TpcSample>* samples;
  double thr;
  
  while(fLoop<fIntree->GetEntries()) {
    //get the TpcEvent;    
    fIntree->GetEvent(fLoop);
    fLoop++;
    samples = fEv->getEventVector();
    if (fVerbose)
      std :: cout << "Copying "<< samples->size()<<" samples." <<std::endl; 
    
    if(samples->size()<fCutoff)
      continue; 
    
    fEventNb = fEv->getEventNb();
    fSpillNb = fEv->getSpillNb();
    fRunNr = fEv->getRunNb();
    fTimeStamp = fEv->getTime();
    
    
    
    TpcEventIdentifier* id = new((*fEventIdOutArray)[0]) TpcEventIdentifier(fEventNb,
									    fSpillNb,
									    fRunNr,
									    fTimeStamp);
    if (fVerbose)
      std :: cout << "Saving "<< samples->size()<<" samples" <<std::endl;  
    
    unsigned int samplecounter=0;
    for(unsigned int i=0; i<samples->size(); i++)
      {
	thr=samthr;
	if (TpcSample((*samples)[i]).padId()>0)
	    if(sigmas.size() >= TpcSample((*samples)[i]).padId())
	      {
		thr=sigmas[TpcSample((*samples)[i]).padId()]*samthr;
	      }

	if (TpcSample((*samples)[i]).amp()>thr)
	  {
	    TpcSample* s=new ((*fSampleOutArray)[samplecounter]) TpcSample((*samples)[i]);
	    s->setIndex(samplecounter);
	    samplecounter++;
	  }
      }
        
    return;
  }
  return;
}
	


void
TpcDataReaderTask::SetParContainers() {
  
  std::cout<<"TpcDataReaderTask::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");
}