///////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
#include "TROOT.h"
#include "TFolder.h"

#include "BaBar/Experiment.hh"
#include "Edm/EventRecord.hh"

#include "JetProbObjects/JPJet.hh"
#include "JetProbObjects/JPTrack.hh"
#include "JetProbObjects/JetProbColl.hh"

#include "TrackingObjects/Storable/CdfTrackView.hh"
#include "JetObjects/CdfJet.hh"
#include "JetObjects/CdfJetColl.hh"  
  
#include <Stntuple/mod/StntupleUtilities.hh>
#include <Stntuple/mod/InitStntupleDataBlocks.hh>
#include <Stntuple/obj/TStnEvent.hh>
#include <Stntuple/obj/TStnErrorLogger.hh>
#include <Stntuple/obj/TStnJetProbBlock.hh>
#include <Stntuple/obj/TStnJetBlock.hh>
#include <Stntuple/obj/TStnTrackBlock.hh>

namespace {
  TFolder*          fgFolder    = NULL;
  TStnErrorLogger*  fgLogger    = NULL;
}
//_____________________________________________________
Int_t StntupleInitJPTrack( TStnJPTrack* jptrack, const JPTrack* ming_track){

  const CdfTrack_clnk icdftrack = ming_track->CdfTrack();

  jptrack->fCdfTrack = (const CdfTrack*) icdftrack.operator->(); 

  jptrack-> fNumShSvxHit        = ming_track->NumSvxHit();                
  jptrack-> fNShSvxPhiHit       = ming_track->NShSvxPhiHit();               
  jptrack-> fNShSvxStHit        = ming_track->NShSvxStHit();                
  jptrack-> fNShSvxZHit         = ming_track->NShSvxZHit();                 
  jptrack-> fNShSvxLay          = ming_track->NShSvxLay();                  
  jptrack-> fInnermostRPhiLayer = ming_track->InnermostRPhiLayer();         
  jptrack-> fInnermostRZLayer   = ming_track->InnermostRZLayer();           

  jptrack-> fTrkQtyWordRPhi     = ming_track->TrkQtyWordRPhi();
  jptrack-> fTrkQtyWordRZ       = ming_track->TrkQtyWordRZ();

  for ( int i = 0; i < 2; i++)
    {
      for ( int j = 0; j < 8; j++)
	{
	  // jptrack-> fNumHitInLayer[i][j]   = ming_track->NumHitInLayer( i, j) ;        
	  // jptrack-> fNumShHitInLayer[i][j] = ming_track->NumShHitInLayer( i, j);   

	  jptrack-> fHitInfoInLayer[i][j]   = ming_track->HitInfoInLayer( i, j) ;        
	  jptrack-> fExptHitInfoInLayer[i][j] = ming_track->ExptHitInfoInLayer( i, j);   
    	}
    }

  jptrack-> fZ0            = ming_track->Z0();                         
  jptrack-> fZ0Err         = ming_track->Z0Err();                      
  jptrack-> fSignZ0        = ming_track->SignZ0();                     
  jptrack-> fD0            = ming_track->D0();                         
  jptrack-> fD0Err         = ming_track->D0Err();                      
  jptrack-> fSignD0        = ming_track->SignD0() ;                     
  
  jptrack-> fTrackProbRPhi = ming_track->TrackProbRPhi();              
  jptrack-> fTrackProbRZ   = ming_track->TrackProbRZ();                
  jptrack-> fTrackProb3D   = ming_track->TrackProb3D() ;                

  for ( int i = 0; i < 5; i++)
    {
      jptrack-> fTrackProb[i] = ming_track->TrackProb(i);                 
    }

  return 0;
}

//_____________________________________________________
Int_t StntupleInitJPJet( TStnJPJet* jpjet, const JPJet* ming_jet){

  jpjet-> fCdfJet = (CdfJet*) &ming_jet->JetLink(); 

  //  jpjet-> fJetId;                            

  jpjet-> fNumTrk         = ming_jet->NumTrk();                           
  jpjet-> fNumGoodRPTrk   = ming_jet->NumGoodRPTrk();                     
  jpjet-> fNGdRPTrkPosSIP = ming_jet->NGdRPTrkPosSIP();                   
  jpjet-> fNGdRPTrkNegSIP = ming_jet->NGdRPTrkNegSIP();                   
  	 				     
  jpjet-> fNumGoodRZTrk   = ming_jet->NumGoodRZTrk();                     
  jpjet-> fNGdRZTrkPosSIP = ming_jet->NGdRZTrkPosSIP();                   
  jpjet-> fNGdRZTrkNegSIP = ming_jet->NGdRZTrkNegSIP();                   
  	  				     
  jpjet-> fNumGood3DTrk   = ming_jet->NumGood3DTrk();                     
  jpjet-> fNGd3DTrkPosSIP = ming_jet->NGd3DTrkPosSIP();                   
  jpjet-> fNGd3DTrkNegSIP = ming_jet->NGd3DTrkNegSIP();                   
  jpjet-> fHFHepId        = ming_jet->JetHFHepId();
  jpjet-> fHFtag          = ming_jet->JetHFTag();
  
  jpjet-> fEt   = ming_jet->JetEt();
  jpjet-> fPhi  = ming_jet->JetPhi();
  jpjet-> fEta  = ming_jet->JetEta();
  jpjet-> fdRHF = ming_jet->JetHFdR();
  
  jpjet-> fJetProbRPUnSignSIP = ming_jet->JetProbRPUnSignSIP();             
  jpjet-> fJetProbRPPosSIP    = ming_jet->JetProbRPPosSIP();                
  jpjet-> fJetProbRPNegSIP    = ming_jet->JetProbRPNegSIP();                
  					    
  jpjet-> fJetProbRZUnSignSIP = ming_jet->JetProbRZUnSignSIP();              
  jpjet-> fJetProbRZPosSIP    = ming_jet->JetProbRZPosSIP();                 
  jpjet-> fJetProbRZNegSIP    = ming_jet->JetProbRZNegSIP();                 
  					     
  jpjet-> fJetProb3DUnSignSIP = ming_jet->JetProb3DUnSignSIP();               
  jpjet-> fJetProb3DPosSIP    = ming_jet->JetProb3DPosSIP();                  
  jpjet-> fJetProb3DNegSIP    = ming_jet->JetProb3DNegSIP();                  

  return 0;
}

//_____________________________________________________
Int_t StntupleInitJetProbBlock(TStnDataBlock* block, AbsEvent* event, int mode) 
{
  TStnJetBlock*    jet_block;
  //  int inum[100];
  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;

  if (! fgFolder) {
//-----------------------------------------------------------------------------
//  initialize local for the file static variables
//-----------------------------------------------------------------------------
    fgFolder = (TFolder*) gROOT->GetRootFolder()->FindObject("StntupleFolder");
    fgLogger = (TStnErrorLogger* ) fgFolder->FindObject("StntupleErrorLogger");
  }

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

  char  process[100], description[100];
  char jetAlgName[100], jetBlockName[100];
  StntupleGetProcessName(data->CollName()->Data(),process,description);
  if ( strcmp(description,"none") == 0) {
	 sprintf(jetBlockName,"JetBlock");
  }
  else if ( strcmp(description,"JetProbModule") == 0) {
	 sprintf(jetBlockName,"JetBlock");
  }
  else {
	 for ( int i = 0; i < 100; i++) jetAlgName[i] = description[14+i];
	 sprintf(jetBlockName,"%s@%s",process,jetAlgName);
}
 
  data->f_EventNumber = ev_number;
  data->f_RunNumber   = rn_number;

  TStnEvent* ev = data->GetEvent();
  jet_block   = (TStnJetBlock*) ev->GetDataBlock(jetBlockName);
  if (!jet_block)  {
    fgLogger->Report(-302,Form("StntupleInitJetProbBlock: no TStnJetBlock with jetBlockName = %s",jetBlockName));
    return -1;
  }

  EventRecord::ConstIterator jp_iter( event,  "JetProbColl", description, process );
  if (!jp_iter.is_valid()) {
    fgLogger->Report(-301,Form("StntupleInitJetProbBlock: no JetProbColl"));
    return -1;
  }
  
  ConstHandle<JetProbColl> jp_handle(jp_iter);
  
  const JetProbColl::CollType& jp_list = jp_handle->contents(); 
  
  int   jp_jets = jp_list.size();

  if (jp_jets == 0) {
    //      std::cout << " no jp jets in  the event "<< std::endl;
      return 0;  
    }

  //  const JPJet*   ming_jet;
  TStnJPJet*     jpjet;
  TStnJPTrack*   jptrack;


  /*
  const  JPJet *jet1,*jet2; 
                                                       // order jets in Et
  for ( int i = 0; i < jp_jets; i++) inum[i] = i;
  for ( int i1 = 0; i1 < jp_jets-1; i1++) 
    {
      jet1 = &jp_list[i1];

      for (int i2 = i1 + 1; i2 < jp_jets; i2++)  
	{

	  jet2 = &jp_list[i2];
	  
	  if ( jet1->JetEt() < jet2->JetEt()) 
	    {
	                                               // swap the jets
	      int itmp = inum[i1];
	      inum[i1] = inum[i2];
	      inum[i2] = itmp;
	      jet1 = jet2;
	    }
	}
    }
  */
  
  for ( int jlp = 0 ; jlp < jet_block->NJets() ; jlp++)
    {
      TStnJet*   ijet     = jet_block->Jet(jlp);
      const CdfJet*  pjet = ijet->GetCdfJet();

      //      ming_jet = NULL;

      for (vector<JPJet>::const_iterator ming_jet = jp_handle->contents().begin();
	   ming_jet != jp_handle->contents().end(); ming_jet++) 
	{


	  //      for ( int j = 0; j < jp_jets; j++)
	  //	{
	  //	  ming_jet = &jp_list[j];
	  const CdfJet* jetp = (CdfJet*) ming_jet->JetLink().operator->();
	  if ( pjet == jetp )
	    {	
                                                       // loop over jets and store in the data block
                                                       // first need to loop over tracks in the jet 
	      //  for ( int j = 0; j < jp_jets; j++) 
	      //    {
	      //      ming_jet  = &jp_list[inum[j]];

	      jpjet = data->NewJPJet();
	      int ij = jet_block->JetNumber(pjet);
	      jpjet->SetJetId(ij);
                                                       // get number jp tracks
	      JPTrack* track[10000];
	      
	      vector<JPTrack> myJPTrackList = ming_jet->TrackList();
	      int ntracks = myJPTrackList.size();
	                                               // order tracks in Pt
	      for ( int i = 0; i < ntracks; i++)
		{
		  track[i] = (JPTrack*)  &myJPTrackList[i];
		}
	      
	      JPTrack* buf;
	      for ( int i1 = 0; i1 < ntracks - 1; i1++) 
		{
		  double pt1 = track[i1]->Pt();
		  for ( int i2 = i1 + 1; i2 < ntracks; i2++)
		    {
		      double pt2 = track[i2]->Pt();
		      if (pt1 < pt2) 
			{
			  buf    = track[i1];
			  track[i1] = track[i2];
			  track[i2] = buf;
			  pt1 = pt2;
			}
		    }
		}       
                                                       // store tracks in the block
	      for ( int it = 0; it < ntracks; it++)
		{
		  jptrack = data->NewJPTrack();
		  data->JPTrackLinkList()->Add(data->NJPJets() - 1,data->NJPTracks() - 1);
		  const JPTrack* ming = &*(track[it]);
		  StntupleInitJPTrack(jptrack,ming);
		}
       
       //       jpjet = data->NewJPJet();

	      const JPJet* mj = &*ming_jet;
	      StntupleInitJPJet(jpjet,mj);
	    }
	}
    }
  return 0;
}

//_____________________________________________________
Int_t StntupleJetProbBlockLinks(TStnDataBlock* block, AbsEvent* event, int mode){

  TStnJetProbBlock* jetprob_block = (TStnJetProbBlock*) block;

  //  TStnJetBlock*     jdata;
  TStnTrackBlock*   tdata;  
  
  // TStnJPJet*    jpjet;
  TStnJPTrack* jptrack;
  //const CdfJet* pierre;
  const CdfTrack* rick;

  tdata = (TStnTrackBlock*) jetprob_block->GetEvent()->GetDataBlock("TrackBlock");


  Int_t njptracks = jetprob_block->NJPTracks();
  for ( int itrk = 0; itrk < njptracks; itrk++)
    {
      jptrack  = jetprob_block->JPTrack(itrk);
      rick = jptrack->GetCdfTrack();
      int ij = tdata->TrackNumber(rick);
      jptrack->SetTrackNumber(ij);
    }

 return 0;
}