//-----------------------------------------------------------------------------
//                     : initialization of the STNTUPLE SecVtx block
//-----------------------------------------------------------------------------
#include <AbsEnv/AbsEnv.hh>

#include <TrackingObjects/Storable/CdfTrackColl.hh>
#include <TrackingObjects/Storable/CdfTrackView.hh>

#include <Stntuple/mod/StntupleUtilities.hh>
// #include <Stntuple/alg/TStntuple.hh>

#include <Stntuple/obj/TStnTrackBlock.hh>
#include <Stntuple/mod/InitStntupleDataBlocks.hh>

#include <Stntuple/obj/TStnEvent.hh>
#include <Stntuple/obj/TStnNode.hh>
#include "TBranch.h"
#include <BTagObjects/SecVtxColl.hh>
#include <BTagObjects/SecVtxObj.hh>
#include <Stntuple/obj/TStnSecVtxTag.hh>
#include <Stntuple/obj/TStnSecVtxTagBlock.hh>

#include <Stntuple/obj/TStnJetBlock.hh>


#include <sstream>


//_____________________________________________________________________________
Int_t StntupleInitSecVtxTag(TStnSecVtxTag* secv, const SecVtxObj* iter, int ijet) {
  
  if ( iter == NULL ){
    secv->fTag = 0;
    return 0;
  }
  
  secv->fJet = ijet;
  secv->fNTrackGd  = iter->getngd();
  secv->fNTrackSd1 = iter->getnsd();
  secv->fNTrackSd2 = iter->getnsd2();
  secv->fNTrackTg  = iter->getntg();
      
  secv->fTag = iter->getagsec();
  secv->fPass = iter->getpass();
  secv->fCharge = iter->getcharge();

  secv->fL3d = iter->getl3d();
  secv->fDl3d = iter->getdl3d();
  secv->fL2d = iter->getl2d();
  secv->fDl2d = iter->getdl2d();
  secv->fLzd = iter->getlzd();
  secv->fDlzd = iter->getdlzd();
  secv->fChisq = iter->getchisq();
  secv->fChisqr = iter->getchisqr();
  secv->fChisqz = iter->getchisqz();

  Hep3Vector   p3 = iter->getxyzsec();
  secv->fSecVertex.SetXYZ(p3.x(),p3.y(),p3.z());

  HepSymMatrix e3 = iter->getexyzsec(); // Returned by value, not ref!
  
  for (int i=0; i<3; i++) {
    for (int j=0; j<3; j++) {
      if ( iter->getagsec() == 0 ){
	secv->fErrorMatrix(i,j) = 0;
      }else {
	secv->fErrorMatrix(i,j) = e3[i][j];
      }
    }
  }

  HepLorentzVector   p = iter->p4sec();
  secv->fSecVertex4.SetXYZT(p.px(),p.py(),p.pz(),p.e());  

  return 0;
}

//_____________________________________________________________________________
Int_t StntupleSecVtxTagBlockLinks(TStnDataBlock* Block, 
				  AbsEvent*      Event, 
				  int            Mode) {
  // this routine is called from StntupleMakerModule and assumes
  // that the JetBlock and TrackBlock have already been filled (this assumption is 
  // essential) and fills secvtx data block

  int ev_number, rn_number;
  // check if block has already been 
  // initialized
  
  ev_number = AbsEnv::instance()->trigNumber();
  rn_number = AbsEnv::instance()->runNumber();
  
  if (Block->Initialized(ev_number,rn_number)) return 0;
  
  TStnSecVtxTagBlock* data = (TStnSecVtxTagBlock*) Block;
  data->Clear();
  
  data->f_EventNumber = ev_number;
  data->f_RunNumber   = rn_number;
  
  SecVtxColl_ch theHandle; 

  // this is a string like "PROD@SecVtxModule-JetCluModule-cone0.4"
  std::string secVtxCollName = data->CollName()->Data();

  // proc is before the "@", desc is after
  char  proc[100], desc[100];
  StntupleGetProcessName(secVtxCollName.c_str(),proc,desc);

  std::string acdesc(desc);
  SecVtxColl::Error theStatus=SecVtxColl::find(theHandle,acdesc); 

  if (theStatus ==SecVtxColl::ERROR) {
    std::cerr <<"InitSecVtxLinks: Could not find SecVtx Collection:"
	      << acdesc << std::endl;
    return -1;
  }

  // find the jet collection which has the corresponding AC++ collection name
  TStnJetBlock* jet_block = NULL;
  TString jetCollName(theHandle->jetcol().c_str());
  jetCollName.Prepend("@");
  jetCollName.Prepend(proc);

  // search though the branches to get the one for this collection
  TStnEvent* ev = data->GetEvent();
  TObjArray* oNodes = ev->GetListOfNodes();
  TIter it(oNodes);
  while(TStnNode* node = (TStnNode*) it.Next()) {
    if(*(node->GetDataBlock()->CollName())==jetCollName) {
      jet_block = (TStnJetBlock*) node->GetDataBlock();
    }
  }

  if (!jet_block) {
    std::cerr <<"InitSecVtxLinks: Could not find Jet Block"
	      << jetCollName<< std::endl;
    return -1;
  }

  TStnTrackBlock *tdata = (TStnTrackBlock*) ev->GetDataBlock("TrackBlock");
  if (! tdata) {
    std::cerr <<"InitSecVtxLinks: Could not find track Block" << std::endl;    
    return -1;
  }

  // save SecVtxColl stuff 

  data->fConeSize = theHandle ->conesize();
  data->fEtCut    = theHandle ->etcut(); 
  data->fEtaCut   = theHandle ->etacut();
  data->fIs_Caljet = theHandle ->calj(); 

  // Initialize the link blocks to the right size
  int nsecvtx = theHandle->contents().size();
  data->fTrackGd.Init(nsecvtx);  
  data->fTrackSd1.Init(nsecvtx);  
  data->fTrackSd2.Init(nsecvtx);  
  data->fTrackTg.Init(nsecvtx);  

  // Loop over Weiming's collection of SecVtxObjs
  for(SecVtxColl::const_iterator iter =theHandle->contents().begin();
      iter !=theHandle->contents().end(); ++iter) { 

    // Make a new TStnSecVtxObj in the TClonesArray
    TStnSecVtxTag* secv = data->NewSecVtxTag();
    StntupleInitSecVtxTag(secv,&*iter,jet_block->JetNumber(&(*iter->getijet())));
      
    // Now make links to tracks used in the tag.
    // If you can't find the track in the track block at first,
    // check it's parent because it may have been refitted in SecVtxModule
    data->fTrackGd.InitLinks(data->fNSecVtxTag-1);  
    for (int i=0; i<iter->getngd(); i++) {
      int itrk = tdata->TrackNumber(&*iter->getrackgd(i));
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getrackgd(i)->parent());
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getrackgd(i)->derived());
      if (itrk>=0) data->fTrackGd.Add(data->fNSecVtxTag-1, itrk);
    }
    data->fTrackSd1.InitLinks(data->fNSecVtxTag-1);  
    for (int i=0; i<iter->getnsd(); i++) {
      int itrk = tdata->TrackNumber(&*iter->getracksd(i));
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracksd(i)->parent());
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracksd(i)->derived());
      if (itrk>=0) data->fTrackSd1.Add(data->fNSecVtxTag-1, itrk);
    }
    data->fTrackSd2.InitLinks(data->fNSecVtxTag-1);  
    for (int i=0; i<iter->getnsd2(); i++) {
      int itrk = tdata->TrackNumber(&*iter->getracksd2(i));
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracksd2(i)->parent());
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracksd2(i)->derived());
      if (itrk>=0) data->fTrackSd2.Add(data->fNSecVtxTag-1, itrk);
    }
    data->fTrackTg.InitLinks(data->fNSecVtxTag-1);  
    for (int i=0; i<iter->getntg(); i++) {
      int itrk = tdata->TrackNumber(&*iter->getracktg(i));
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracktg(i)->parent());
      if (itrk<0) itrk = tdata->TrackNumber(&*iter->getracktg(i)->derived());
      if (itrk>=0) data->fTrackTg.Add(data->fNSecVtxTag-1, itrk);
    }
  }

  return 0;
}

Int_t StntupleInitSecVtxTagBlock(TStnDataBlock* Block, 
				 AbsEvent*      Event, 
				 int            Mode) {
  // this routine is now largely useless

  TStnSecVtxTagBlock *data = (TStnSecVtxTagBlock*) Block;
  if (! data) return -1;
  
  return 0;
}