/** @file CbmTofFlibData.cxx
 ** @author Pierre-Alain Loizeau <loizeau@physi.uni-heidelberg.de>
 ** @date 05.05.2015
 **
 ** Code for Prototype class of TOF data unit
 **/
#include "CbmTofFlibData.h"

// It seems C++ standard force the initialization to be in cxx/cpp file (outside of class definition)
// When not trivial constant values => To check if it should apply also to simple values maybe?     

const double CbmTofFlibData::fgkdTimeBinSize =  10.0; // [ps] => 41 943.40 ns ( > GET4 epoch, > trigger window)
const double CbmTofFlibData::fgkdTotBinSize  =  50.0; // [ps] => 0-51.200 range

// -----   Bit fields sizes   --------------------------------------------------
const int      CbmTofFlibData::fgkiTimeSize = CbmTofFlibData::fgkiFineTimeSize + CbmTofFlibData::fgkiCoarseTimeSize;
// -----------------------------------------------------------------------------
// -----   Bit masks -----------------------------------------------------------
const uint64_t CbmTofFlibData::fgklAddrMask = (static_cast<uint64_t>(1) << CbmTofFlibData::fgkiAddressSize) - 1;
const uint64_t CbmTofFlibData::fgklTimeMask = (static_cast<uint64_t>(1) << CbmTofFlibData::fgkiTimeSize)    - 1;
const uint64_t CbmTofFlibData::fgklFineTimeMask   = (static_cast<uint64_t>(1) << CbmTofFlibData::fgkiFineTimeSize)   - 1;
const uint64_t CbmTofFlibData::fgklCoarseTimeMask = (static_cast<uint64_t>(1) << CbmTofFlibData::fgkiCoarseTimeSize) - 1;
const uint64_t CbmTofFlibData::fgklTotMask  = (static_cast<uint64_t>(1) << CbmTofFlibData::fgkiTotSize)     - 1;
// -----------------------------------------------------------------------------

// -----   Bit shifts   --------------------------------------------------------
const int    CbmTofFlibData::fgkiAddressOffs    =   0;
const int    CbmTofFlibData::fgkiTimeOffs       = CbmTofFlibData::fgkiAddressOffs  + CbmTofFlibData::fgkiAddressSize;
const int    CbmTofFlibData::fgkiFineTimeOffs   = CbmTofFlibData::fgkiTimeOffs;
const int    CbmTofFlibData::fgkiCoarseTimeOffs = CbmTofFlibData::fgkiFineTimeOffs + CbmTofFlibData::fgkiFineTimeSize;
const int    CbmTofFlibData::fgkiTotOffs        = CbmTofFlibData::fgkiTimeOffs     + CbmTofFlibData::fgkiTimeSize;
// -----------------------------------------------------------------------------

CbmTofFlibData::CbmTofFlibData()
  : flData(0)
{
}

CbmTofFlibData::CbmTofFlibData(
      unsigned address,
      double time,
      double tot)
  : flData(0)
{
   SetAddress( address );
   SetTime( time);
   SetTot(  tot);
}

CbmTofFlibData::CbmTofFlibData(
      unsigned address,
      int time,
      int tot)
  : flData(0)
{
   SetAddress( address );
   SetTime( time);
   SetTot(  tot);
}

CbmTofFlibData::CbmTofFlibData(
      unsigned address,
      int coarsetime,
      int finetime,
      int tot)
  : flData(0)
{
   SetAddress( address );
   SetCoarseTime( coarsetime);
   SetFineTime(   finetime);
   SetTot(  tot);
}

CbmTofFlibData::CbmTofFlibData(const CbmTofFlibData& digiIn)
  : flData(digiIn.flData)
{
  //   flData = digiIn.GetData(); ///< Fully compressed data
}

CbmTofFlibData::~CbmTofFlibData()
{
}

void CbmTofFlibData::SetAddress( unsigned address)
{ 
   // First set old address to zero
   flData = flData & ~(fgklAddrMask << fgkiAddressOffs);

   // Now set new address
   flData = flData | ( (address & fgklAddrMask) << fgkiAddressOffs );
};
void CbmTofFlibData::SetTime(double time)
{ 
   int iBinnedTime = static_cast<int>( time / fgkdTimeBinSize );
   // First set old time to zero
   flData = flData & ~(fgklTimeMask << fgkiTimeOffs);

   // Now set new time
   flData = flData | ( (iBinnedTime & fgklTimeMask) << fgkiTimeOffs );
};
void CbmTofFlibData::SetTime(int time)
{
   // First set old time to zero
   flData = flData & ~(fgklTimeMask << fgkiTimeOffs);

   // Now set new time
   flData = flData | ( (time & fgklTimeMask) << fgkiTimeOffs );
};
void CbmTofFlibData::SetCoarseTime(int coarsetime)
{
   // First set old coarse time to zero
   flData = flData & ~(fgklCoarseTimeMask << fgkiCoarseTimeOffs);

   // Now set new coarse time
   flData = flData | ( (coarsetime & fgklCoarseTimeMask) << fgkiCoarseTimeOffs );
};
void CbmTofFlibData::SetFineTime(int finetime)
{
   // First set old fine time to zero
   flData = flData & ~(fgklFineTimeMask << fgkiFineTimeOffs);

   // Now set new fine time
   flData = flData | ( (finetime & fgklFineTimeMask) << fgkiFineTimeOffs );
};
void CbmTofFlibData::SetTot(double tot)
{ 
   int iBinnedTot = static_cast<int>( tot / fgkdTotBinSize );
   
   // First set old tot to zero
   flData = flData & ~(fgklTotMask << fgkiTotOffs);

   // Now set new tot
   flData = flData | ( (iBinnedTot & fgklTotMask) << fgkiTotOffs );
};
void CbmTofFlibData::SetTot(int tot)
{
   // First set old tot to zero
   flData = flData & ~(fgklTotMask << fgkiTotOffs);

   // Now set new tot
   flData = flData | ( (tot & fgklTotMask) << fgkiTotOffs );
};

bool  CbmTofFlibData::operator <( const CbmTofFlibData& rhs) const
{
   return (this->GetTime() < rhs.GetTime()) ? true : false;
} 
int	  CbmTofFlibData::Compare(      const CbmTofFlibData*  obj) const
{
   if( this->GetTime() < obj->GetTime() )
      // hit ... obj
      return -1;
   else if( this->GetTime() > obj->GetTime() )
      // obj ... hit
      return 1;
   // obj = hit
   else return 0;
}