#include "IBeamSummaryDataModule.hxx"

#include <TFile.h>
#include <TSystem.h>
#include <IBeamDataSingleton.hxx>

ClassImp(COMET::IBeamSummaryDataModule);
ClassImp(COMET::IBeamSummaryDataModule::IBeamSummaryData);
ClassImp(COMET::IBeamSummaryDataModule::IBeamSummaryData::IOtherData);

#define CVSTAG "\
  $Name: v5r19 $"
#define CVSID  "\
  $Id: IBeamSummaryDataModule.cxx,v 1.9 2012/07/17 11:58:26 finch Exp $"

COMET::IBeamSummaryDataModule::IBeamSummaryDataModule(const char *name,
    const char *title) {
  SetNameTitle(name, title);
  // Enable this module by default:
  fIsEnabled = kTRUE;
  fDescription = "Module incorporating Beam Summary Data as provided by the beamline group";
  fCVSTagName = CVSTAG;
  fCVSID = CVSID;
  fBeamSummaryData = new TClonesArray("COMET::IBeamSummaryDataModule::IBeamSummaryData", 200);
}


COMET::IBeamSummaryDataModule::~IBeamSummaryDataModule() {
}

void COMET::IBeamSummaryDataModule::InitializeModule() {
  /* error code should be implemented.
     throw COMET::ENoBeamSummaryData();
     */
}

void COMET::IBeamSummaryDataModule::InitializeBranches() {
  //HEADER INFO
  fOutputTree->Branch("BeamSummaryDataStatus", &fBeamSummaryDataStatus, "BeamSummaryDataStatus/I", fBufferSize);
  fOutputTree->Branch("COMETSpill", &fCOMETSpill, "COMETSpill/I", fBufferSize);
  fOutputTree->Branch("BeamSummaryData", &fBeamSummaryData, fBufferSize, fSplitLevel);
  fOutputTree->GetBranch("BeamSummaryDataStatus")->SetTitle
  ("  Flag : Beam Summary Data is available or not in the spill. 1 = BSD is available. 0 is not.");
  fOutputTree->GetBranch("COMETSpill")->SetTitle
  ("  COMET Spill Number. 16 bit.");
}

// finding spill and filling information //
bool COMET::IBeamSummaryDataModule::FillTree(COMET::ICOMETEvent& event) {

        fRawBeamData = COMET::IBeamDataSingleton::Get();

  fBeamSummaryDataStatus = 0;
  fBeamSummaryData->Clear();

  Int_t spill = event.GetHeader().GetSpillNumber();
  fCOMETSpill = spill;
  Int_t mcmTime = event.GetHeader().GetMCMSecond();
  Int_t trigger = event.GetHeader().GetTriggerBits();

        // Unused variable so commenting out to remove compiler warnings
  //Int_t bsdTime;

  if(trigger != 1) {
    return true;
  }

  bool ret = fRawBeamData.GetSpill(spill, mcmTime, 1);

  if (ret == true&&(mcmTime - fRawBeamData.GetTriggerTime(0))>=0) {

    fBeamSummaryDataStatus = 1;
    IBeamSummaryData *bsd = new((*fBeamSummaryData)[0]) IBeamSummaryData;

    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();

    // We have to think about numbering spills. //
    for(int bunch_1 = 0; bunch_1 < 8; ++bunch_1) {
      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);
    }

    bsd->OtherData.SpillNumber = fRawBeamData.GetSpillNumber();
    bsd->OtherData.MRRunNumber = fRawBeamData.GetMRRunNumber();
    bsd->OtherData.BeamRunNumber = fRawBeamData.GetBeamRunNumber();
    //bsd->OtherData.MRShotNumber = fRawBeamData.GetMRShotNumber();

    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();
    //bsd->OtherData.MidasEvent = fRawBeamData.GetMidasEvent();

    for(int iGPS = 0; iGPS < 3; ++iGPS) {
      bsd->OtherData.TriggerTime[iGPS] = fRawBeamData.GetTriggerTime(iGPS);
      bsd->OtherData.TriggerTimeNanoSecond[iGPS] = fRawBeamData.GetTriggerTimeNanoSecond(iGPS);
    }
    bsd->OtherData.GPSStatus[0] = fRawBeamData.GetGPSStatus(0);
    bsd->OtherData.GPSStatus[1] = fRawBeamData.GetGPSStatus(1);

    for(int ct = 0; ct < 5; ++ct) {
      bsd->OtherData.BeamTiming[ct] = fRawBeamData.GetBeamTiming(ct);
      bsd->OtherData.BeamFlag[ct] = fRawBeamData.GetBeamFlag(ct);
      bsd->OtherData.ProtonsPerSpill[ct] = fRawBeamData.GetProtonsPerSpill(ct);

      for(int bunch_2 = 0; bunch_2 < 9; ++bunch_2) {
        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);
      }
    }


    for(int ihorn = 0; ihorn < 3; ++ihorn) {
      bsd->OtherData.HornCurrent[ihorn] = fRawBeamData.GetHornCurrent(ihorn);

      for(int ch = 0; ch < 5; ++ch) {
        bsd->OtherData.HornBusBarCurrent[ihorn][ch] = fRawBeamData.GetHornBusBarCurrent(ihorn,ch);
      }

    }
    for(int dir = 0; dir < 2; ++dir) {
      bsd->OtherData.BeamDirectionOnTarget[dir] = fRawBeamData.GetBeamDirectionOnTarget(dir);
      bsd->OtherData.BeamSizeOnTarget[dir] = fRawBeamData.GetBeamSizeOnTarget(dir);
    }


    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() ;


    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() ;
  }

  if(fBeamSummaryDataStatus == 0) fBeamSummaryDataStatus = -1;
  return true;
}


Bool_t COMET::IBeamSummaryDataModule::ProcessFirstEvent(COMET::ICOMETEvent&) {
  return true;
}

Bool_t COMET::IBeamSummaryDataModule::Configure(std::string& option) {
  SetEnabled(kFALSE);
  /*
     std::string filenameOrDirectory = option;

     void* dirp = gSystem->OpenDirectory(filenameOrDirectory.c_str());

     if(dirp) {
     const char* fname = 0;
     while((fname = gSystem->GetDirEntry(dirp))) {
     std::string filePath = Form("%s/%s", filenameOrDirectory.c_str(), fname);
     TFile *f = new TFile(filePath.c_str());
     if(f && !f->IsZombie() && f->Get("bsd")) {
     fBSDTree->Add(filePath.c_str());
     }
     delete f;
     }
     }
     else {
     TFile *f = new TFile(filenameOrDirectory.c_str());
     if(f && !f->IsZombie() && f->Get("bsd")) {
     fBSDTree->Add(filenameOrDirectory.c_str());;
     }
     delete f;
     }
     */
  return true;

}

COMET::IBeamSummaryDataModule::IBeamSummaryData::~IBeamSummaryData() {}
COMET::IBeamSummaryDataModule::IBeamSummaryData::IOtherData::~IOtherData() {}