//-------------------------------------------------------------------
// init for L3Summary stntuple object
// Oct 2003 - RLC
//-------------------------------------------------------------------

// for bad value protection
#ifdef LINUX
  #include <math.h>
#elif __sgi
  #include <ieeefp.h>
#elif SunOS
  #include <ieeefp.h>
#endif
#include <iostream>
#include <iomanip>


#include <BaBar/Experiment.hh>
#include <Edm/EventRecord.hh>
#include <Edm/ConstHandle.hh>

#include <evt/Event.hh>
#include <Bbos/bank_interface.hh>
#include "Level3Objects/L3SummaryObject.hh"

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

Int_t StntupleInitL3SummaryBlock(TStnDataBlock *block, AbsEvent *event, int mode) 
{
                            // check if block has already been initialised
   int ev_number, rn_number;
   ev_number = AbsEnv::instance()->trigNumber();
   rn_number = AbsEnv::instance()->runNumber();

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

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

   EventRecord::ConstIterator iter(event, "L3SummaryObject");
   if (!iter.is_valid()) return -1;

   ConstHandle<L3SummaryObject> l3_h(iter);
   L3SummaryObject::indexType  headers = l3_h->index();

   // order ele,mu,jet4,jet7,cot,svt,met,tau
   // type:  0  1   2    3    4   5   6   7 
   int blockVerC[8] = {2,1,0,0,2,4,1,0}; // current versions
   int blockVers[8];
   int blockN[8] = {0,0,0,0,0,0,0,0};
   int ind = 0;
   int pred = 0;
   bool ok = true, blockOk = true;

   for( L3SummaryObject::indexType::const_iterator it = headers.begin();
	it != headers.end(); it++) {

     //std::cout 
     //<< "  ID   " << it->blockId
     //<< "  entr " << it->nEntries
     //<< "  ver  " << it->blockVersion
     //<< "  len " << it->entryLength
     //<< std::endl;
     blockN[ind] = it->nEntries;
     blockVers[ind] = it->blockVersion;
     blockOk = true;
     if(blockVers[ind]>blockVerC[ind]) blockOk = false;
     if(!blockOk) {
       std::cout << "InitL3SummaryBlock: Can't pack L3 block type " 
		 << it->blockId << "  version " 
		 << it->blockVersion << std::endl;
       ok = false;
     }
     pred += it->nEntries * it->entryLength;
     ind++;
   }
   if(!ok) return 1; 

   float* buf0 = l3_h->floatBuffer();
   int buflen = l3_h->floatBufferSize();

   // wash the values since the block pointers are wrong sometimes
   float buf[10000];
   for(int  i=0; i<buflen; i++) {
     if( isnanf(buf0[i]) ) {
       buf[i] = 0;
     } else if( buf0[i]>1.e7 ) {
       buf[i] = 1.e7;
     } else if( buf0[i]<-1.e7 ) {
       buf[i] = -1.e7;
     } else {
       buf[i] = buf0[i];
     }
   }

   if(buflen!=pred) {
     std::cout << "InitL3SummaryBlock: L3Summary sizes don't make sense, len="
	       << buflen<< "  pred: "<< pred << std::endl;
   }

   //for(int i=0; i<buflen; i++) {
   //  std::cout << buf[i] << " " << int(buf[i]) << std::endl;
   //}

   // fill each type of object from the float array
   int ipt = 0;
   int blk = 0;

   // Em
   for(int i=0;i <blockN[blk]; i++) {
     TL3Em* ptr = data->NewEm();
     ptr->fVersion =    blockVers[blk];
     ptr->fElet = 	buf[ipt++];	    
     ptr->fEta = 	buf[ipt++];
     if(blockVers[blk]>=1) {
       ptr->fTrackpt = 	buf[ipt++];    
     } else {
       float pt =   buf[ipt++];
       float curv = buf[ipt++];
       ptr->fTrackpt = 	(curv>0.0 ? pt : -pt);    
     }
     ptr->fTrackZ0 = 	buf[ipt++];     
     ptr->fTrackPhi0 = 	buf[ipt++];   
     ptr->fTrackD0 = 	buf[ipt++];     
     ptr->fHadem2 = 	buf[ipt++];      
     ptr->fHadem3 = 	buf[ipt++];      
     ptr->fDelx = 	buf[ipt++];        
     ptr->fDelz = 	buf[ipt++];        
     ptr->fChiS = 	buf[ipt++];        
     ptr->fChiW = 	buf[ipt++];
     ptr->fLshrCes = 	buf[ipt++];
     ptr->fLshrEl2 = 	buf[ipt++];
     ptr->fLshrEl3 = 	buf[ipt++];
     ptr->fSeedIeta = 	buf[ipt++];
     ptr->fSeedIphi = 	buf[ipt++];
     ptr->fIso4 = 	buf[ipt++];        
     ptr->fCesZ = 	buf[ipt++];        
     ptr->fCesAvgChi2 = buf[ipt++];  
     if(blockVers[blk]>=1) {
       ptr->fPhet = 	   buf[ipt++];        
       ptr->fTracklambda = buf[ipt++]; 
       ptr->fPhIso4 = 	   buf[ipt++];      
     } else {
       ptr->fPhet =       999;
       ptr->fTracklambda = 99;
       ptr->fPhIso4 = 	   99;
     }
     //cout << " Electron " << endl;
     //ptr->Print();
   }
   blk++;

   // Muon
   for(int i=0;i <blockN[blk]; i++) {
     TL3Muon* ptr = data->NewMuon();
     ptr->fVersion =    blockVers[blk];
     if(blockVers[blk]>=1) {
       ptr->fTrackpt = 	buf[ipt++];    
     } else {
       float pt =   buf[ipt++];
       float curv = buf[ipt++];
       ptr->fTrackpt = 	(curv>0.0 ? pt : -pt);    
     }
     ptr->fEta = 	buf[ipt++];       
     ptr->fPhi0 = 	buf[ipt++];      
     ptr->fD0 = 	buf[ipt++];        
     ptr->fZ0 = 	buf[ipt++];        
     ptr->fEm = 	buf[ipt++];        
     ptr->fHad = 	buf[ipt++];       
     ptr->fDxCmu = 	buf[ipt++];     
     ptr->fChixCmu = 	buf[ipt++];   
     ptr->fDxCmp = 	buf[ipt++];     
     ptr->fChixCmp = 	buf[ipt++];   
     ptr->fDxCmx = 	buf[ipt++];     
     ptr->fChixCmx = 	buf[ipt++];   
     if(blockVers[blk]>=1) {
       ptr->fChixPosCmu = buf[ipt++];
       ptr->fChixPosCmp = buf[ipt++];
       ptr->fChixPosCmx = buf[ipt++];
     } else {
       ptr->fChixPosCmu = 999;
       ptr->fChixPosCmp = 999;
       ptr->fChixPosCmx = 999;
     }
     //cout << " Muon " << endl;
     //ptr->Print();
   }
   blk++;

   // Jet4
   for(int i=0;i <blockN[blk]; i++) {
     TL3Jet* ptr = data->NewJet4();
     ptr->fVersion =    blockVers[blk];
     ptr->fEt = 	buf[ipt++]; 
     ptr->fEta = 	buf[ipt++];
     ptr->fPhi = 	buf[ipt++];
     //cout << " Jet 4 " << endl;
     //ptr->Print();
   }
   blk++;

   // Jet7
   for(int i=0;i <blockN[blk]; i++) {
     TL3Jet* ptr = data->NewJet7();
     ptr->fVersion =    blockVers[blk];
     ptr->fEt = 	buf[ipt++]; 
     ptr->fEta = 	buf[ipt++];
     ptr->fPhi = 	buf[ipt++];
     //cout << " Jet 7 " << endl;
     //ptr->Print();
   }
   blk++;

   // Cot Tracks
   for(int i=0;i <blockN[blk]; i++) {
     TL3Track* ptr = data->NewCotTrack();
     ptr->fVersion =    blockVers[blk];
     if(blockVers[blk]>=1) {
       ptr->fTrackpt = 	buf[ipt++];    
     } else {
       float pt =   buf[ipt++];
       float curv = buf[ipt++];
       ptr->fTrackpt = 	(curv>0.0 ? pt : -pt);    
     }
     ptr->fZ0 = 	buf[ipt++];    
     ptr->fD0 = 	buf[ipt++];    
     ptr->fPhi0 = 	buf[ipt++];  
     ptr->fLambda = 	buf[ipt++];
     if(blockVers[blk]>=1) {
       ptr->fMask1 = 	buf[ipt++];
       ptr->fMask2 = 	buf[ipt++];
     } else {
       ptr->fMask1 = 	0;
       ptr->fMask2 = 	0;
     }
     ptr->fD0Sig = -999;
     //cout << " COT track " << endl;
     //ptr->Print();
   }
   blk++;

   // Svt Tracks
   for(int i=0;i <blockN[blk]; i++) {
     TL3Track* ptr = data->NewSvtTrack();
     ptr->fVersion =    blockVers[blk];
     if(blockVers[blk]>=1) {
       ptr->fTrackpt = 	buf[ipt++];    
     } else {
       float pt =   buf[ipt++];
       float curv = buf[ipt++];
       ptr->fTrackpt = 	(curv>0.0 ? pt : -pt);    
     }

     ptr->fZ0 = 	buf[ipt++];    
     ptr->fD0 = 	buf[ipt++];    
     ptr->fPhi0 = 	buf[ipt++];  
     ptr->fLambda = 	buf[ipt++];
     if(blockVers[blk]>=1) {
       ptr->fMask1 = 	buf[ipt++];
       ptr->fMask2 = 	buf[ipt++];
     } else {
       ptr->fMask1 = 0;
       ptr->fMask2 = 0;
     }

     if(blockVers[blk]>=3) {
       ptr->fD0Sig = 	buf[ipt++];
     } else {
       ptr->fD0Sig = -999;
     }
     //cout << " SVT track " << endl;
     //ptr->Print();
   }
   blk++;

   // Met
   for(int i=0;i <blockN[blk]; i++) {
     TL3Met* ptr = data->NewMet();
     ptr->fVersion =    blockVers[blk];
     ptr->fMetX = 	buf[ipt++]; 
     ptr->fMetY = 	buf[ipt++]; 
     ptr->fPhi = 	buf[ipt++];  
     ptr->fEtSum = 	buf[ipt++];
     //cout << " Met " << endl;
     //ptr->Print();
   }
   blk++;

   // Tau
   for(int i=0;i <blockN[blk]; i++) {
     TL3Tau* ptr = data->NewTau();
     ptr->fVersion =    blockVers[blk];
     ptr->fPt = 	buf[ipt++];           
     ptr->fEta = 	buf[ipt++];          
     ptr->fPhi = 	buf[ipt++];          
     ptr->fCluMass = 	buf[ipt++];      
     ptr->fTkMass = 	buf[ipt++];       
     ptr->fChargedtkSeed = buf[ipt++];
     //cout << " Tau " << endl;
     //ptr->Print();
   }
   blk++;

   if(buflen!=ipt) {
     std::cout << "InitL3SummaryBlock: L3Summary sizes don't make sense, len="
	       << buflen<< "  ipt: "<< ipt << std::endl;
   }

   data->f_EventNumber = ev_number;
   data->f_RunNumber   = rn_number;

   return 0;
}