/***********************************************************************
**                                                                    **
**          /----------------------------------------------\          **
**         |  Delphes, a framework for the fast simulation  |         **
**         |       of a  generic collider experiment        |         **
**          \-------------  arXiv:0903.2225v1  ------------/          **
**                                                                    **
**                                                                    **
**   This package uses:                                               **
**   ------------------                                               **
**   ROOT: Nucl. Inst. & Meth. in Phys. Res. A389 (1997) 81-86        **
**   FastJet algorithm: Phys. Lett. B641 (2006) [hep-ph/0512210]      **
**   Hector: JINST 2:P09005 (2007) [physics.acc-ph:0707.1198v2]       **
**   FROG: [hep-ex/0901.2718v1]                                       **
**   HepMC: Comput. Phys. Commun.134 (2001) 41                        **
**                                                                    **
** ------------------------------------------------------------------ **
**                                                                    **
**   Main authors:                                                    **
**   -------------                                                    **
**                                                                    **
**                Severine Ovyn                Xavier Rouby           **
**          severine.ovyn@uclouvain.be      xavier.rouby@cern         **
**                                                                    **
**         Center for Particle Physics and Phenomenology (CP3)        **
**                Universite catholique de Louvain (UCL)              **
**                     Louvain-la-Neuve, Belgium                      **
**                                                                    **
**                      Copyright (C) 2008-2009,                      **
**                        All rights reserved.                        **
**                                                                    **
***********************************************************************/


// \brief Trigger class, and some generic definitions

#include "TriggerUtil.h"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <string>

using namespace std;

TriggerTable::TriggerTable() {
  has_been_evaluated=false;
}

TriggerTable& TriggerTable::operator=(TriggerTable&tt) {
  if (this == &tt) return *this;
  has_been_evaluated = tt.has_been_evaluated;
  GlobalResult = tt.GlobalResult;
  for (unsigned int i=0; i<tt.list_of_trigger_bits.size(); i++)
        list_of_trigger_bits.push_back(tt.list_of_trigger_bits[i]);
  return *this;
}

TriggerTable::TriggerTable(const TriggerTable& tt) {
  has_been_evaluated = tt.has_been_evaluated;
  GlobalResult = tt.GlobalResult;
  for (unsigned int i=0; i<tt.list_of_trigger_bits.size(); i++)
	list_of_trigger_bits.push_back(tt.list_of_trigger_bits[i]);
}


void TriggerTable::TriggerCardReader(const string& filename){
   ifstream trigger_file(filename.c_str());
   if( !trigger_file.good() ) {
       cerr << left  << setw(30) <<"** ERROR: Trigger input file "<<""
          << right << setw(15) <<filename<<""
          << right << setw(24)  <<"not found. Exiting... **"<<endl;
	return;
   }

   TriggerBit mybit;
   string temp_string, temp_string_no_comment, trigger_name, trigger_algorithm;
   while ( getline(trigger_file,temp_string) ) {
	string temp_string_no_comment = temp_string.substr(0,temp_string.find("#")); //remove comments
	if(temp_string_no_comment.size()<2) continue;  // avoid empty lines
 	istringstream temp_stream(temp_string_no_comment);

	temp_stream >> trigger_name;
	trigger_algorithm = temp_string_no_comment.substr( temp_string_no_comment.find(">>")+2) ;

        mybit.TriggerBit::GetTrigCondition(trigger_algorithm);
        list_of_trigger_bits.push_back(mybit);
   }
}


void TriggerTable::PrintTriggerTable(const string& LogName) {

  ofstream f_out(LogName.c_str(),ios::app);
  f_out<<"*                                                                    *"<<"\n";
  f_out<<"#***********************************************                     *"<<"\n";
  f_out<<"# Trigger conditions defined in the trigger card                     *"<<"\n";
  f_out<<"#***********************************************                     *"<<"\n";
  f_out<<"*                                                                    *"<<"\n";

  f_out.close();
 
  for(unsigned int i=0; i < list_of_trigger_bits.size(); i++) {
  list_of_trigger_bits[i].PrintTrigCondition(LogName,i+1);
 }
  f_out<<"*                                                                    *"<<"\n";
  f_out<<"#*********************************************************************"<<"\n";

}

bool TriggerTable::GetGlobalResult(TClonesArray *branchElecTrig, TClonesArray *branchMuonTrig,
      TClonesArray *branchJetTrig, TClonesArray *branchTauJetTrig,
      TClonesArray *branchPhotonTrig,  TClonesArray *branchETmisTrig, ExRootTreeBranch *branchTrigger) {

  TRootTrigger *elementTrigger;
  GlobalResult=false;
  for(unsigned int i=0; i < list_of_trigger_bits.size(); i++) {
  if(list_of_trigger_bits[i].GetResult(branchElecTrig, branchMuonTrig,  branchJetTrig, branchTauJetTrig, branchPhotonTrig, branchETmisTrig))
    {
       GlobalResult=true;
       int flag=i+1;
       elementTrigger = (TRootTrigger*) branchTrigger->NewEntry();
       elementTrigger->Accepted=flag;
    }
  }
  if(GlobalResult)
    {
      elementTrigger = (TRootTrigger*) branchTrigger->NewEntry();
      elementTrigger->Accepted=0;
    }
    return GlobalResult;

}

//*************************************************************************
TriggerBit::TriggerBit() {
}

TriggerBit::~TriggerBit() {
	ElecValues.clear();
	IElecValues.clear();
	MuonValues.clear();
	IMuonValues.clear();
	JetValues.clear();
	BjetValues.clear();
	TauJetValues.clear();
	EtmisValues.clear();
	GammaValues.clear();
}

TriggerBit::TriggerBit(const TriggerBit& tb) {
  for(unsigned int i=0; i<tb.ElecValues.size(); i++)
	ElecValues.push_back(tb.ElecValues[i]);

  for(unsigned int i=0; i<tb.IElecValues.size(); i++)
        IElecValues.push_back(tb.IElecValues[i]);

  for(unsigned int i=0; i<tb.MuonValues.size(); i++)
	MuonValues.push_back(tb.MuonValues[i]);

  for(unsigned int i=0; i<tb.IMuonValues.size(); i++)
        IMuonValues.push_back(tb.IMuonValues[i]);

  for(unsigned int i=0; i<tb.JetValues.size(); i++)
        JetValues.push_back(tb.JetValues[i]);

  for(unsigned int i=0; i<tb.BjetValues.size(); i++)
        BjetValues.push_back(tb.BjetValues[i]);

  for(unsigned int i=0; i<tb.TauJetValues.size(); i++)
        TauJetValues.push_back(tb.TauJetValues[i]);

  for(unsigned int i=0; i<tb.EtmisValues.size(); i++)
        EtmisValues.push_back(tb.EtmisValues[i]);

  for(unsigned int i=0; i<tb.GammaValues.size(); i++)
        GammaValues.push_back(tb.GammaValues[i]);

  Result = tb.Result;
}

TriggerBit& TriggerBit::operator=(const TriggerBit& tb) {
  if (this==&tb) return *this;
  for(unsigned int i=0; i<tb.ElecValues.size(); i++)
        ElecValues.push_back(tb.ElecValues[i]);

  for(unsigned int i=0; i<tb.IElecValues.size(); i++)
        IElecValues.push_back(tb.IElecValues[i]);

  for(unsigned int i=0; i<tb.MuonValues.size(); i++)
        MuonValues.push_back(tb.MuonValues[i]);

  for(unsigned int i=0; i<tb.IMuonValues.size(); i++)
        IMuonValues.push_back(tb.IMuonValues[i]);

  for(unsigned int i=0; i<tb.JetValues.size(); i++)
        JetValues.push_back(tb.JetValues[i]);

  for(unsigned int i=0; i<tb.BjetValues.size(); i++)
        BjetValues.push_back(tb.BjetValues[i]);

  for(unsigned int i=0; i<tb.TauJetValues.size(); i++)
        TauJetValues.push_back(tb.TauJetValues[i]);

  for(unsigned int i=0; i<tb.EtmisValues.size(); i++)
        EtmisValues.push_back(tb.EtmisValues[i]);

  for(unsigned int i=0; i<tb.GammaValues.size(); i++)
        GammaValues.push_back(tb.GammaValues[i]);
  Result = tb.Result;

  return *this;
}



bool TriggerBit::GetResult(TClonesArray *branchElecTrig, TClonesArray *branchMuonTrig,
      TClonesArray *branchJetTrig, TClonesArray *branchTauJetTrig,
      TClonesArray *branchPhotonTrig,  TClonesArray *branchETmisTrig)
{
  TSimpleArray<TRootJet> bjets=SubArrayBjets(branchJetTrig);
  TSimpleArray<TRootElectron> Ielectron=SubArrayIElec(branchElecTrig);
  TSimpleArray<TRootMuon> Imuon=SubArrayIMuon(branchMuonTrig);

  int elec_size = ElecValues.size();
  int Ielec_size = IElecValues.size();
  int muon_size = MuonValues.size();
  int Imuon_size = IMuonValues.size();
  int jet_size = JetValues.size();
  int bjet_size = BjetValues.size();
  int taujet_size = TauJetValues.size();
  int gamma_size = GammaValues.size();
  int etmis_size = EtmisValues.size();

  Result=false;
  if(
     (branchElecTrig->GetEntries() >= elec_size )
      && (Ielectron.GetEntries() >= Ielec_size )
      && (branchMuonTrig->GetEntries() >= muon_size )
      && (Imuon.GetEntries() >= Imuon_size )
      && (branchJetTrig->GetEntries() >= jet_size )
      && (bjets.GetEntries() >= bjet_size )
      && (branchTauJetTrig->GetEntries() >= taujet_size )
      && (branchPhotonTrig->GetEntries() >= gamma_size )
    )
    {
      Result=true;
      if(elec_size!=0){
        TRootElectron *electron;
	for(int i=0;i<elec_size;i++){
           electron = (TRootElectron*)branchElecTrig->At(i);
           if(electron->PT < ElecValues[i])Result=false;}}

      if(Ielec_size!=0)
        {
         TRootElectron *i_elec; Ielectron.Reset();
         int i=0;
         while((i_elec = Ielectron.Next()))
              {
                if(i_elec->PT < IElecValues[i])Result=false;
                i++;
              }
        }

      if(muon_size!=0){
        TRootMuon *muon;
        for(int i=0;i<muon_size;i++){
           muon = (TRootMuon*)branchMuonTrig->At(i);
           if(muon->PT < MuonValues[i])Result=false;}}

      if(Imuon_size!=0)
        {
         TRootMuon *i_muon; Imuon.Reset();
         int i=0;
         while((i_muon = Imuon.Next()))
              {
                if(i_muon->PT < IMuonValues[i])Result=false;
                i++;
              }
        }

      if(jet_size!=0){
        TRootJet *jet;
        for(int i=0;i<jet_size;i++){
           jet = (TRootJet*)branchJetTrig->At(i);
           if(jet->PT < JetValues[i])Result=false;}}

      if(bjet_size!=0)
        {
         TRootJet *i_bjets; bjets.Reset();
         int i=0;
         while((i_bjets = bjets.Next()))
              {
                if(i_bjets->PT < BjetValues[i])Result=false;
                i++;
              }
        }

      if(taujet_size!=0){
        TRootTauJet *taujet;
        for(int i=0;i<taujet_size;i++){
           taujet = (TRootTauJet*)branchTauJetTrig->At(i);
           if(taujet->PT < TauJetValues[i])Result=false;}}

      if(gamma_size!=0){
        TRootPhoton *gamma;
        for(int i=0;i<gamma_size;i++){
           gamma = (TRootPhoton*)branchPhotonTrig->At(i);
           if(gamma->PT < GammaValues[i])Result=false;}}


      if(etmis_size!=0){
        TRootETmis *etmis = (TRootETmis*)branchETmisTrig->At(0);
           if(etmis->ET < EtmisValues[0])Result=false;}
    
   }
  return Result;
}

void TriggerBit::GetTrigCondition(const string& trigger_algorithm) {

  vector<string> ElecSequences;
  vector<string> IElecSequences;
  vector<string> MuonSequences;
  vector<string> IMuonSequences;
  vector<string> JetSequences;
  vector<string> TauJetSequences;
  vector<string> EtmisSequences;
  vector<string> GammaSequences;
  vector<string> BjetSequences;

  char * result = new char[256];
  result = strtok( (char*) trigger_algorithm.c_str(),"&");
  while( result != NULL )
     {
       if(strstr (result,"ELEC"))ElecSequences.push_back(result);
       if(strstr (result,"IElec"))IElecSequences.push_back(result);
       if(strstr (result,"MUON"))MuonSequences.push_back(result);
       if(strstr (result,"IMuon"))IMuonSequences.push_back(result);
       if(strstr (result,"JET"))JetSequences.push_back(result);
       if(strstr (result,"TAU"))TauJetSequences.push_back(result);
       if(strstr (result,"ETMIS"))EtmisSequences.push_back(result);
       if(strstr (result,"GAMMA"))GammaSequences.push_back(result);
       if(strstr (result,"Bjet"))BjetSequences.push_back(result);
       result = strtok( NULL,"&");
     }
  delete [] result;

  ElecValues = GetCuts(ElecSequences);
  IElecValues = GetCuts(IElecSequences);
  MuonValues = GetCuts(MuonSequences);
  IMuonValues = GetCuts(IMuonSequences);
  JetValues = GetCuts(JetSequences);
  TauJetValues = GetCuts(TauJetSequences);
  EtmisValues = GetCuts(EtmisSequences);
  GammaValues = GetCuts(GammaSequences);
  BjetValues = GetCuts(BjetSequences);

}


void TriggerBit::PrintTrigCondition(const string& LogName,const int i) 
{
  int elec_size = TriggerBit::ElecValues.size();
  int Ielec_size = TriggerBit::IElecValues.size();
  int muon_size = TriggerBit::MuonValues.size();
  int Imuon_size = TriggerBit::IMuonValues.size();
  int jet_size = TriggerBit::JetValues.size();
  int taujet_size = TriggerBit::TauJetValues.size();
  int gamma_size = TriggerBit::GammaValues.size();
  int etmis_size = TriggerBit::EtmisValues.size();
  int bjets_size = TriggerBit::BjetValues.size();

  ofstream f_out(LogName.c_str(),ios::app);

  f_out <<"*                                                                    *"<<"\n";
  f_out << left << setw(25) <<"# Trigger bit number "<<""
        << left << setw(35) <<i       <<""<< right << setw(10)<<"*"<<"\n";
  f_out <<"#*************************"<<"\n";
  f_out << left << setw(45) <<"*   # Number of reconstructed objects required:"<<""<<right << setw(23)<<"*"<<"\n";
  
  if(elec_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << elec_size <<""<< left << setw(20)<<"Electron(s) with p_T: "<<"";
  for(int i=0;i<elec_size;i++){f_out << left << setw(5) << TriggerBit::ElecValues[i]<<"";}f_out <<"\n";}

  if(Ielec_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << Ielec_size <<""<< left << setw(20)<<"Isolated electron(s) with p_T: "<<"";
  for(int i=0;i<Ielec_size;i++){f_out << left << setw(5) << TriggerBit::IElecValues[i]<<"";}f_out <<"\n";}

  if(muon_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << muon_size <<""<< left << setw(20)<<"Muon(s) with p_T: "<<"";
  for(int i=0;i<muon_size;i++){f_out << left << setw(5) << TriggerBit::MuonValues[i]<<"";}f_out <<"\n";}

  if(Imuon_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << Imuon_size <<""<< left << setw(20)<<"Isolated muon(s) with p_T: "<<"";
  for(int i=0;i<Imuon_size;i++){f_out << left << setw(5) << TriggerBit::IMuonValues[i]<<"";}f_out <<"\n";}

  if(jet_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << jet_size <<""<< left << setw(20)<<"Jet(s) with p_T: "<<"";
  for(int i=0;i<jet_size;i++){f_out << left << setw(5) << TriggerBit::JetValues[i]<<"";}f_out <<"\n";}

  if(taujet_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << taujet_size <<""<< left << setw(20)<<"Tau-jet(s) with p_T: "<<"";
  for(int i=0;i<taujet_size;i++){f_out << left << setw(5) << TriggerBit::TauJetValues[i]<<"";}f_out <<"\n";}

  if(bjets_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << bjets_size <<""<< left << setw(20)<<"B-jet(s) with p_T: "<<"";
  for(int i=0;i<bjets_size;i++){f_out << left << setw(5) << TriggerBit::BjetValues[i]<<"";}f_out <<"\n";}

  if(gamma_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(2) << gamma_size <<""<< left << setw(20)<<"Photon(s) with p_T: "<<"";
  for(int i=0;i<gamma_size;i++){f_out << left << setw(5) << TriggerBit::GammaValues[i]<<"";}f_out <<"\n";}
 
  if(etmis_size!=0){
  f_out << left << setw(5) <<"**  -"<<""<< left << setw(20)<<"Transverse missing energy with p_T: "<<"";
  for(int i=0;i<etmis_size;i++){f_out << left << setw(5) << TriggerBit::EtmisValues[i]<<"";}f_out <<"\n";}
  f_out <<"*                                                                    *"<<"\n";
  f_out <<"**********************************************************************"<<"\n";

}

vector<float> TriggerBit::GetCuts(const vector<string> &Sequences)
{
  vector<float> OrderedValue;
  string ptVal;
  Int_t PtVal=0;
  for(unsigned int i=0; i < Sequences.size(); i++) {
    ptVal = Sequences[i].substr( Sequences[i].find("'")+1) ;
    PtVal = atoi( ptVal.c_str() );
    OrderedValue.push_back(PtVal);
   }
  return OrderedValue;

}

TSimpleArray<TRootJet> TriggerBit::SubArrayBjets(TClonesArray *JET)
{
   TIter itJet((TCollection*)JET);
   TRootJet *jet;
   itJet.Reset();
   TSimpleArray<TRootJet> array;
   while( (jet = (TRootJet*) itJet.Next()) )
     {
        if(jet->Btag==1)array.Add(jet);
     }
   return array;
}

TSimpleArray<TRootElectron> TriggerBit::SubArrayIElec(TClonesArray *ELEC)
{
   TIter itElec((TCollection*)ELEC);
   TRootElectron *electron;
   itElec.Reset();
   TSimpleArray<TRootElectron> array;
   while( (electron = (TRootElectron*) itElec.Next()) )
     {
        if(electron->IsolFlag==1)array.Add(electron);
     }
   return array;
}

TSimpleArray<TRootMuon> TriggerBit::SubArrayIMuon(TClonesArray *MUON)
{
   TIter itMuon((TCollection*)MUON);
   TRootMuon *muon;
   itMuon.Reset();
   TSimpleArray<TRootMuon> array;
   while( (muon = (TRootMuon*) itMuon.Next()) )
     {
        if(muon->IsolFlag==1)array.Add(muon);
     }
   return array;
}