#ifdef __CLING__
R__LOAD_LIBRARY(libDelphes)
#include "classes/DelphesClasses.h"
#include "external/ExRootAnalysis/ExRootTreeReader.h"
#include "external/ExRootAnalysis/ExRootResult.h"
#include "external/ExRootAnalysis/ExRootTreeBranch.h"
#include "external/ExRootAnalysis/ExRootTreeWriter.h"
#include "external/ExRootAnalysis/ExRootFilter.h"
#else
class ExRootTreeReader;
class ExRootResult;
class ExRootTreeBranch;
class ExRootTreeWriter;
class ExRootFilter;
#endif

#include <iostream>
#include <cmath>
#include <array>
#include <vector>
#include <TArrayC.h>
#include <string>
#include "TH1.h"                                 // for histrograming
#include "TH2D.h"
#include "TH1F.h"
#include "TH2F.h"
//#include "TVirtualPad.h"
#include "TApplication.h"
#include "TBranch.h"
#include "TBranchElement.h"
#include "TFile.h"                     // ROOT, for saving file.
#include  <map>
#include "TTree.h"                     //for Tree file 
#include "TROOT.h"


//------------------------------------------------------------------------------

void DelphesAnalysis(const char *inputFile, const char *outputFile)
{
   gSystem->Load("libDelphes");

   // Create chain of root trees
   TChain chain("Delphes");
   chain.Add(inputFile);

   // Creating the output file and tree
   TFile *outfile = new TFile(outputFile,"RECREATE");
   TTree *outtree=new TTree("eventtree","Test");


   // Create object of class ExRootTreeReader
   ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);

   Long64_t numberOfEntries = treeReader->GetEntries();

   cout << "** Chain contains " << numberOfEntries << " events" << endl; //To see the total number of events
                                                                         // ExRootResult *result = new ExRootResult();


   // Get pointers to branches used in this analysis
   TClonesArray *branchPhoton = treeReader->UseBranch("Photon");
   TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");


   Photon *photon;
   MissingET *misset;

   Double_t met, etamiss, phimiss, ptph, eph, etaph, phiph;

   std::vector<Double_t> MET;
   std::vector<Double_t> ETAmiss;
   std::vector<Double_t> PHImiss;
   std::vector<Double_t> PTph;
   std::vector<Double_t> Eph;
   std::vector<Double_t> ETAph;
   std::vector<Double_t> PHIph;

   /* --------- Creating the DATA file ---------------/
    ofstream myfile;
    myfile.open ("ExtractedData.dat");

    ofstream myfile1;
    ofstream myfile2;
    myfile1.open ("/home/pdas/Bhupal_TMVA/SignalSP_Photon.dat");
    myfile2.open ("/home/pdas/Bhupal_TMVA/SignalSP_MissEt.dat");

    /-------------------------------------------------*/


   /*------------------ Creates the Branches ------------------------*/
   outtree->Branch("PTph", "vector<Double_t>",&PTph);
   outtree->Branch("Eph", "vector<Double_t>",&Eph);
   outtree->Branch("ETAph", "vector<Double_t>",&ETAph);
   outtree->Branch("PHIph", "vector<Double_t>",&PHIph);
   outtree->Branch("MET", "vector<Double_t>",&MET);
   outtree->Branch("ETAmiss", "vector<Double_t>",&ETAmiss);
   outtree->Branch("PHImiss", "vector<Double_t>",&PHImiss);
   /*-----------------------------------------------------------------*/

   // Loop over all events
   for(Int_t entry = 0; entry < numberOfEntries; ++entry)
   {

      // Load selected branches with data from specified event
      treeReader->ReadEntry(entry);

      // if(entry>10) break;
      //cout <<"--------- New Event ("<< entry << ") ---------" <<endl;

      // loop over all input particles in the event

      for(Int_t ii=0; ii < branchMissingET->GetEntriesFast(); ii++)
      {
         misset = (MissingET*) branchMissingET->At(ii);
         met = misset->MET;
         etamiss = misset->Eta;
         phimiss = misset->Phi;
         MET->push_back(met);
         ETAmiss->push_back(etamiss);
         PHImiss->push_back(phimiss);
         //cout<<"|| MET: "<<misset->MET<<" || Eta: "<<misset->Eta<<" || Phi: "<<misset->Phi<<" || "<<endl;
         //myfile << misset->MET << "\t" << misset->Eta << "\t" << misset->Phi <<"\n";
      }

      for(Int_t i=0; i < branchPhoton->GetEntriesFast(); i++)
      {
         photon = (Photon*) branchPhoton->At(i);
         ptph = photon->PT;
         eph = photon->E;
         etaph = photon->Eta;
         phiph = photon->Phi;
         PTph.push_back(ptph);
         Eph.push_back(eph);
         ETAph.push_back(etaph);
         PHIph.push_back(phiph);
         //cout<<"|| E: "<<photon->E<<" || PT: "<<photon->PT<<" || Eta: "<<photon->Eta<<" || Phi: "<<photon->Phi<<" || "<<endl;
         //myfile << photon->E <<"\t"<< photon->PT <<"\t"<< photon->Eta <<"\t"<<photon->Phi<<"\n";
      }

      outtree->Fill();
   }
   outfile->Write();
   delete outfile;
}