//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////
////Macro that reads a MadGraph DelphesRecoObjects file and saves .root output acording to TopTreeProducer format
////Last revisions list
////Alexis Kalogeropoulos 1.12.2009
////Eric Chabert 23.10.2009
////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


#include "../interface/DelphesRecoObjects.h"
//using namespace TopTree;
using namespace std;


void
DelphesRecoObjects::CreateBranches (TTree * eventTreee)
{
}

void
DelphesRecoObjects::Loop (bool verbose, int num)
{

  ///Get the Delphes file and create the new file
  TFile *input_ = TFile::Open ("../test/Delphes.root");
  TTree *events;

  events = (TTree *) input_->Get ("Analysis");

  cout << events->GetEntriesFast () << endl;

  fout_ = new TFile ("TopTreeRecoDelphes.root", "RECREATE");
  TTree *eventTree;
  eventTree_ = new TTree ("eventTreeReco", " Events");


  //Create some branches in the new file
  jets = new TClonesArray ("TopTree::TRootCaloJet", 1000);
  eventTree_->Branch ("Jets", "TClonesArray", &jets);

  elecs = new TClonesArray ("TopTree::TRootElectron", 1000);
  eventTree_->Branch ("Electrons", "TClonesArray", &elecs);

  muons = new TClonesArray ("TopTree::TRootMuon", 1000);
  eventTree_->Branch ("Muons", "TClonesArray", &muons);

  mets = new TClonesArray ("TopTree::TRootMET", 1000);
  eventTree_->Branch ("MET", "TClonesArray", &mets);

  // events->Print();

  Long64_t nentries = events->GetEntriesFast ();




  //nentries = 1000;

  for (Long64_t jentry = 0; jentry < nentries; jentry++)
    {


      FillEntry (jentry);

      eventTree_->Fill ();
    }


  if (verbose)
    cout << "  All  info succesfully for " << nentries << "  events " << endl;

  eventTree_->Write ();

  fout_->Write ();


}


void
DelphesRecoObjects::FillEntry (int jentry)
{
  Long64_t ientry = LoadTree (jentry);
  if (ientry < 0)
    return;
  fChain->GetEntry (jentry);


  JetAnalyzer JetsA;
  ElectronAnalyzer EleA;
  MuonAnalyzer MuonA;
  METAnalyzer MetA;


  //////////loop for Jets
  jets->Clear ("C");
  for (Int_t i = 0; i < init_jets->GetEntriesFast (); i++)

    JetsA.AnalysisJet (i, (TRootCaloJet *) init_jets->At (i), jets);

  ///////loop for Elecs
  elecs->Clear ("C");
  for (int ie = 0; ie < init_elecs->GetEntriesFast (); ie++)
    EleA.AnalysisE (ie, (TopTree::TRootElectron *) init_elecs->At (ie), elecs);

  ///////loop for Muons
  muons->Clear ("C");
  for (int im = 0; im < init_muons->GetEntriesFast (); im++)
    MuonA.AnalysisM (im, (TopTree::TRootMuon *) init_muons->At (im), muons);

  ///////loop for MET
  mets->Clear ("C");
  for (int ime = 0; ime < init_mets->GetEntriesFast (); ime++)
    MetA.AnalysisMET (ime, (TRootETmis *) init_mets->At (ime), mets);
}

//cout<<&init_mcpart<<"  "<<&init_mets<<endl;
DelphesRecoObjects::DelphesRecoObjects (string infilename, string outfilename)
{

  file = new TFile (infilename.c_str ());
  fChain = (TTree *) gDirectory->Get ("Analysis");
  //fChainMC = (TTree *) gDirectory->Get ("GEN");
  //tc 
  init_muons = new TClonesArray ("TopTree::TRootMuon", 1000);
  init_elecs = new TClonesArray ("TopTree::TRootElectron", 1000);
  init_jets = new TClonesArray ("TRootCaloJet", 1000);
  init_mets = new TClonesArray ("TRootETmis", 1000);
  // init_mcpart = new TClonesArray ("TRootGenParticle", 0);
  Init (fChain);

}

DelphesRecoObjects::~DelphesRecoObjects ()
{
}

Int_t DelphesRecoObjects::GetEntry (Long64_t entry)
{
// Read contents of entry.
  if (!fChain)
    return 0;
  return fChain->GetEntry (entry);
  // return fChainMC->GetEntry (entry);
}

Long64_t DelphesRecoObjects::LoadTree (Long64_t entry)
{
// Set the environment to read one entry
  if (!fChain)
    return -5;
  Long64_t
    centry = fChain->LoadTree (entry);
  if (centry < 0)
    return centry;
  if (!fChain->InheritsFrom (TChain::Class ()))
    return centry;
  TChain *
    chain = (TChain *) fChain;
  if (chain->GetTreeNumber () != fCurrent)
    {
      fCurrent = chain->GetTreeNumber ();
    }
  return centry;
}

void
DelphesRecoObjects::Init (TTree * tree)
{
  if (!tree)
    return;
  fChain = tree;
  TTree *fChainMC;
  //fChainMC = MCtree;
  fCurrent = -1;
  //fChain->SetMakeClass(1);
  //fChainMC->SetMakeClass(1);
  fChain->SetBranchAddress ("Muon", &init_muons, &b_input_Muons);
  fChain->SetBranchAddress ("Electron", &init_elecs, &b_input_Electrons);
  fChain->SetBranchAddress ("Jet", &init_jets, &b_input_Jets);
  fChain->SetBranchAddress ("ETmis", &init_mets, &b_input_MET);
  //MC
  //fChainMC->SetBranchAddress ("Particle", &init_mcpart, &b_input_MCParticles);

};