#include <iostream>
#include <iomanip>
#include <cmath>
#include "TF1.h"
#include "TCanvas.h"
#include "Stntuple/loop/TStnAna.hh"
#include "Stntuple/obj/TStnJetBlock.hh"
#include "Stntuple/obj/TStnMetBlock.hh"
#include "Stntuple/obj/TStnTriggerTable.hh"
#include "Stntuple/alg/TStntuple.hh"
#include "Stntuple/ana/TFlatNtupleModule.hh"


using std::cout;
using std::endl;

 ClassImp(TFlatNtupleModule)

//_____________________________________________________________________________
TFlatNtupleModule::TFlatNtupleModule(const char* name, const char* title):
  TStnModule(name,title), qMc(false)
{

}

//_____________________________________________________________________________
TFlatNtupleModule::~TFlatNtupleModule() {
}

//_____________________________________________________________________________
void TFlatNtupleModule::SaveHistograms() {

  spruce->Write();
  _file->Close();
  
}

//_____________________________________________________________________________
void TFlatNtupleModule::BookHistograms() {
  //char name[100];

  DeleteHistograms();
  _file = new TFile(_fileName,"RECREATE");


  spruce = new TTree("spruce", "Test tree"); 
  spruce->Branch("evt",  &fEveS, branch_format_event);

}

//_____________________________________________________________________________
void TFlatNtupleModule::InitNtuple(){

  int dummy       = -999;

  fEveS.run         = dummy;
  fEveS.eve         = dummy;
  fEveS.npho        = dummy;
  fEveS.nele        = dummy;
  fEveS.nmu         = dummy;
  fEveS.njet        = dummy;


  const int NELE1=10;
  for(int ab=0; ab!=NELE1; ab++)
    {
      if(ab==NELE1)
   	break;
      fEveS.j_et[ab] = dummy;
      fEveS.j_px[ab] = dummy;
      fEveS.j_py[ab] = dummy;
      fEveS.j_pz[ab] = dummy;
    }


  const int NELE2=5;
  for(int ab=0; ab!=NELE2; ab++)
    {
      if(ab==NELE2)
	break;
      fEveS.g_phi[ab]   = dummy;
      fEveS.g_etc[ab]   = dummy;
      fEveS.g_ec[ab]    = dummy;
      fEveS.g_ces2[ab]  = dummy;
      fEveS.g_eta[ab]   = dummy;
      fEveS.g_hadem[ab] = dummy;
      fEveS.g_chi2[ab]  = dummy;
      fEveS.g_xces[ab]  = dummy;
      fEveS.g_zces[ab]  = dummy;
      fEveS.g_lshr[ab]  = dummy;
      fEveS.g_iso4[ab]  = dummy;
      fEveS.g_n3d[ab]   = dummy;
      fEveS.g_sumpt4[ab]= dummy;
      fEveS.g_px[ab]    = dummy;
      fEveS.g_py[ab]    = dummy;
      fEveS.g_pz[ab]    = dummy;
      fEveS.g_e[ab]     = dummy;

      fEveS.e_et[ab]    = dummy;
      fEveS.m_pt[ab]    = dummy;

    }


}


//_____________________________________________________________________________
int TFlatNtupleModule::BeginJob() {

				// register the data block, why?

  fHeaderBlock = (TStnHeaderBlock*) 
          RegisterDataBlock("HeaderBlock","TStnHeaderBlock");
  fCalDataBlock = (TCalDataBlock*) 
          RegisterDataBlock("CalDataBlock","TCalDataBlock");
  fCesDataBlock = (TCesDataBlock*) 
          RegisterDataBlock("CesDataBlock","TCesDataBlock");
  fCprDataBlock = (TCprDataBlock*) 
          RegisterDataBlock("CprDataBlock","TCprDataBlock");
  fJetBlock =     (TStnJetBlock*) 
          RegisterDataBlock("JetBlock","TStnJetBlock");
  fTrackBlock =   (TStnTrackBlock*) 
         RegisterDataBlock("TrackBlock","TStnTrackBlock");
  fClusterBlock = (TStnClusterBlock*) 
          RegisterDataBlock("ClusterBlock","TStnClusterBlock");
  fPhotonBlock =  (TStnPhotonBlock*) 
          RegisterDataBlock("PhotonBlock","TStnPhotonBlock");
  fTriggerBlock =  (TStnTriggerBlock*) 
          RegisterDataBlock("TriggerBlock","TStnTriggerBlock");
  fTrigSimBlock =  (TStnTriggerBlock*) 
          RegisterDataBlock("TrigSimBlock","TStnTriggerBlock");
  fDcasDataBlock =  (TDcasDataBlock*) 
          RegisterDataBlock("DcasDataBlock","TDcasDataBlock");
  fElectronBlock =  (TStnElectronBlock*) 
          RegisterDataBlock("ElectronBlock","TStnElectronBlock");
  fPhElectronBlock =  (TPhoenixElectronBlock*) 
          RegisterDataBlock("Phoenix_Electrons","TPhoenixElectronBlock");
  fPhSiTrackBlock =  (TStnTrackBlock*) 
          RegisterDataBlock("PROD@PhoenixSI_Tracking","TStnTrackBlock");
  fMuonBlock =  (TStnMuonBlock*) 
          RegisterDataBlock("MuonBlock","TStnMuonBlock");
  fVertexBlock =  (TStnVertexBlock*) 
          RegisterDataBlock("VertexBlock","TStnVertexBlock");
  fZVertexBlock = (TStnVertexBlock*) 
          RegisterDataBlock("ZVertexBlock","TStnVertexBlock");
  BookHistograms();
  nevent =0;
  nskim=0;
  

  for(int i=0; i<100; i++) npass[i]=0;


  return 0;
}


//_____________________________________________________________________________
int TFlatNtupleModule::BeginRun() {


  run = fHeaderBlock->RunNumber();
  if(fHeaderBlock->McFlag()) 
    qMc = true;
  else
    qMc = false;
  

  TStntuple::Init(run);
  return 0;
}

//_____________________________________________________________________________
int TFlatNtupleModule::Event(int ientry) {

  InitNtuple();


  evt = fHeaderBlock->EventNumber();
  sec = fHeaderBlock->SectionNumber();

  npass[0]++;


  fEveS.run    = run;
  fEveS.eve    = evt;


  event = fHeaderBlock->GetEvent();

  LepPlots(ientry);
  nevent++;

  return 0;
}

//_____________________________________________________________________________
int TFlatNtupleModule::LepPlots(int ientry) {



  //----------------------------------------------------------------------
  // look for photons
  //----------------------------------------------------------------------
  fPhotonBlock->GetEntry(ientry);
  if(fPhotonBlock->NPhotons()>100) {
    cout << " found bad NPho  "<< fPhotonBlock->NPhotons() << endl;
    cout << run << "   " << evt << endl;
    return 1;
  }


  fEveS.npho = fPhotonBlock->NPhotons();
  fJetBlock->GetEntry(ientry);
  fEveS.njet = fJetBlock->NJets();
  fElectronBlock->GetEntry(ientry);
  fEveS.nele = fElectronBlock->NElectrons();
  fMuonBlock->GetEntry(ientry);
  fEveS.nmu = fMuonBlock->NMuons();


  for(int ey=0; ey< fPhotonBlock->NPhotons() && ey<5; ey++)
    {
      TStnPhoton* photon = fPhotonBlock->Photon(ey);
      fEveS.g_phi[ey]    = photon->Momentum()->Phi();
      fEveS.g_etc[ey]    = photon->Etc();
      fEveS.g_ec[ey]     = photon->ECorr();
      float ces2         = (photon->CesStripE2()>photon->CesWireE2()? 
			    photon->CesStripE2() : photon->CesWireE2() );
      ces2               = ces2*photon->SinTheta();	
      fEveS.g_ces2[ey]   = ces2;
      fEveS.g_eta[ey]    = photon->Momentum()->Eta();
      fEveS.g_hadem[ey]  = photon->HadEm();
      fEveS.g_chi2[ey]   = photon->Chi2();
      fEveS.g_xces[ey]   = photon->XCes();
      fEveS.g_zces[ey]   = photon->ZCes();
      fEveS.g_lshr[ey]   = photon->LShr();
      fEveS.g_iso4[ey]   = photon->EIso4(2);
      fEveS.g_n3d[ey]    = photon->N3d();
      fEveS.g_sumpt4[ey] = photon->SumPt4();
      fEveS.g_px[ey]     = photon->Momentum()->Px();
      fEveS.g_py[ey]     = photon->Momentum()->Py();
      fEveS.g_pz[ey]     = photon->Momentum()->Pz();
      fEveS.g_e[ey]      = photon->Momentum()->E();
    }

       

  for(int ey=0; ey<fJetBlock->NJets() && ey<10; ey++)
    {
      TStnJet* jet = fJetBlock->Jet(ey);
      fEveS.j_et[ey]    = jet->Et();
      fEveS.j_eta[ey]   = jet->DetEta();
      fEveS.j_px[ey]    = jet->Momentum()->Px();
      fEveS.j_py[ey]    = jet->Momentum()->Py();
      fEveS.j_pz[ey]    = jet->Momentum()->Pz();
      fEveS.j_phi[ey]   = jet->Momentum()->Phi();
    }



  //----------------------------------------------------------------------
  // look for electrons
  //----------------------------------------------------------------------

            
  for(int i=0; i< fElectronBlock->NElectrons() && i<5; i++) {
    
    TStnElectron* ele= fElectronBlock->Electron(i);

    fEveS.e_et[i]     = ele->Et();

  }


  //----------------------------------------------------------------------
  // look for muons
  //----------------------------------------------------------------------


  for(int i=0; i<fMuonBlock->NMuons() && i<5; i++) {
    TStnMuon* muo     =  fMuonBlock->Muon(i);
    fEveS.m_pt[i]    =  muo->TrackPt();

  }

  spruce->Fill();
  npass[8]++;
  

return 0;
}



//_____________________________________________________________________________
int TFlatNtupleModule::EndJob() {
  printf("----- end job: ---- %s\n",GetName());
  cout << "Processed: "<<nevent<< "    skimmed:" << nskim << endl;

  for(int i=0; i<100; i++) {
    if(npass[i]>0) cout << "npass["<<i<<"] = " << npass[i] << endl;
  }
  return 0;
}