#include "stdio.h"
#include "iostream"
#include "vector"
#include <utility>
#include <fstream>

#include <TSystem.h>
#include <TROOT.h>
#include <TApplication.h>
#include <memory>
#include <string>
#include <TCanvas.h>
#include <TStyle.h>
#include <TF1.h>
#include <TH1.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TMultiGraph.h>
#include <TBox.h>
#include <TNtuple.h>
#include <TFile.h>
#include <TChain.h>
#include <TProfile.h>
#include <TRefArray.h>
#include <TClonesArray.h>
#include <TLegend.h>
#include <TGeoManager.h>
#include <TTree.h>
#include <TVector3.h>
#include <TLorentzVector.h>
#include <TStopwatch.h>
#include <TLatex.h>
#include <TString.h>
#include <TRandom.h>
#include <time.h>

#include "IBeamSummaryDataModule.hxx"
#include "IRawBeamData.hxx"

COMET::IRawBeamData fRawBeamData;

//______________________________________________________________________________________

using namespace COMET;

bool DataCheck(Int_t COMETSpill, UInt_t EventTime, COMET::IBeamSummaryDataModule::IBeamSummaryData *bsd){
  bool ret = fRawBeamData.GetSpill(COMETSpill, EventTime, 1);
  bool Flag_MainData = false;
  bool Flag_MainData2 = false;
  bool Flag_OtherData1 = false;
  bool Flag_OtherData2 = false;
  bool Flag_OtherData3 = false;
  bool Flag_OtherData4 = false;
  bool Flag_OtherData5 = false;
  bool Flag_OtherData6 = false;
  if (ret == false){
    std::cout << "Cannot Find Spill!" << std::endl; 
    return false;
  }
  else if (ret == true) {
    if(
        bsd->BeamRunNumber == fRawBeamData.GetBeamRunNumber() &&
        bsd->SpillNumber == fRawBeamData.GetSpillNumber() &&
        bsd->GPS1TriggerTime == fRawBeamData.GetTriggerTime(0) &&
        bsd->GPS1TriggerTimeNanoSecond == fRawBeamData.GetTriggerTimeNanoSecond(0) &&
        bsd->CT5ProtonsPerSpill == fRawBeamData.GetProtonsPerSpill(4) &&
        bsd->GoodSpillFlag == fRawBeamData.GetGoodSpillFlag() &&
        bsd->Horn1CurrentSum == fRawBeamData.GetHornCurrent(0) &&
        bsd->Horn2CurrentSum == fRawBeamData.GetHornCurrent(1) &&
        bsd->Horn3CurrentSum == fRawBeamData.GetHornCurrent(2) &&
        bsd->BSDVersion == fRawBeamData.GetBSDVersion() 
      )	Flag_MainData = true;

    for(int bunch_1 = 0; bunch_1 < 8; ++bunch_1){
      if(
          bsd->CT5ProtonsPerBunch[bunch_1] == fRawBeamData.GetProtonsPerBunch(4,bunch_1+1) &&
          bsd->CT5BeamBunchTiming[bunch_1] == fRawBeamData.GetBeamBunchTiming(4,bunch_1+1) &&
          bsd->CT5BeamBunchFlag[bunch_1] == fRawBeamData.GetBeamFlag(bunch_1+1)
        )	Flag_MainData2 = true;
      else{ 
        Flag_MainData2 =false;
        //std::cout<< "FlagM2 error"<<std::endl;
        break;
      }
    }

    if(
        bsd->OtherData.SpillNumber == fRawBeamData.GetSpillNumber() &&
        bsd->OtherData.MRRunNumber == fRawBeamData.GetMRRunNumber() &&
        bsd->OtherData.BeamRunNumber == fRawBeamData.GetBeamRunNumber() &&
        bsd->OtherData.SpillFlag == fRawBeamData.GetSpillFlag() &&
        bsd->OtherData.TriggerFlag == fRawBeamData.GetTriggerFlag() &&
        bsd->OtherData.GoodGPSFlag == fRawBeamData.GetGoodGPSFlag() &&
        bsd->OtherData.GoodSpillFlag == fRawBeamData.GetGoodSpillFlag() &&
        bsd->OtherData.MagSetID == fRawBeamData.GetMagSetID() &&
        bsd->OtherData.RunType == fRawBeamData.GetRunType()
      ) Flag_OtherData1 = true;

    if(
        bsd->OtherData.MumonSiTotalQ == fRawBeamData.GetMumonSiTotalQ() &&
        bsd->OtherData.MumonSiPeak == fRawBeamData.GetMumonSiPeak() &&
        bsd->OtherData.MumonSiX == fRawBeamData.GetMumonSiX() &&
        bsd->OtherData.MumonSiwX == fRawBeamData.GetMumonSiwX() &&
        bsd->OtherData.MumonSiY == fRawBeamData.GetMumonSiY() &&
        bsd->OtherData.MumonSiwY == fRawBeamData.GetMumonSiwY() &&

        bsd->OtherData.MumonICTotalQ == fRawBeamData.GetMumonICTotalQ() &&
        bsd->OtherData.MumonICPeak == fRawBeamData.GetMumonICPeak() &&
        bsd->OtherData.MumonICX == fRawBeamData.GetMumonICX() &&
        bsd->OtherData.MumonICwX == fRawBeamData.GetMumonICwX() &&
        bsd->OtherData.MumonICY == fRawBeamData.GetMumonICY() &&
        bsd->OtherData.MumonICwY == fRawBeamData.GetMumonICwY() 
      ) Flag_OtherData2 = true;

    if(
        bsd->OtherData.OTRX == fRawBeamData.GetOTRX() &&
        bsd->OtherData.OTRY == fRawBeamData.GetOTRY() &&
        bsd->OtherData.OTRwX == fRawBeamData.GetOTRwX() &&
        bsd->OtherData.OTRwY == fRawBeamData.GetOTRwY() &&
        bsd->OtherData.OTRXError == fRawBeamData.GetOTRXError() &&
        bsd->OtherData.OTRYError == fRawBeamData.GetOTRYError() &&
        bsd->OtherData.OTRwXError == fRawBeamData.GetOTRwXError() &&
        bsd->OtherData.OTRwYError == fRawBeamData.GetOTRwYError() &&
        bsd->OtherData.OTRLightYield == fRawBeamData.GetOTRLightYield() &&
        bsd->OtherData.GPSStatus[0] == fRawBeamData.GetGPSStatus(0)&&
        bsd->OtherData.GPSStatus[1] == fRawBeamData.GetGPSStatus(1)&&
        bsd->OtherData.BeamDirectionOnTarget[0] == fRawBeamData.GetBeamDirectionOnTarget(0)&&
        bsd->OtherData.BeamSizeOnTarget[0] == fRawBeamData.GetBeamSizeOnTarget(0)&&
        bsd->OtherData.BeamDirectionOnTarget[1] == fRawBeamData.GetBeamDirectionOnTarget(1)&&
        bsd->OtherData.BeamSizeOnTarget[1] == fRawBeamData.GetBeamSizeOnTarget(1)
      ) Flag_OtherData3 = true;

    for(int iGPSoriHorn = 0; iGPSoriHorn < 3; ++iGPSoriHorn) {
      if(
          bsd->OtherData.TriggerTime[iGPSoriHorn] == fRawBeamData.GetTriggerTime(iGPSoriHorn) &&
          bsd->OtherData.TriggerTimeNanoSecond[iGPSoriHorn] == fRawBeamData.GetTriggerTimeNanoSecond(iGPSoriHorn) &&
          bsd->OtherData.HornCurrent[iGPSoriHorn] == fRawBeamData.GetHornCurrent(iGPSoriHorn) &&
          bsd->OtherData.HornBusBarCurrent[iGPSoriHorn][0] == fRawBeamData.GetHornBusBarCurrent(iGPSoriHorn,0) &&
          bsd->OtherData.HornBusBarCurrent[iGPSoriHorn][1] == fRawBeamData.GetHornBusBarCurrent(iGPSoriHorn,1) &&
          bsd->OtherData.HornBusBarCurrent[iGPSoriHorn][2] == fRawBeamData.GetHornBusBarCurrent(iGPSoriHorn,2) &&
          bsd->OtherData.HornBusBarCurrent[iGPSoriHorn][3] == fRawBeamData.GetHornBusBarCurrent(iGPSoriHorn,3) &&
          bsd->OtherData.HornBusBarCurrent[iGPSoriHorn][4] == fRawBeamData.GetHornBusBarCurrent(iGPSoriHorn,4)
        ) Flag_OtherData4 = true;
      else{
        Flag_OtherData4 = false;
        //std::cout<< "Flag4 error"<<std::endl;
        break;
      }
    }

    for(int ct = 0; ct < 5; ++ct) {
      if(
          bsd->OtherData.BeamTiming[ct] == fRawBeamData.GetBeamTiming(ct)&&
          bsd->OtherData.BeamFlag[ct] == fRawBeamData.GetBeamFlag(ct) &&
          bsd->OtherData.ProtonsPerSpill[ct] == fRawBeamData.GetProtonsPerSpill(ct)
        ) Flag_OtherData5 = true;
      else{
        Flag_OtherData5 = false;
        //std::cout<< "Flag5 error"<<std::endl;
        break;
      }

      for(int bunch_2 = 0; bunch_2 < 8; ++bunch_2) {
        if(
            bsd->OtherData.ProtonsPerBunch[ct][bunch_2] == fRawBeamData.GetProtonsPerBunch(ct,bunch_2)&&
            bsd->OtherData.BeamBunchTiming[ct][bunch_2] == fRawBeamData.GetBeamBunchTiming(ct,bunch_2)&&
            bsd->OtherData.BeamBunchFlag[ct][bunch_2] == fRawBeamData.GetBeamBunchFlag(ct,bunch_2)
          ) Flag_OtherData6 = true;
        else{
          Flag_OtherData6 = false;
          //std::cout<< "Flag6 error"<<std::endl;
          goto BREAK;
        }

      }

      for(int bunch_2 = 8; bunch_2 < 9; ++bunch_2) {
        if(
            bsd->OtherData.ProtonsPerBunch[ct][bunch_2] == fRawBeamData.GetProtonsPerBunch(ct,bunch_2)&&
            bsd->OtherData.BeamBunchTiming[ct][bunch_2] == fRawBeamData.GetBeamBunchTiming(ct,bunch_2)&&
            bsd->OtherData.BeamBunchFlag[ct][bunch_2] == fRawBeamData.GetBeamBunchFlag(ct,bunch_2)
          );
        else{
          std::cerr<< "Expected error was found. This problem in IBeamSummaryDataModule was fixed at 22th Sep."<<std::endl;
        }
      }

    }
BREAK:;
  }
  return Flag_MainData&&Flag_MainData2&&Flag_OtherData1&&Flag_OtherData2&&Flag_OtherData3&&Flag_OtherData4&&Flag_OtherData5&&Flag_OtherData6;
}

int main(int argc, char **argv) {
  bool health = true;
  char *filename = argv[1];

  // file name should be a text file containing one or several root files (one per line)

  // Load some important libraries.

  gROOT->SetBatch(1);

  gSystem->AddIncludePath("-I$OAANALYSISROOT/src");
  gSystem->AddIncludePath("-I."); 

  gSystem->Load("libPhysics");
  gSystem->Load("libGeom");
  gSystem->Load("libTree");
  gSystem->Load("libMatrix");
  gSystem->Load("liboaEvent.so");
  gSystem->Load("librecpack.so");
  gSystem->Load("liboaRecPack.so");
  gSystem->Load("liboaBeamData.so");
  gSystem->Load("liboaAnalysis.so");

  TChain BasicHeader("HeaderDir/BasicHeader");
  TChain BeamSummaryData("HeaderDir/BeamSummaryData");

  // _____________________________________________________________________________________
  // Load data files   
  //std::cout<< filename << std::endl;
  TString fileName(filename);
  ifstream inputFile(fileName.Data(), std::ios::in);
  if (!inputFile) {
    std::cerr << "Cannot open input file '" << fileName.Data() << "'. Exit!" << std::endl;
    std::cerr << "Usage: BSDChecker.exe <Root File>" << std::endl;
    return 1;
  }
  inputFile.close();

  /*
     std::string inputString;
     while (inputFile >> inputString) {
     std::cout << "Adding file: " << inputString << std::endl;
     BeamSummaryData.AddFile(inputString.c_str());
     }
     */
  BeamSummaryData.AddFile(filename);
  BasicHeader.AddFile(filename);
  //std::cout<< "file loaded" << std::endl;

  // _____________________________________________________________________________________
  // Prepare to read trees.

  Int_t EventID;
  Int_t RunID;
  UInt_t EventTime;
  BasicHeader.SetBranchAddress("EventID", &EventID);
  BasicHeader.SetBranchAddress("RunID", &RunID);
  BasicHeader.SetBranchAddress("EventTime", &EventTime);

  //Int_t SpillNumber;
  Int_t COMETSpill;
  Int_t BRunID;
  Int_t BEventID;
  Int_t BeamSummaryDataStatus;

  BeamSummaryData.SetBranchAddress("RunID",&BRunID);
  BeamSummaryData.SetBranchAddress("EventID",&BEventID);
  BeamSummaryData.SetBranchAddress("BeamSummaryDataStatus",&BeamSummaryDataStatus);
  BeamSummaryData.SetBranchAddress("COMETSpill", &COMETSpill);

  TClonesArray *TClonesBSD = new TClonesArray("COMET::IBeamSummaryDataModule::IBeamSummaryData");
  BeamSummaryData.SetBranchAddress("BeamSummaryData",&TClonesBSD);
  COMET::IBeamSummaryDataModule::IBeamSummaryData *bsd=(COMET::IBeamSummaryDataModule::IBeamSummaryData*)(*TClonesBSD)[0];

  BasicHeader.GetEntry(0);
  BeamSummaryData.GetEntry(0);
  int entries = BasicHeader.GetEntries();
  std::cout << "------------------------------------------------------" << std::endl;
  std::cout << ">>>> entries            : " << entries << std::endl;
  std::cout << ">>>> Starting RunID     : " << RunID << std::endl;
  std::cout << ">>>> Starting EventTime : " << EventTime << std::endl;
  std::cout << "------------------------------------------------------" << std::endl;
  // Loop over all events.  
  for(int i = 0; i < entries; i++){

    BasicHeader.GetEntry(i);
    BeamSummaryData.GetEntry(i);
    if (RunID != BRunID || EventID != BEventID)
    {
      std::cout << "Mismatching RunID, EventID between BasicHeader and BeamSummary Header." << std::endl;
      return -1;
    }

    if (BeamSummaryDataStatus==1&&(Int_t (bsd->GoodSpillFlag))==1)
    {
      std::cout  << "#Good_Spill_List# "
        << RunID << " "
        << "D" << " " 
        << EventID << " "
        << COMETSpill << " "
        << bsd->GPS1TriggerTime << " "
        << bsd->CT5ProtonsPerSpill << " "
        << bsd->GoodSpillFlag 
        << std::endl;
    }
    if (BeamSummaryDataStatus==1){
      if (DataCheck(COMETSpill, EventTime, bsd)==false){
        health = false;
        std::cout << "There is problem with beam data!" << std::endl;
      };
    };
  }///end loop entries
  if(health==true){
    std::cout<<"BSD Check was successfully finished. There is no problem with attached beam data."<<std::endl;
    return 0;
  }
  else{
    std::cout << "There is problem with beam data!" << std::endl;
    return -1;
  }
}