//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Reading data from the FOPI data files and provide it to
//      the framework.
//      Compares to eventNb/SpillNb from TPC data
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Felix Boehmer                      (original author)
//	Sverre Doerheim			   (added helitron/plawa)
//      Paul Buehler      		   (added helitron/plawa)
//      Physics Department E18, TUM
//
//
//-----------------------------------------------------------


#include "FopiDataReaderTask.h"

#include "TpcEventIdentifier.h"

#include "FopiEvent.h"
#include "CdcHit.h"
#include "CdcTrack.h"
#include "RpcTrack.h"
#include "BarrelTrack.h"
#include "HeliHit.h"
#include "HeliTrack.h"
#include "PlawaTrack.h"

#include "TFile.h"
#include "TClonesArray.h"
#include "TTree.h"
#include "TTreeIndex.h"

#include <iostream>

static unsigned int fEvInTree = 0;



FopiDataReaderTask::FopiDataReaderTask()
: fPersistence(kFALSE),
  fFopiEventInBranch("FopiEventBr"),	       
  fCdcHitInBranch("CdcHitBr"),
  fCdcTrackInBranch("CdcTrackBr"),
  fRpcTrackInBranch("RpcTrackBr"),
  fBarrelTrackInBranch("BarrelTrack"),
  fHeliHitAllInBranch("HeliHitAllBr"),
  fHeliTrackInBranch("HeliTrackBr"),
  fHeliHitInBranch("HeliHitBr"),
  fPlawaHitAllInBranch("PlawaHitAllBr"),
  fPlawaTrackInBranch("PlawaTrackBr"),
  fTpcEventIDBranch("TpcEventIdentifier"),
  fInputFileName(""),
  fInputFile(NULL),
  fFopiTreeName("FOPITree"),
  fNFopiEvents(0),
  fCdcHitInArray(NULL),
  fCdcTrackInArray(NULL),
  fRpcTrackInArray(NULL),
  fBarrelTrackInArray(NULL),
  fHeliHitInArray(NULL),
  fPlawaTrackInArray(NULL),
  fHeliHitAllInArray(NULL),
  fPlawaHitAllInArray(NULL),
  fFopiEventInArray(NULL),
  fBarrelOn(kFALSE),
  fCdcHitPersistence(fPersistence),
  fCdcTrackPersistence(fPersistence),
  fRpcTrackPersistence(fPersistence),
  fHeliHitPersistence(fPersistence),
  fHeliHitAllPersistence(fPersistence),
  fHeliTrackPersistence(fPersistence),
  fPlawaHitAllPersistence(fPersistence),
  fPlawaTrackPersistence(fPersistence),
  DEBUG(false),
  fDisableHeliTracks(kFALSE)
{
  ;
}


FopiDataReaderTask::~FopiDataReaderTask() {
   if(fInputFile!=NULL && fInputFile->IsZombie() == false) {
    fInputFile->Close();
    delete fInputFile;
  }    
}

InitStatus
FopiDataReaderTask::Init() {
  if(fInputFileName.Length() < 2) {
    Error("FopiDataReaderTask::Init()", "No Input file given");
    return kERROR;
  }
  
  fInputFile = new TFile(fInputFileName, "read");
  //check if valid
  if(fInputFile->IsZombie()) {
    Error("FopiDataReaderTask::Init()", "Input file not ok");
    return kERROR;
  }
    
  //TODO: check for valid keys (as I did in time extraction code)
  fFopiTree = (TTree*) fInputFile->Get(fFopiTreeName);
  fNFopiEvents = fFopiTree->GetEntriesFast();
  //connect input arrays
  fFopiTree->SetBranchAddress(fCdcTrackInBranch, &fCdcTrackInArray);
  fFopiTree->SetBranchAddress(fRpcTrackInBranch, &fRpcTrackInArray);
  if(!fDisableHeliTracks) 
    fFopiTree->SetBranchAddress(fHeliTrackInBranch, &fHeliTrackInArray);
  fFopiTree->SetBranchAddress(fPlawaTrackInBranch, &fPlawaTrackInArray);
  fFopiTree->SetBranchAddress(fHeliHitAllInBranch, &fHeliHitAllInArray);   
  fFopiTree->SetBranchAddress(fPlawaHitAllInBranch, &fPlawaHitAllInArray);   
  if(fBarrelOn){
    fFopiTree->SetBranchAddress(fBarrelTrackInBranch, &fBarrelTrackInArray);
  }
  fFopiTree->SetBranchAddress(fCdcHitInBranch, &fCdcHitInArray);
  fFopiTree->SetBranchAddress(fHeliHitInBranch, &fHeliHitInArray);
  fFopiTree->SetBranchAddress(fFopiEventInBranch, &fFopiEventInArray);
  
  //build output arrays
  fFopiEventArray = new TClonesArray("FopiEvent");
  fCdcHitArray   = new TClonesArray("CdcHit");
  fCdcTrackArray = new TClonesArray("CdcTrack");
  fRpcTrackArray = new TClonesArray("RpcTrack");
  fHeliHitArray   = new TClonesArray("HeliHit");
  if(!fDisableHeliTracks) 
    fHeliTrackArray = new TClonesArray("HeliTrack");
  fPlawaTrackArray = new TClonesArray("PlawaTrack");
  fHeliHitAllArray = new TClonesArray("HeliHit");  
  fPlawaHitAllArray = new TClonesArray("PlawaTrack");
  if(fBarrelOn){
    fBarrelTrackArray = new TClonesArray("BarrelTrack");
  }
  fTpcEventID    = new TClonesArray("TpcEventIdentifier");

  //connect to the framework:
  FairRootManager* ioman = FairRootManager::Instance();
  if(ioman==0) {
    Fatal("FopiDataReaderTask::Init()","RootManager not instantiated!");
    return kFATAL;
  }
  // Get TPC EventID info
  fTpcEventID = (TClonesArray*) ioman->GetObject(fTpcEventIDBranch);
  // Register output arrays
  
  ioman->Register("CdcHit", "FopiCdc", fCdcHitArray, fCdcHitPersistence);
  ioman->Register("CdcTrack", "FopiCdc", fCdcTrackArray, fCdcTrackPersistence);
  ioman->Register("RpcTrack", "FopiRpc", fRpcTrackArray, fRpcTrackPersistence);
  ioman->Register("HeliHit", "FopiHelitron", fHeliHitArray, fHeliHitPersistence);
  if(!fDisableHeliTracks) 
    ioman->Register("HeliTrack", "FopiHelitron", fHeliTrackArray, fHeliTrackPersistence);
  ioman->Register("PlawaTrack", "FopiPlawa", fPlawaTrackArray, fPlawaTrackPersistence);
  ioman->Register("HeliHitAll","FopiPlawa", fHeliHitAllArray, fHeliHitAllPersistence);
  ioman->Register("PlawaHitAll","FopiPlawa", fPlawaHitAllArray, fPlawaHitAllPersistence);
  if(fBarrelOn){
    ioman->Register("BarrelTrack", "FopiBarrel", fBarrelTrackArray, fPersistence);
  }
  ioman->Register("FopiEvent", "Fopi", fFopiEventArray, fPersistence);

  //build tree Index for fast access later on:
  std::cout<<"FopiDataReaderTask::Init() Building tree index ... "
	   <<std::endl;
  TString major = fFopiEventInBranch;
  TString minor = major;
  //please let us never change the accessor names
  major += ".GetSpillNum()";
  minor += ".GetEvtNum()";
  int nE = fFopiTree->BuildIndex(major, minor);
  std::cout<<"   ... Index has "<<nE<<" entries"<<std::endl;
  if(nE<1) {
    Fatal("FopiDataReaderTask::Init()",
	  "Failed to create Index of FOPI input tree");
  }
  fFopiIndex = (TTreeIndex*) fFopiTree->GetTreeIndex();  //Tree has ownership
  if(DEBUG)
    fFopiIndex->Print();
}

void
FopiDataReaderTask::Exec(Option_t* opt) {

  //clear output arrays:
  if(fCdcHitArray!=NULL) //could never happen, but let's be paranoid
    fCdcHitArray->Delete();
  if(fCdcTrackArray!=NULL)
    fCdcTrackArray->Delete();
  if(fRpcTrackArray!=NULL)
    fRpcTrackArray->Delete();
  //
  if(fHeliHitArray!=NULL) //could never happen, but let's be paranoid
    fHeliHitArray->Delete();

  if(fHeliTrackArray!=NULL && fDisableHeliTracks==false)
    fHeliTrackArray->Delete();
  if(fPlawaTrackArray!=NULL)
    fPlawaTrackArray->Delete();
  if(fHeliHitAllArray!=NULL)
    fHeliHitAllArray->Delete();
  if(fPlawaHitAllArray!=NULL)
    fPlawaHitAllArray->Delete();

  if(fBarrelOn){
  if(fBarrelTrackArray!=NULL)
    fBarrelTrackArray->Delete();}
  if(fFopiEventArray!=NULL)
    fFopiEventArray->Delete();

  if(fTpcEventID->GetEntriesFast()<1) {
    Fatal("FopiDataReaderTask::Exec()","No TPC EventID found!");
    return;
  }
  
  TpcEventIdentifier* tpcid = (TpcEventIdentifier*)(*fTpcEventID)[0];
  unsigned int tpcEvent = tpcid->getEventInSpill();
  unsigned int tpcSpill = tpcid->getSpill();
  //if(DEBUG) {
    std::cout<<"looking for entry with\n"
	     <<"   Spill: "<<tpcSpill<<"\n"
	     <<"   Event: "<<tpcEvent<<"\n";
    //}
  int treeEv = fFopiIndex->GetEntryNumberWithIndex((int)tpcSpill,
						  (int)tpcEvent);
  fprintf(stderr,"Fopi event: %i\n",treeEv);
  if(treeEv<0) {
    Warning("FopiDataReaderTask::Exec()",
	    "No matching Entry in Fopi Tree could be found");
    return;
  }
  
  // get event from FOPITree
  fEvInTree=treeEv;			       
  fFopiTree->GetEvent(fEvInTree);

  std::cout<<"  ... retrieved event "<<fEvInTree<<"\n";

  //if we reach this point we can proceed to read in the actual data (yay.)
  for(unsigned int iHit=0; iHit<fCdcHitInArray->GetEntriesFast(); iHit++) {
    CdcHit* hit = (CdcHit*)(*fCdcHitInArray)[iHit];
    hit  = new ((*fCdcHitArray)[fCdcHitArray->GetEntriesFast()]) CdcHit(*hit);
  }

  for(unsigned int iHit=0; iHit<fHeliHitInArray->GetEntriesFast(); iHit++) {
    HeliHit* hit = (HeliHit*)(*fHeliHitInArray)[iHit];
    hit  = new ((*fHeliHitArray)[fHeliHitArray->GetEntriesFast()]) HeliHit(*hit);
  }
  
  for(unsigned int iTrack=0; iTrack<fRpcTrackInArray->GetEntriesFast(); iTrack++) {
    RpcTrack* rpctrk =  (RpcTrack*)(*fRpcTrackInArray)[iTrack];
    rpctrk  = new ((*fRpcTrackArray)[fRpcTrackArray->GetEntriesFast()]) RpcTrack(*rpctrk);
  }

  if(fBarrelOn){
    for(unsigned int iTrack=0; iTrack<fBarrelTrackInArray->GetEntriesFast(); iTrack++) {
      BarrelTrack* barreltrk =  (BarrelTrack*)(*fBarrelTrackInArray)[iTrack];
      barreltrk  = new ((*fBarrelTrackArray)[fBarrelTrackArray->GetEntriesFast()]) BarrelTrack(*barreltrk);
    }
  }
    
  
  for(unsigned int iTrack=0; iTrack<fCdcTrackInArray->GetEntriesFast(); iTrack++) {
    CdcTrack* track = (CdcTrack*)(*fCdcTrackInArray)[iTrack];
    track  = new ((*fCdcTrackArray)[fCdcTrackArray->GetEntriesFast()]) CdcTrack(*track);
  }
  
  if(!fDisableHeliTracks) {
    for(unsigned int iTrack=0; iTrack<fHeliTrackInArray->GetEntriesFast(); iTrack++) {
      HeliTrack* track = (HeliTrack*)(*fHeliTrackInArray)[iTrack];
      track  = new ((*fHeliTrackArray)[fHeliTrackArray->GetEntriesFast()]) HeliTrack(*track);
    // currently Plawa/Heli/Barrel matching is done in DST2ROOT so that the Heli tracks are also Plawa and Barrel tracks
      PlawaTrack* plawatrk =  (PlawaTrack*)(*fPlawaTrackInArray)[iTrack];
      plawatrk  = new ((*fPlawaTrackArray)[fPlawaTrackArray->GetEntriesFast()]) PlawaTrack(*plawatrk);
    }
  }

  // Helitron hits, all
  for(unsigned int iHit=0; iHit<fHeliHitAllInArray->GetEntriesFast(); iHit++) {
    HeliHit* hit = (HeliHit*)(*fHeliHitAllInArray)[iHit];
    hit  = new ((*fHeliHitAllArray)[fHeliHitAllArray->GetEntriesFast()]) HeliHit(*hit);
  }

  
  // Plawa hits, all
  for(unsigned int iHit=0; iHit<fPlawaHitAllInArray->GetEntriesFast(); iHit++) {
    PlawaTrack* hit = (PlawaTrack*)(*fPlawaHitAllInArray)[iHit];
    hit  = new ((*fPlawaHitAllArray)[fPlawaHitAllArray->GetEntriesFast()]) PlawaTrack(*hit);
  }

  
  FopiEvent* event = (FopiEvent*)(*fFopiEventInArray)[0];
  event  = new ((*fFopiEventArray)[fFopiEventArray->GetEntriesFast()]) FopiEvent(*event);
  
  tpcid->setTriggerMask(event->GetTriggerPattern());
  return;
}





void
FopiDataReaderTask::SetPersistence(Bool_t opt) {
  fPersistence = opt;
  fCdcHitPersistence = opt;
  fCdcTrackPersistence = opt;
  fRpcTrackPersistence = opt;
  fHeliHitPersistence = opt;
  fHeliHitAllPersistence = opt;
  fHeliTrackPersistence = opt;
  fPlawaHitAllPersistence = opt;
  fPlawaTrackPersistence = opt;
}
ClassImp(FopiDataReaderTask)