#include <iostream>
#include "cometEventLoop.hxx"
#include "ICosmicTrigger.hxx"
#include "IRealDatum.hxx"
#include "IIntegerDatum.hxx"
#include <TH1F.h>
#include <TPad.h>

/// Program to run the cosmic trigger simulation and save output.
class IRunCosmicTriggerLoop: public COMET::ICOMETEventLoopFunction {
protected:
  ICosmicTrigger *fTrigger;
  ULong64_t wordsseen[100];
  int ntimesseen[100];
  int nwordsseen;
  int ntriggers;
  int CPWeight;

public:
  IRunCosmicTriggerLoop() {fTrigger = 0;};  
  virtual ~IRunCosmicTriggerLoop() {delete fTrigger;};

  bool operator () (COMET::ICOMETEvent& event) {
    COMET::ICOMETEvent::Header myHeader = event.GetHeader();
    ULong64_t triggerBits = myHeader.GetTriggerBits();
  
    // Get the words containing which trigger primitives fired
    ULong64_t CTMword[3];
    for(int i=0; i<3;++i){
      CTMword[i] = myHeader.GetCTMTriggerPattern(i);
      // std::cout << CTMword[i] << std::endl;
    }
    //std::cout << CTMword[2] << std::endl;

    COMET::IHandle<COMET::IIntegerDatum> trigtype = event.Get<COMET::IIntegerDatum>("triptCosmicTriggerType");
    COMET::IHandle<COMET::IIntegerDatum> trigupward = event.Get<COMET::IIntegerDatum>("triptCosmicTriggerUpward");
    COMET::IHandle<COMET::IRealDatum> preweight = event.Get<COMET::IRealDatum>("CosmicPrescaleWeight");
    std::cout << "prescale weight = " << preweight->GetValue() << std::endl;

    double tt = 0;
    if(trigtype){
      tt = trigtype->GetValue();
      // std::cout << tt << std::endl;
      htrigtype->Fill(tt);
      hupdown->Fill(trigupward->GetValue());
      ntriggers++;
    }

    ULong64_t testbit;
    for(int i=0;i<32;++i){
      // fill P0D primitives histogram
      testbit = 1;
      testbit = testbit<<i;
      if(CTMword[2]&(testbit)){
  hprimitivesP0D->Fill(i);
  //std::cout << "P0D bit " << i << " " << testbit << std::endl;
  if(tt==12||tt==8||tt==10||tt==14||tt==6){
    hprimtrigP0D->SetBinContent(i,hprimtrigP0D->GetBinContent(i)+1);
  }else{
    hprimnotP0D->SetBinContent(i,hprimnotP0D->GetBinContent(i)+1);
  }
      }
      testbit = testbit<<32;
      if(CTMword[2]&(testbit)){
  hprimitivesECAL->SetBinContent(i,hprimitivesECAL->GetBinContent(i)+1);
  //std::cout << "ECAL bit " << i << " " << testbit << std::endl;
  if(tt==13||tt==9||tt==11||tt==14||tt==7){
    hprimtrigECAL->SetBinContent(i,hprimtrigECAL->GetBinContent(i)+1);
  }else{
    hprimnotECAL->SetBinContent(i,hprimnotECAL->GetBinContent(i)+1);
  }
      }
    }

    //    ULong64_t triggerWord = (myHeader.GetTriggerWord() & 0x03ff000000000000) >> 48;
    if (trigtype) {
      //  std::cout << "trigtype, trigupward = " << trigtype->GetValue() << ", " << trigupward->GetValue() << std::endl;
    }
  
    bool seen = false;
    for (int i=0; i<nwordsseen; i++) {
      if (wordsseen[i] == triggerBits) {
  seen = true;
  ntimesseen[i]++;
      }
    }
    if (!seen) {
      wordsseen[nwordsseen] = triggerBits;
      ntimesseen[nwordsseen] = 1;
      nwordsseen++;
    }
    return true;
  };

  void BeginFile(COMET::IVInputFile *input) {
    if(fTrigger)
      delete fTrigger;    
    fTrigger = new ICosmicTrigger();
  };

  void Initialize() {
    nwordsseen = 0;
    ntriggers = 0;
    hprimitivesECAL = new TH1F("hprimitivesECAL","",33,-0.5,32.5);
    hprimitivesP0D = new TH1F("hprimitivesP0D","",33,-0.5,32.5);
    hprimtrigECAL = new TH1F("hprimtrigECAL","",33,-0.5,32.5);
    hprimtrigP0D = new TH1F("hprimtrigP0D","",33,-0.5,32.5);
    hprimnotECAL = new TH1F("hprimnotECAL","",33,-0.5,32.5);
    hprimnotP0D = new TH1F("hprimnotP0D","",33,-0.5,32.5);
    htrigtype = new TH1F("htrigtype","",21,-0.5,20.5);
    hupdown = new TH1F("hupdown","",3,-0.5,2.5);
    for(int i=0;i<33;++i){
      hprimitivesECAL->SetBinContent(i,0);
      hprimitivesP0D->SetBinContent(i,0); 
      hprimtrigECAL->SetBinContent(i,0);
      hprimtrigP0D->SetBinContent(i,0);
      hprimnotECAL->SetBinContent(i,0); 
      hprimnotP0D->SetBinContent(i,0);
      if(i<=21)htrigtype->SetBinContent(i,0);
      if(i<=3)hupdown->SetBinContent(i,0);
    }
  };

  void Finalize(COMET::ICOMETOutput* output) {
    std::cout << "saw " << nwordsseen << " words" << std::endl;
    for (int i=0; i<nwordsseen; i++) {
      std::cout << "saw trigger word = " << std::hex << wordsseen[i] << std::dec << " " << ntimesseen[i] << " times" << std::endl;
    }
    hprimitivesECAL->Draw();
    gPad->Print("ECALAllprimitivesFired.C");
    hprimitivesP0D->Draw();
    gPad->Print("P0DAllprimitivesFired.C");
    hprimtrigECAL->Draw();
    gPad->Print("ECALprimitivesFiredInGlobal.C");
    hprimtrigP0D->Draw();
    gPad->Print("P0DprimitivesFiredInGlobal.C");
    hprimnotECAL->Draw();
    gPad->Print("ECALprimitivesFiredOther.C");
    hprimnotP0D->Draw();
    gPad->Print("P0DprimitivesFiredOther.C");
    htrigtype->Draw();
    gPad->Print("GlobalTriggerTypes.C");
    hupdown->Draw();
    gPad->Print("UpDown.C");
    std::cout << "Number of cosmic triggers generated = " << ntriggers << std::endl;
  };
private: 
  TH1F *hprimitivesECAL;
  TH1F *hprimitivesP0D; 
  TH1F *hprimtrigECAL;
  TH1F *hprimtrigP0D; 
  TH1F *hprimnotECAL;
  TH1F *hprimnotP0D; 
  TH1F *htrigtype;
  TH1F *hupdown;
};

int main(int argc, char **argv) {
  IRunCosmicTriggerLoop userCode;
  cometEventLoop(argc,argv,userCode);
}