// #include "evt/Event.hh"
// #include <Bbos/bank_interface.hh>
#include <string>
#include <AbsEnv/AbsEnv.hh>

#include <iostream>

#include <Stntuple/obj/TStnEvent.hh>
#include <Stntuple/obj/TStnCosmicBlock.hh>
#include <Stntuple/obj/TStnMuonBlock.hh>
#include "CosmicObjects/CosmicRayInfo.hh"
#include <Stntuple/mod/InitStntupleDataBlocks.hh>
#include <Stntuple/mod/StntupleUtilities.hh>


//_____________________________________________________________________________
Int_t StntupleInitCosmicBlock(TStnDataBlock* block, 
			      AbsEvent*      event, 
			      int            mode) 
{
  // fill muon data block with the event data

  int   ev_number, rn_number;
  char  process[100], description[100], coll_type[100];

  ev_number = AbsEnv::instance()->trigNumber();
  rn_number = AbsEnv::instance()->runNumber();

  if (block->Initialized(ev_number,rn_number)) return 0;

  TStnCosmicBlock* data = (TStnCosmicBlock*) block;
  data->Clear();

  StntupleGetProcessName(data->CollName()->Data(), process, description, coll_type);

  //Assume that find only one CosmicRayInfo in the event record
  EventRecord::ConstIterator ci;
  ci = StntupleGetIterator(event,"CosmicRayInfo",process,description);
  if (! ci.is_valid()) return -2;
  ConstHandle<CosmicRayInfo> cosmicHdl(ci);
  
  data->fCosmicBit     = cosmicHdl->bitword();

  data->fNLegs         = cosmicHdl->numLegs();

  data->fDPhiMuStub    = cosmicHdl->dPhiMuStub();
  data->fAcollinearity = cosmicHdl->acollinearity();
  data->fD0Rho         = cosmicHdl->d0Rho();
  data->fD0Beta        = cosmicHdl->d0Beta();
  data->fDPhi          = cosmicHdl->dPhi();
  data->fSumEta        = cosmicHdl->sumEta();

  data->fZi       = cosmicHdl->seedZ();
  data->fdZi      = cosmicHdl->seedZErr();
  data->fNTrkVtx  = cosmicHdl->vtxNTrk(); 
  data->fZt       = cosmicHdl->vtxMean();
  data->fdZt      = cosmicHdl->vtxErr();
  
  //Fill per leg quantities
  for(int ileg=0; ileg<2; ileg++){
    data->fTrackId[ileg]=cosmicHdl->trkId(ileg);

    data->fPt[ileg]=cosmicHdl->pt(ileg);
    data->fCrv[ileg]=cosmicHdl->curvature(ileg); 
    data->fCot[ileg]=cosmicHdl->lambda(ileg); 
    data->fPhi[ileg]=cosmicHdl->phi(ileg);  
    data->fEta[ileg]=cosmicHdl->eta(ileg); 
    data->fZ0[ileg]=cosmicHdl->z0(ileg); 
    data->fD0[ileg]=cosmicHdl->d0(ileg);
    data->fD0C[ileg]=cosmicHdl->d0C(ileg); 
    data->fAlgo[ileg]=cosmicHdl->algo(ileg);

    data->fDeltaT0[ileg]=cosmicHdl->deltaT0(ileg);
    data->fErrorDeltaT0[ileg]=cosmicHdl->errorDeltaT0(ileg);
    data->fDeltaBetaInv[ileg]=cosmicHdl->deltaBetaInv(ileg);
    data->fErrorDeltaBetaInv[ileg]=cosmicHdl->errorDeltaBetaInv(ileg);
    for(int itype=0; itype<2; itype++){
      data->fFitT0[ileg][itype]=cosmicHdl->fitT0(ileg,itype);
      data->fFitdT0[ileg][itype]=cosmicHdl->fitErrT0(ileg,itype);
      data->fFitCrdT0[ileg][itype]=cosmicHdl->fitCrudeT0(ileg,itype);
      data->fFitChi2[ileg][itype]=cosmicHdl->fitChi2(ileg,itype);
      data->fFitdChi2[ileg][itype]=cosmicHdl->fitDeltaChi2(ileg,itype);
      data->fFitDir[ileg][itype]=cosmicHdl->fitDirection(ileg,itype); 
      data->fFitNCOTH[ileg][itype]=cosmicHdl->fitNHits(ileg,itype);  
      data->fFitNCOTHExp[ileg][itype]=cosmicHdl->fitNExpHits(ileg,itype);
    }

    data->fEmE[ileg]=cosmicHdl->emEnergy(ileg);
    data->fHadE[ileg]=cosmicHdl->hadronEnergy(ileg);
    data->fHadTDC[ileg]=cosmicHdl->hadronTDCTime(ileg);
    data->fNgbrEmE[ileg]=cosmicHdl->neighborEmEnergy(ileg);
    data->fNgbrHadE[ileg]=cosmicHdl->neighborHadronEnergy(ileg);
    data->fNgbrHadTDC[ileg]=cosmicHdl->neighborhadronTDCTime(ileg);

    data->fTof[ileg]=cosmicHdl->timeOfFlight(ileg);
    data->fTofM[ileg]=cosmicHdl->tofMethod(ileg);    

    data->fCsp[ileg]=cosmicHdl->cspTime(ileg);
    data->fCsx[ileg]=cosmicHdl->csxTime(ileg);

    data->fStubPhi[ileg]=cosmicHdl->muonStubPhi(ileg);
  }//end loop over legs
                                        // set event and run numbers to 
					// mark block as initialized
  data->f_RunNumber   = rn_number;
  data->f_EventNumber = ev_number;


  //  data->Print();

  return 0;
}


//_____________________________________________________________________________
Int_t StntupleCosmicBlockLinks(TStnDataBlock* block,AbsEvent* event,int mode) 
{
  Int_t         rc;
  int                ev_number, rn_number;

  TStnCosmicBlock*     cosmic_block = (TStnCosmicBlock*) block;

  ev_number = AbsEnv::instance()->trigNumber();
  rn_number = AbsEnv::instance()->runNumber();

  if (! block->Initialized(ev_number,rn_number)) return -1;

					// do not do initialize links 2nd time
  if (block->LinksInitialized()) return 0;


  //-----------------------------------------------------------------------------
  // fill muon link block
  //-----------------------------------------------------------------------------

  TStnMuonBlock* muon_block;
  TStnEvent* ev = cosmic_block->GetEvent();
  muon_block   = (TStnMuonBlock*) ev->GetDataBlock("MuonBlock");

  rc = 0;

  for(int ileg=0; ileg<2; ileg++){
    CdfMuonView_ch cosmicMuon;
    bool cosmicMuonStatus = CdfMuonView::find(cosmicMuon,"CosmicMuons");
    if(cosmicMuonStatus){
      for (CdfMuonView::const_iterator imu = cosmicMuon->contents().begin();
	   imu != cosmicMuon->contents().end(); ++imu) {
	const CdfMuon& muon = **imu;
	const CdfMuon* muptr= (CdfMuon*) &(**imu);
	const CdfTrack& track = *(muon.bestTrack());

	if(cosmic_block->TrackId(ileg)==track.id().value()){//cosmic muon match leg(i)
	  Int_t it = muon_block->MuonNumber(muptr);
	  cosmic_block->SetMuonNumber(it,ileg);
	  //	  printf("Match CosmicMuon View to Muon Block, muon at position %i\n",it);
	}
      }//end loop over cosmic muons
    }
  }

 
//-----------------------------------------------------------------------------
// mark links as initialized
//-----------------------------------------------------------------------------
  block->SetLinksInitialized();
  return rc;
}