/*
 *   ---- Delphes ----
 *     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
 *             */

// \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;
  event_i = tt.event_i;
  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) {
  event_i = tt.event_i;
  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() ) {
	cout << "ERROR: Trigger input file "<< filename << " not found. Exiting.\n";
	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();
	MuonValues.clear();
	JetValues.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.MuonValues.size(); i++)
	MuonValues.push_back(tb.MuonValues[i]);

  for(unsigned int i=0; i<tb.JetValues.size(); i++)
        JetValues.push_back(tb.JetValues[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.MuonValues.size(); i++)
        MuonValues.push_back(tb.MuonValues[i]);

  for(unsigned int i=0; i<tb.JetValues.size(); i++)
        JetValues.push_back(tb.JetValues[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)
{
  int elec_size = ElecValues.size();
  int muon_size = MuonValues.size();
  int jet_size = JetValues.size();
  int taujet_size = TauJetValues.size();
  int gamma_size = GammaValues.size();
  int etmis_size = EtmisValues.size();

  Result=false;
  if(
     (branchElecTrig->GetEntries() >= elec_size )
      && (branchMuonTrig->GetEntries() >= muon_size )
      && (branchJetTrig->GetEntries() >= jet_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(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(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(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> MuonSequences;
  vector<string> JetSequences;
  vector<string> TauJetSequences;
  vector<string> EtmisSequences;
  vector<string> GammaSequences;

  char *result = NULL;
  result = strtok( (char*) trigger_algorithm.c_str(),"&");
  while( result != NULL )
     {
       if(strstr (result,"ELEC"))ElecSequences.push_back(result);
       if(strstr (result,"MUON"))MuonSequences.push_back(result);
       if(strstr (result,"JET"))JetSequences.push_back(result);
       if(strstr (result,"TAUJET"))TauJetSequences.push_back(result);
       if(strstr (result,"ETMIS"))EtmisSequences.push_back(result);
       if(strstr (result,"GAMMA"))GammaSequences.push_back(result);
       result = strtok( NULL,"&");
     }

  ElecValues = GetCuts(ElecSequences);
  MuonValues = GetCuts(MuonSequences);
  JetValues = GetCuts(JetSequences);
  TauJetValues = GetCuts(TauJetSequences);
  EtmisValues = GetCuts(EtmisSequences);
  GammaValues = GetCuts(GammaSequences);

}


void TriggerBit::PrintTrigCondition(const string& LogName,const int i) 
{
  int elec_size = TriggerBit::ElecValues.size();
  int muon_size = TriggerBit::MuonValues.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();
  
  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";
  f_out << left << setw(1) <<"*"
        << internal << setw(10) << "Electron"<< ""<< internal << setw(10) << "Muon"    << ""
        << internal << setw(10) << "Jets"    << ""<< internal << setw(10) << "Tau-jets "<< ""
        << internal << setw(10) << "Photons" << ""<< internal << setw(10) << "ETmis "<< ""<< right    << setw(9)  <<"*"<<"\n";
  f_out << left << setw(1) <<"*"
        << internal << setw(10) << elec_size << ""<< internal << setw(10) << muon_size << ""
        << internal << setw(10) << jet_size  << ""<< internal << setw(10) << taujet_size << ""
        << internal << setw(10) << gamma_size<< ""<< internal << setw(10) << etmis_size << ""<< right << setw(9)<<"*"<<"\n";
  f_out << left << setw(45) <<"*   # Values of the related thresholds: "<<""<<right << setw(25)<<"*"<<"\n";
  if(elec_size!=0){
  f_out << left << setw(20) <<"*    - Electrons: "<<"";
  for(int i=0;i<elec_size;i++){f_out << left << setw(5) << TriggerBit::ElecValues[i]<<"";}f_out <<"\n";}

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

  if(jet_size!=0){
  f_out << left << setw(20) <<"*    - Jets: "<<"";
  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(20) <<"*    - Tau-jets: "<<"";
  for(int i=0;i<taujet_size;i++){f_out << left << setw(5) << TriggerBit::TauJetValues[i]<<"";}f_out <<"\n";}
 
  if(gamma_size!=0){
  f_out << left << setw(20) <<"*    - Photons: "<<"";
  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(20) <<"*    - ETMIS: "<<"";
  for(int i=0;i<etmis_size;i++){f_out << left << setw(5) << TriggerBit::EtmisValues[i]<<"";}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;

}