#include "ITreeMaker.hxx"
//#include <ITFBmcDigit.hxx>
//#include <ITFBChannelId.hxx">
#include <IIntegerDatum.hxx>
//#ifdef MAKEHITS
#include <IGeomInfo.hxx>
#include <IMCHit.hxx>
//#endif
//#include <IHitSelection.hxx>

#include <iostream>
#include <cassert>

using COMET::ITreeMaker;
using std::cout;
using std::endl;

//----------------------------------------------------------------------
void ITreeMaker::Initialize()
{
  if (!gFile->IsWritable()){
    cout << "Can't find suitable file for putting output trees in" << endl;
    assert(0);
  }

  fDigitSimTree = new TTree("simdigits","IDigit level quantities");
  fDigitSimTree->SetDirectory(0);
  fDigitSimTree->Branch("chan",  &fChan,  "chan/i");
  fDigitSimTree->Branch("tfb",   &fTfb,   "tfb/i");
  fDigitSimTree->Branch("rmm",   &fRmm,   "rmm/i");
  fDigitSimTree->Branch("subdet",&fSubdet,"subdet/i");
  //fDigitSimTree->Branch("side",  &fSide,  "side/I");
  fDigitSimTree->Branch("err",   &fErr,   "err/i");
  fDigitSimTree->Branch("tdc",   &fTdc,   "tdc/L");
  fDigitSimTree->Branch("t",   &fT,   "coarse/i:fine/i");
  fDigitSimTree->Branch("adc",   &fAdc,   "lo/I:hi/I");
  fDigitSimTree->Branch("event", &fEvent, "event/I");
  fDigitSimTree->Branch("tdctrig", &fTdcTrig, "tdctrig/L");
  fDigitSimTree->Branch("tdcread", &fTdcRead, "tdcread/L");


  fHitTree = new TTree("hits","IHit level quantites");
  fHitTree->SetDirectory(0);
  fHitTree->Branch("time",   &fTime,   "time/F");
  fHitTree->Branch("charge", &fCharge, "charge/F");
  fHitTree->Branch("geomId",&fGeomId,"geomId/i");
  fHitTree->Branch("pos",    &fPos,    "x/F:y/F:z/F");
  fHitTree->Branch("xlayer",  &fXLayer,  "xlayer/I");
  fHitTree->Branch("ylayer",  &fYLayer,  "ylayer/I");
  fHitTree->Branch("bar",    &fBar,    "bar/I");
  fHitTree->Branch("end",    &fEnd,    "end/I");
  fHitTree->Branch("event",  &fEvent,  "event/I");
  fHitTree->Branch("timeread", &fTimeRead, "timeread/F");
  fHitTree->Branch("chan",  &fChan,  "chan/i");
  fHitTree->Branch("tfb",   &fTfb,   "tfb/i");
  fHitTree->Branch("rmm",   &fRmm,   "rmm/i");
  fHitTree->Branch("subdet",&fSubdet,"subdet/i");
}

//----------------------------------------------------------------------
bool ITreeMaker::operator() (COMET::ICOMETEvent& event)
{
  fEvent = event.GetEventId();
  
  fTdcTrig = 0;
  
  COMET::IHandle<COMET::IIntegerDatum> mcmTrigTime 
    = event.Get<COMET::IIntegerDatum>("mcmTrigTime");
  if (mcmTrigTime){
    UInt_t trigger_mcmTDC = static_cast<UInt_t>(mcmTrigTime->GetValue());
    const Long64_t mcmTick(4LL);
    fTdcTrig = mcmTick * trigger_mcmTDC; 
  }
  

  fTdcRead = 0;
  COMET::IHandle<COMET::IIntegerDatum> mcmTimeSinceBusy
    = event.Get<COMET::IIntegerDatum>("mcmTimeSinceBusy");
  if (mcmTimeSinceBusy){
    UInt_t dt_bktTrig_mcmTDC = static_cast<UInt_t>(mcmTimeSinceBusy->GetValue());
    const Long64_t mcmTick(4LL);
    fTdcRead = mcmTick * dt_bktTrig_mcmTDC;
    fTimeRead = (fTdcRead%260) * 2.5;
  }
  
  COMET::IHandle<COMET::IDataVector> digitV = event.Get<COMET::IDataVector>("digits");
  for (COMET::IDataVector::iterator diter = digitV->begin();
       diter != digitV->end(); ++diter){
    COMET::IDigitContainer* digList = dynamic_cast<COMET::IDigitContainer*>(*diter);
    if (digList){
      std::string dt_name = digList->GetName(); dt_name += "digits";
      TTree* digitTree = FindOrClone(dt_name.c_str(), fDigitSimTree);
      COMET::IDigitContainer::iterator digItr;
      for (digItr=digList->begin(); digItr!=digList->end(); ++digItr){
	/*
	ITFBDigit* digit = dynamic_cast<ITFBDigit*> (*digItr);
	if (!digit) {
	  continue;
	}
	ITFBChannelId id(digit->GetChannelId());
	fChan = id.GetChannel() + 16*id.GetTripChip();
	fTfb = id.GetTFB();
	fRmm = id.GetRMM();
	fSubdet = id.GetSubDetector();
	fSide = 0;
	fErr = 0;
	fErr += (digit->CheckTimeDiscriminator() ? 0x1 : 0);
	fTdc = digit->GetTDC();
	fT.coarse = digit->GetTimeCounter();
	fT.fine = UInt_t(digit->GetTimeQuad());
	//fTdc.upper = digit->GetTimeCounter();
	//fTdc.quad = digit->GetTimeQuad();
	fAdc.lo = digit->GetLowGainADC();
	fAdc.hi = digit->GetHighGainADC();
	
	digitTree->Fill();
	*/
      } //for (digItr)
    } //if (digList)
  } //for (digit containers)


//#ifdef MAKEHITS
  COMET::IHandle<COMET::IDataVector> hitV = event.Get<COMET::IDataVector>("hits");

  for(COMET::IDataVector::iterator hiter = hitV->begin();
      hiter != hitV->end(); ++hiter){
    COMET::IHitSelection* hitList = dynamic_cast<COMET::IHitSelection*>(*hiter);
    if (hitList){
      std::string ht_name = hitList->GetName(); ht_name += "hits";
      TTree* hitTree = FindOrClone(ht_name.c_str(), fHitTree);
      COMET::IHitSelection::iterator hitItr;
      for (hitItr=hitList->begin(); hitItr!=hitList->end(); ++hitItr){
	COMET::IHandle<COMET::IMCHit> hit = (*hitItr);
	fTime = hit->GetTime();
	fCharge = hit->GetCharge();
	fGeomId = hit->GetGeomId().AsInt();
	fPos.x = hit->GetPosition().X();
	fPos.y = hit->GetPosition().Y();
	fPos.z = hit->GetPosition().Z();
	std::string nodename = COMET::IGeomInfo::Get().NodeName(hit->GetGeomId());
	//cout <<  COMET::IGeomInfo::Get().NodeName(hit->GetGeomId()) <<endl;
	fXLayer = LayerXFromName(nodename);
	fYLayer = LayerYFromName(nodename);
	fBar = BarFromName(nodename);
	fEnd = -1;
//	ITFBmcDigit* srcdigit = dynamic_cast<COMET::ITFBmcDigit*>(*(hit->GetDigit()));
/*
	ITFBChannelId id(hit->GetChannelId());
	fChan = id.GetChannel() + 16*id.GetTripChip();
	fTfb = id.GetTFB();
	fRmm = id.GetRMM();
 	fSubdet = id.GetSubDetector();
*/
	fSide = 0;
	fErr = 0;
	
	hitTree->Fill();
      }
    }  //if (hitList)
  } //for (hit selections)
//#endif
  return false;
}
//----------------------------------------------------------------------
void ITreeMaker::Finalize(ICOMETOutput* const output)
{
  //  output.GetListOfKeys()->FindObject("hits")->Delete();
  //cmt show usesoutput.GetListOfKeys()->FindObject("digits")->Delete();
}

//----------------------------------------------------------------------
int ITreeMaker::BarFromName(std::string name)
{
  std::string match("Bar_");
  if ( name.find(match) == name.npos ) return -1;
  std::string ss =name.substr(name.find(match)+match.size());
  return atoi(ss.c_str());
}

//----------------------------------------------------------------------
int ITreeMaker::LayerXFromName(std::string name)
{
  std::string match("ScintX1_");
  if ( name.find(match) == name.npos ) return -1;
  std::string ss =name.substr(name.find(match)+match.size());
  return atoi(ss.c_str());
}

//----------------------------------------------------------------------
int ITreeMaker::LayerYFromName(std::string name)
{
  std::string match("ScintY1_");
  if ( name.find(match) == name.npos ) return -1;
  std::string ss =name.substr(name.find(match)+match.size());
  return atoi(ss.c_str());
}

//----------------------------------------------------------------------
TTree* ITreeMaker::FindOrClone(const char* name, TTree* src){
  TTree* tree = dynamic_cast<TTree*>(gFile->Get(name));
  if (tree != 0x0) return tree;
  tree = src->CloneTree(0);
  tree->SetName(name);
  return tree;
}

//======================================================================
int main(int argc, char **argv) 
{
  COMET::ITreeMaker tm;
  cometEventLoop(argc, argv, tm);
}