#include "ITripTRawDataTree.hxx"

// COMET headers
//#include "IRunInfoInterface.hxx"
#include "IMidasFile.hxx"
#include "IMidasBank.hxx"
#include "ITripTDigitBank.hxx"
#include "ITripTInfoBank.hxx"
#include "IXmlBank.hxx"
#include "IMidasTripTDigitItr.hxx"
#include "IMidasTripTDigit.hxx"
#include "ICOMETRawEvent.hxx"
#include "IMCMBank.hxx"
//#include "ITimeFitter.hxx"
#include "IRawDataHeader.hxx"
#include "ITFBChannelId.hxx"
#include "ITriggerBank.hxx"
#include "COMETTriggerWord.hxx"

// C headers
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <sstream>
#include <string>
#include <cstdio>

// ROOT headers
#include "TFile.h"
#include "TTree.h"

void IDataTree::ProcessEvents(){

  InitialiseFilesAndTrees();
  
  fnFile = 0;
  
  for(std::vector<std::string>::const_iterator f = fFiles->begin(); f != fFiles->end(); ++f){
    fnEvent = 0;
    ++fnFile;
    fInputFile->Open(f->c_str());
    // Loop over all input events
    std::cout<<"Processing file "<<fnFile<<": "<<f->c_str()<<std::endl;
    while((fRawEvent = fInputFile->ReadRawEvent())){
      ++fnEvent;
      ReadEvents();
      fUnixTime = HeaderTime();
      delete fRawEvent;
    }
    
    fInputFile->Close();
  }
  
  fOffsetTree->Write();
  fRootFile->Close();

  delete fOffsetTree;
  delete fRootFile;
  
  return;
}

bool IDataTree::ParseArgs(int argc, char* argv[]){

  InitialiseVariables();

  // Process the options.
  for (;;) {
    int c = getopt(argc, argv, "o:");
    if (c<0) break;
    switch (c) {
    case 'o':
      fOutputRootFile = optarg;
      break;
    }
  } // Closes process options for loop
  
  // Test for further command line arguments after options
  if (argc<=optind) {
    std::cout << "ERROR: No input file(s)" << std::endl << std::endl;
    return false;
  }

  for(int i=optind; i<argc; i++){
    char* f = argv[i];
    std::ifstream ifstr(f);
    if(ifstr.good()) {
      fFiles->push_back(f);
      ifstr.close();
    }
    else {
      std::cout << "ERROR: File " << f << " does not exist, aborting" << std::endl;
      return false;
    }
  }

  // If the files exist, but no output file name has been specified, use the name of the first file to produce one
  if(!fOutputRootFile.size()){
    std::vector<std::string>::const_iterator f = fFiles->begin();
    fOutputRootFile = "timesliptree_" + *f;
    size_t found;
    std::string key = "daq.mid.gz";
    found = fOutputRootFile.rfind(key);
    if(found!=std::string::npos){
      fOutputRootFile.replace(found, key.length(), "root");
    }
    else{
      fOutputRootFile += ".root";
    }
  }
  
  fNumberFiles = argc - optind;
  std::cout<<"Number of files "<<fNumberFiles<<std::endl;

  return true;
}

void IDataTree::InitialiseVariables(){

  fFiles = new std::vector<std::string>;
  fInputFile = new COMET::IMidasFile;
  fRawEvent = new COMET::ICOMETRawEvent;

  return;
}

UInt_t IDataTree::HeaderTime(){

  //Get the unix time of the event
  COMET::IRawDataHeader header = fRawEvent->GetHeader();

  return header.GetTimeStamp();
}

void IDataTree::ReadEvents(){

  COMET::IHandle<COMET::IMCMBank> mcmBank;
  mcmBank = fRawEvent->GetMidasBank<COMET::IMCMBank>("OMCM",mcmBank);
  if(!mcmBank){
    std::cout<<"no mcm bank for event"<<std::endl;
    return;
  }

  ULong64_t triggerWord = mcmBank->GetTriggerWord();
  const ULong64_t ti_MASK(0xFFFF000000000000ULL);
  const Int_t ti_SHIFT(48);
  Int_t trigField = (triggerWord & ti_MASK) >> ti_SHIFT;
  
  const Int_t trigger_MASK(0x3FF);
  const Int_t trigger_SHIFT(0);
  
  Int_t tBits = (trigField & trigger_MASK) >> trigger_SHIFT;
  if(tBits!=128 && tBits!=1){ //Trigger type 128 is trip-t cosmics
      return;
  }

  // Get trigger primitives information from triger bank
  const ULong64_t maskUpper = 0xFFFFFFFF00000000ULL;
  const ULong64_t maskLower = 0x00000000FFFFFFFFULL;

  // SMRD
  fprmtv_top = 0;
  fprmtv_bottom = 0;
  fprmtv_south = 0;
  fprmtv_north = 0;
  // POD
  fprmtv_p0d = 0;
  // DsECAL
  fprmtv_dsecal = 0;

  COMET::IHandle<COMET::ITriggerBank> trgBank;
  if(trgBank = fRawEvent->GetMidasBank<COMET::ITriggerBank>("OTRI") ){
    fprmtv_top    = (trgBank->GetTriggerPatternLow()  & maskLower);
    fprmtv_south  = (trgBank->GetTriggerPatternLow()  & maskUpper)>>32;
    fprmtv_bottom = (trgBank->GetTriggerPatternMid()  & maskLower);
    fprmtv_north  = (trgBank->GetTriggerPatternMid()  & maskUpper)>>32;
    fprmtv_p0d    = (trgBank->GetTriggerPatternHigh() & maskLower);
    fprmtv_dsecal = (trgBank->GetTriggerPatternHigh() & maskUpper)>>32;
  }

  Long64_t trigSubSec = mcmBank->GetUnixTimeSSecTrig();
  int mcmTick = 4;
  
  // Loop over the tripT banks in the event
  COMET::IHandle<COMET::ITripTDigitBank> triptBank;
  while(triptBank = fRawEvent->GetMidasBank<COMET::ITripTDigitBank>("",triptBank)){
    
    const Char_t *name = triptBank->GetName();
    // RMM is third digit in the bank name, 0123456789ABCDEFG... 
    Int_t detector = (name[0]=='P') ? 0 :      // P0D
                     (name[0]=='I') ? 1 :      // INGRID
                     (name[0]=='E') ? 2 :      // ECAL
                     (name[0]=='S') ? 3 : 4;   // SMRD : 4=Unknown
    
    // Reject hits from INGRID and Unknown detectors.
    if (detector == 1 || detector == 4) continue;
  
    // Iterate over the digits
    COMET::IMidasTripTDigitItr itr(triptBank->GetMidasTripTDigitItr());     
    while(!itr.EOD()){
      COMET::IMidasTripTDigit digit(itr.Get());
      int RMMIndex = digit.GetRMMNum();
      
      COMET::ITFBChannelId channelID = digit.GetChannelId();
      Int_t subDet = channelID.GetSubDetector();

      // Noise cut, currently rejecting hits below 900 loADC counts.
      // Cut can easily be loosed to accept more data into tree, cuts can 
      // be then placed against ADC count stored in tree if required.
      UShort_t highadc = digit.GetHighGainADC();
      UShort_t adcCutLow = 900;
      
      if( (highadc > adcCutLow) && (tBits == 128) );
      else continue;
      
      // Set values for each to be written to the flat tree.
      fsubDet = subDet;
      fDetector = detector;
      Long64_t time = digit.GetTime();
      fTimeRelTrig = time%400000000 - trigSubSec*mcmTick;
      fRMM = RMMIndex;
      fTFB = digit.GetTFBNum();
      fTripT = digit.GetTripTNum();
      fLowADC = digit.GetLowGainADC();
      fHighADC = digit.GetHighGainADC();
      
      fOffsetTree->Fill();

    } // if ECAL
  } // while(!itr.EOD())
  
  return;
}

void IDataTree::InitialiseFilesAndTrees(){
  
  fRootFile = new TFile(fOutputRootFile.c_str(),"RECREATE","Tree containing offset information.");

  fOffsetTree = new TTree("fOffsetTree", "");
  fOffsetTree->SetDirectory(0);

  fOffsetTree->Branch("SubDet",         &fsubDet,         "fsubDet/I");
  fOffsetTree->Branch("Detector",       &fDetector,       "fDetector/I");
  fOffsetTree->Branch("nFile",          &fnFile,          "fnFile/I");
  fOffsetTree->Branch("nEvent",         &fnEvent,         "fnEvent/I");
  fOffsetTree->Branch("RMM",            &fRMM,            "fRMM/I");
  fOffsetTree->Branch("TFB",            &fTFB,            "fTFB/I");
  fOffsetTree->Branch("TripT",          &fTripT,          "fTripT/I");
  fOffsetTree->Branch("UnixTime",       &fUnixTime,       "fUnixTime/i");
  fOffsetTree->Branch("TimeRelTrig",    &fTimeRelTrig,    "fTimeRelTrig/L");
  fOffsetTree->Branch("HighADC",        &fHighADC,        "fHighADC/s");
  fOffsetTree->Branch("LowADC",         &fLowADC,         "fLowADC/s");
  fOffsetTree->Branch("prmtv_top",      &fprmtv_top,      "fprmtv_top/i");
  fOffsetTree->Branch("prmtv_bottom",   &fprmtv_bottom,   "fprmtv_bottom/i");
  fOffsetTree->Branch("prmtv_south",    &fprmtv_south,    "fprmtv_south/i");
  fOffsetTree->Branch("prmtv_north",    &fprmtv_north,    "fprmtv_north/i");
  fOffsetTree->Branch("prmtv_p0d",      &fprmtv_p0d,      "fprmtv_p0d/i");
  fOffsetTree->Branch("prmtv_dsecal",   &fprmtv_dsecal,   "fprmtv_dsecal/i");

  return;
}

void IDataTree::Usage(){

  std::cout<<"**************************************** USAGE ****************************************"<<std::endl;
  
  std::cout<<"genTimeSlipFinder.exe reads in one or more comet raw data files.\n"<<std::endl;

  std::cout<<"From the raw data file(s) a simple flat tree of hits in the TripT"<<std::endl;
  std::cout<<"subdetectors is produced for use in locating RMM timeslips.\n"<<std::endl;

  std::cout<<"genTimeSlipFinder.exe accepts the command line option '-o' to"<<std::endl;
  std::cout<<"specify the output file name, e.g...\n"<<std::endl;

  std::cout<<"genTimeSlipFinder.exe -o timesliptree_00001234_0000.root comet_00001234_0000.daq.mid.gz"<<std::endl;

  std::cout<<"***************************************************************************************"<<std::endl;

  return;
}


IDataTree::~IDataTree(){

  delete fFiles;
  delete fInputFile;
  delete fRawEvent;
 
  return;
}