/*
  ---- FastSim ----
  A Fast Simulator for general purpose LHC detector
  S. Ovyn ~~~~ severine.ovyn@uclouvain.be

  Center for Particle Physics and Phenomenology (CP3)
  Universite Catholique de Louvain (UCL)
  Louvain-la-Neuve, Belgium
*/

/// \file Smearing.cpp
/// \brief executable for the FastSim

#include "TChain.h"
#include "TApplication.h"

#include "Utilities/ExRootAnalysis/interface/ExRootTreeReader.h"
#include "Utilities/ExRootAnalysis/interface/ExRootTreeWriter.h"
#include "Utilities/ExRootAnalysis/interface/ExRootTreeBranch.h"

#include "Utilities/CDFCones/interface/JetCluAlgorithm.h"
#include "Utilities/CDFCones/interface/MidPointAlgorithm.h"
#include "Utilities/CDFCones/interface/PhysicsTower.h"
#include "Utilities/CDFCones/interface/Cluster.h"

#include "interface/DataConverter.h"
#include "interface/HEPEVTConverter.h"
#include "interface/LHEFConverter.h"
#include "interface/STDHEPConverter.h"
#include "interface/SmearUtil.h"
#include "interface/TreeClasses.h"

using namespace std;

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



void PairingJet(TLorentzVector &JETSm, TLorentzVector JET, vector<Cluster> jetsS)
{
  JETSm.SetPxPyPzE(0,0,0,0);
  vector<Cluster>::iterator itJetS;
  float deltaRtest=5000;
  LorentzVector jetMomentumS;
  for(itJetS = jetsS.begin(); itJetS != jetsS.end(); ++itJetS) 
     {
       jetMomentumS = itJetS->fourVector;
       TLorentzVector Att;
       Att.SetPxPyPzE(jetMomentumS.px,jetMomentumS.py,jetMomentumS.pz,jetMomentumS.E);
       if(DeltaR(JET.Phi(),JET.Eta(),Att.Phi(),Att.Eta()) < deltaRtest)
            {
              deltaRtest = DeltaR(JET.Phi(),JET.Eta(),Att.Phi(),Att.Eta());
              if(deltaRtest < 0.25)
                {
                  JETSm = Att;
                }
            }
     }
}


int main(int argc, char *argv[])
{
  int appargc = 2;
  char *appName = "Smearing";
  char *appargv[] = {appName, "-b"};
  TApplication app(appName, &appargc, appargv);
  
  if(argc != 4 && argc != 3) {
      cout << " Usage: " << argv[0] << " input_file" << " output_file" << " data_card " << endl;
      cout << " input_list - list of files in Ntpl, StdHep of LHEF format," << endl;
      cout << " output_file - output file." << endl;
      cout << " data_card - Datacard containing resolution variables for the detector simulation (optional) "<<endl;
      exit(1);
  }

  srand (time (NULL));         /* Initialisation du générateur */
  
  //read the input TROOT file
  string inputFileList(argv[1]), outputfilename(argv[2]);
  if(outputfilename.find(".root") > outputfilename.length() ) {
    cout << "output_file should be a .root file!\n";
    return -1;
  }
  TFile *outputFile = TFile::Open(outputfilename.c_str(), "RECREATE"); // Creates the file, but should be closed just after
  outputFile->Close();

  string line;
  ifstream infile(inputFileList.c_str());
  infile >> line; // the first line determines the type of input files
 
  DataConverter *converter=0;
   
  if(strstr(line.c_str(),".hep"))
    {                           
      cout<<"*************************************************************************"<<endl;
      cout<<"************         StdHEP file format detected           **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new STDHEPConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else if(strstr(line.c_str(),".lhe"))
    {
      cout<<"*************************************************************************"<<endl;
      cout<<"************          LHEF file format detected            **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new LHEFConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else if(strstr(line.c_str(),".root"))
    {
      cout<<"*************************************************************************"<<endl;
      cout<<"************         h2root file format detected           **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new HEPEVTConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else { cout << "***  " << line.c_str() << "\n***  file format not identified\n***  Exiting\n"; return -1;};

  TChain chain("GEN");
  chain.Add(outputfilename.c_str());
  ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
  const TClonesArray *branchGen = treeReader->UseBranch("Particle");
  TIter itGen((TCollection*)branchGen);
  
  //write the output root file
  ExRootTreeWriter *treeWriter = new ExRootTreeWriter(outputfilename, "Analysis");
  ExRootTreeBranch *branchjet = treeWriter->NewBranch("JetPTResol", RESOLJET::Class());
  ExRootTreeBranch *branchelec = treeWriter->NewBranch("ElecEResol", RESOLELEC::Class());
  ExRootTreeBranch *branchmuon = treeWriter->NewBranch("MuonPTResol", RESOLMUON::Class());
  ExRootTreeBranch *branchtaujet = treeWriter->NewBranch("TauJetPTResol", TAUHAD::Class());
  ExRootTreeBranch *branchetmis = treeWriter->NewBranch("ETmisResol",ETMIS::Class());

  TRootGenParticle *particle;
  TRootETmis *etmisc;

  RESOLELEC *elementElec;
  RESOLMUON *elementMuon;
  RESOLJET *elementJet;
  TAUHAD *elementTaujet;
  ETMIS *elementEtmis;

 
  //read the datacard input file
  string DetDatacard("");
  if(argc==4)  DetDatacard =argv[3];
  RESOLution *DET = new RESOLution();   
  DET->ReadDataCard(DetDatacard);
  
  
  TLorentzVector genMomentum(0,0,0,0);
  LorentzVector jetMomentum;
  vector<TLorentzVector> TrackCentral;  
  vector<PhysicsTower> towersS;
  vector<Cluster> jetsS; 
  vector<PhysicsTower> towers;
  vector<Cluster> jets;

 
  // Loop over all events
  Long64_t entry, allEntries = treeReader->GetEntries();
  cout << "** Chain contains " << allEntries << " events" << endl;
  for(entry = 0; entry < allEntries; ++entry)
    {
      TLorentzVector PTmis(0,0,0,0);
      treeReader->ReadEntry(entry);
      treeWriter->Clear();
      
      if((entry % 100) == 0 && entry > 0 )  cout << "** Processing element # " << entry << endl;
      
      TSimpleArray<TRootGenParticle> bGen;
      itGen.Reset();
      TrackCentral.clear();
      towers.clear();
      towersS.clear();
      TSimpleArray<TRootGenParticle> NFCentralQ;


      // Loop over all particles in event
      while( (particle = (TRootGenParticle*) itGen.Next()) )
	{
          genMomentum.SetPxPyPzE(particle->Px, particle->Py, particle->Pz, particle->E);

	  int pid = abs(particle->PID);
	  float eta = fabs(particle->Eta);

if(particle->Status == 1)towers.push_back(PhysicsTower(LorentzVector(genMomentum.Px(),genMomentum.Py(),genMomentum.Pz(), genMomentum.E())));

	  // keeps only final particles, visible by the central detector, including the fiducial volume
	  // the ordering of conditions have been optimised for speed : put first the STATUS condition
          if( (particle->Status == 1)    &&
	      ( 
		(pid == pMU  && eta < DET->MAX_MU) ||
                (pid != pMU  && (pid != pNU1) && (pid != pNU2) && (pid != pNU3) && eta < DET->MAX_CALO_FWD) 
              )
            ) {
		switch(pid) {
		    
		    case pE: // all electrons with eta < DET->MAX_CALO_FWD
		      DET->SmearElectron(genMomentum);
		      break; // case pE

		    case pGAMMA: // all photons with eta < DET->MAX_CALO_FWD
		      DET->SmearElectron(genMomentum);
		      break; // case pGAMMA

		    case pMU: // all muons with eta < DET->MAX_MU
		      DET->SmearMu(genMomentum);
		      break; // case pMU

		    case pLAMBDA: // all lambdas with eta < DET->MAX_CALO_FWD
		    case pK0S:    // all K0s with eta < DET->MAX_CALO_FWD
		      DET->SmearHadron(genMomentum, 0.7);
		      break; // case hadron
		      
		    default:   // all other final particles with eta < DET->MAX_CALO_FWD
		      DET->SmearHadron(genMomentum, 1.0);
		      break;
		} // switch (pid)

		// all final particles but muons and neutrinos	
		// for calorimetric towers and mission PT
                if(genMomentum.E()!=0) PTmis = PTmis + genMomentum;//ptmis

		if(pid != pMU && genMomentum.Pt() > DET->PT_TRACKS_MIN)
                towersS.push_back
                 (
                   PhysicsTower
                    (
                      LorentzVector(genMomentum.Px(),genMomentum.Py(),genMomentum.Pz(), genMomentum.E())
                    )
                 );
		// all final charged particles
		if(
		     ((rand()%100) < DET->TRACKING_EFF)  &&
		     (genMomentum.E()!=0) &&
		     (fabs(particle->Eta) < DET->MAX_TRACKER) && 
		     (genMomentum.Pt() > DET->PT_TRACKS_MIN ) &&     // pt too small to be taken into account
		     (pid != pGAMMA)    && 
		     (pid != pPI0)      &&
		     (pid != pK0L)      &&
		     (pid != pN)        &&
		     (pid != pSIGMA0)   &&
		     (pid != pDELTA0)   &&
		     (pid != pK0S)   // not charged particles : invisible by tracker
                 )
		      TrackCentral.push_back(genMomentum);
	    } // switch
	} // while


      //*****************************
      JetCluAlgorithm jetAlgoS(1,DET->CONERADIUS,DET->C_ADJACENCYCUT,DET->C_MAXITERATIONS,DET->C_IRATCH,DET->C_OVERLAPTHRESHOLD);
      jetAlgoS.run(towersS, jetsS);

      JetCluAlgorithm jetAlgo(0,DET->CONERADIUS,DET->C_ADJACENCYCUT,DET->C_MAXITERATIONS,DET->C_IRATCH,DET->C_OVERLAPTHRESHOLD);
      jetAlgo.run(towers, jets);


      vector<Cluster>::iterator itJet;
      TLorentzVector JETSm(0,0,0,0);
      for(itJet = jets.begin(); itJet != jets.end(); ++itJet) {
          jetMomentum = itJet->fourVector;
          TLorentzVector JET(0,0,0,0);
          JET.SetPxPyPzE(jetMomentum.px,jetMomentum.py,jetMomentum.pz,jetMomentum.E);
          PairingJet(JETSm,JET,jetsS);
          if(JETSm.Pt()>3)
            {
              elementJet= (RESOLJET*) branchjet->NewEntry();
              elementJet->NonSmearePT = JET.Pt();
              elementJet->SmearePT = (JETSm.Pt()/JET.Pt());
              /*cout<<"valeur obtenue "<<JETSm.Pt()/JET.Pt()<<endl;
              cout<<" pt non smeare "<<JET.Pt()<<" phi "<<JET.Phi()<<" eta "<<JET.Eta()<<endl;
              cout<<"pt smeare "<<JETSm.Pt()<<" phi "<<JETSm.Phi()<<" eta "<<JETSm.Eta()<<endl;
              cout<<"************"<<endl;
*/
            }

	} // for itJet : loop on all jets

      treeWriter->Fill();
    } // Loop over all events
  treeWriter->Write();
  
  cout << "** Exiting..." << endl;
  
  delete treeWriter;
  delete treeReader;
  delete DET;
  if(converter) delete converter;
}