/*
 * CbmTimeSlice.cxx
 *
 *  Created on: 17.07.2012
 *      Author: friese
 */

#include <iomanip>
#include <sstream>

#include "CbmTimeSlice.h"

#include "FairLogger.h"
#include "CbmModuleList.h"

using std::stringstream;
using std::fixed;
using std::string;
using std::setprecision;


// -----   Constructor for flexible time-slice   ----------------------------
CbmTimeSlice::CbmTimeSlice(EType type)
 : TNamed(),
   fType(type),
   fStartTime(-1.),
   fLength(-1.),
   fIsEmpty(kTRUE),
   fNofData(),
   fTimeDataFirst(0.),
   fTimeDataLast(0.),
   fMatch()
{
}
// ---------------------------------------------------------------------------



// -----   Constructor for fixed-length time-slice   -------------------------
CbmTimeSlice::CbmTimeSlice(Double_t start, Double_t duration)
 : TNamed(),
   fType(kRegular),
   fStartTime(start), 
   fLength(duration),
   fIsEmpty(kTRUE),
   fNofData(),
   fTimeDataFirst(0.),
   fTimeDataLast(0.),
   fMatch()
{
}
// ---------------------------------------------------------------------------



// -----   Destructor   ------------------------------------------------------
CbmTimeSlice::~CbmTimeSlice() {
}
// ---------------------------------------------------------------------------



// -----   Add data with time stamp   ----------------------------------------
Bool_t CbmTimeSlice::AddData(Int_t detector, Double_t time) {

  // Check for out of bounds
  if ( fType == kRegular ) {
    if ( time < fStartTime || time > GetEndTime() )  {
      LOG(error) << "Trying to add data at t = " << time << " ns to "
                 << "time slice [ " << fStartTime << ", " << GetEndTime()
                 << " ] ns !";
      return kFALSE;
    } //? out of bounds
  } //? fixed-length

  // Update bookkeeping
  if ( fIsEmpty ) {
    fTimeDataFirst = time;
    fTimeDataLast = time;
  } //? time-slice empty
  else {
    if ( time < fTimeDataFirst ) fTimeDataFirst = time;
    if ( time > fTimeDataLast ) fTimeDataLast = time;
  } //? time-slice not empty

  fNofData[detector]++;
  fIsEmpty = kFALSE;

  return kTRUE;
}
// ---------------------------------------------------------------------------



// -----   End time of time slice   ------------------------------------------
Double_t CbmTimeSlice::GetEndTime() const {
  Double_t value = -1.;
  switch ( fType ) {
    case kRegular:  value = fStartTime + fLength; break;
    case kFlexible: value = -1.; break;
    case kEvent:    value = fStartTime; break;
    default:        value = -1.; break;
  }
  return value;
}
// ---------------------------------------------------------------------------



// -----   Get data array size   ---------------------------------------------
Int_t CbmTimeSlice::GetNofData(Int_t detector) const {
  auto it = fNofData.find(detector);
  if ( it == fNofData.end() ) return 0;
  return it->second;
}
// ---------------------------------------------------------------------------



// -----   Register data   ---------------------------------------------------
Bool_t CbmTimeSlice::RegisterData(Int_t system, Double_t time) {

  // Check for out of bounds
  if ( fType == kRegular ) {
    if ( time < fStartTime || time > GetEndTime() )  {
      LOG(error) << "Trying to add data at t = " << time << " ns to "
                 << "time slice [ " << fStartTime << ", " << GetEndTime()
                 << " ] ns !";
      return kFALSE;
    } //? out of bounds
  } //? fixed-length

  // Update bookkeeping
  if ( fIsEmpty ) {
    fTimeDataFirst = time;
    fTimeDataLast = time;
  } //? time-slice empty
  else {
    if ( time < fTimeDataFirst ) fTimeDataFirst = time;
    if ( time > fTimeDataLast ) fTimeDataLast = time;
  } //? time-slice not empty
  fNofData[system]++;
  fIsEmpty = kFALSE;

  return kTRUE;
}
// ---------------------------------------------------------------------------



// -----   Register data   ---------------------------------------------------
Bool_t CbmTimeSlice::RegisterData(Int_t system, Double_t time,
                                  const CbmMatch& match) {

  // Update match object
  CbmLink link;
  for (Int_t iLink = 0; iLink < match.GetNofLinks(); iLink++) {
    Int_t input = match.GetLink(iLink).GetFile();
    Int_t event = match.GetLink(iLink).GetEntry();
    Double_t weight = match.GetLink(iLink).GetWeight();
    fMatch.AddLink(weight, -1, event, input);
  }

  return RegisterData(system, time);
}
// ---------------------------------------------------------------------------



// ----- Reset time slice   --------------------------------------------------
void CbmTimeSlice::Reset() {
  assert ( fType != kRegular );
  ResetCounters();
  fMatch.ClearLinks();
}
// ---------------------------------------------------------------------------



// ----- Reset time slice   --------------------------------------------------
void CbmTimeSlice::Reset(Double_t start, Double_t length) {
  fStartTime = start;
  fLength = length;
  ResetCounters();
  fMatch.ClearLinks();
}
// ---------------------------------------------------------------------------



// ----- Reset time slice bookkeeping   --------------------------------------
void CbmTimeSlice::ResetCounters() {
  fNofData.clear();
  fIsEmpty = kTRUE;
  fTimeDataFirst = 0.;
  fTimeDataLast = 0.;
  fMatch.ClearLinks();
}
// ---------------------------------------------------------------------------



// -----   Status info   -----------------------------------------------------
string CbmTimeSlice::ToString() const {
  stringstream ss;
  ss << "Time slice [";
  switch (fType) {
    case kRegular: ss << fixed << setprecision(0) << fStartTime
        << ", " << GetEndTime() << "] ns, data: "; break;
    case kFlexible: ss << "flexible], data: "; break;
    case kEvent: ss << "event], data: "; break;
    default: ss << "], data: "; break;
  }
  if ( IsEmpty() ) ss << "empty";
  else {
    ss << "[" << fixed << setprecision(3) << fTimeDataFirst
        << ", " << fTimeDataLast << "] ns, ";
    for ( auto it = fNofData.begin(); it != fNofData.end(); it++) {
      if ( it->second ) ss << CbmModuleList::GetModuleNameCaps(it->first)
    << " " << it->second << " ";
    } //# detectors
    ss << ", MC events " << fMatch.GetNofLinks();
  } //? time-slice not empty
  return ss.str();
}
// ---------------------------------------------------------------------------


ClassImp(CbmTimeSlice)