/******************************************************************************
 * PESQ class function definition file                                        *
 *                                                                            *
 * Author: Benn Tannenbaum                                                    *
 * see header file for more information                                       *
 *****************************************************************************/

//-----------------------
// This Class's Header --
//-----------------------
#include "CalorObjects/PESQ.hh"

//-----------------
// Other Headers --
//-----------------
#include <vector>
using std::vector;

#include "TBuffer.h"
#include "Edm/EventRecord.hh"
#include "ErrorLogger_i/gERRLOG.hh"

// SET THE VERSION NUMBER :
const Version_t PESQ::_VERSION = 2;
Version_t PESQ::_READ_VERSION = -1;

//*****************************************************************************
// Class Implementation
//*****************************************************************************

/**************************************************************************
 * PESQ Default Constructor                                               *
 **************************************************************************/
PESQ::PESQ(): 
  _address(0),
  _nstrips(0)
{}

/**************************************************************************
 * PESQ Copy Constructor                                                  *
 **************************************************************************/
PESQ::PESQ( const PESQ& oldPESQ ) {
  _address   = oldPESQ._address;
  _nstrips   = oldPESQ._nstrips;
  _energies  = oldPESQ._energies;
}


/**************************************************************************
 * PESQ Custom Constructor                                                *
 **************************************************************************/
PESQ::PESQ(int address, int nstrips, vector<unsigned short> energies) {
  _address = address;
  _nstrips = nstrips;
  _energies = energies;
}

/*===========================================================================*\
 * Principal Assignment Operator Overload                                    *
\*===========================================================================*/
PESQ& PESQ::operator = (const PESQ & rhs) {
  if (this != &rhs) {                 // beware of self-assignment
    _address   = rhs._address;
    _nstrips   = rhs._nstrips;
    _energies  = rhs._energies;
  }
  return *this;
}

/*===========================================================================*\
 * Operator overloads                                                        *
\*===========================================================================*/
inline bool PESQ::operator == (const PESQ& rhs) const  {
  return ( this->_address == rhs._address  &&
	   this->_energies == rhs._energies  );
}

inline bool PESQ::operator != (const PESQ& rhs) const {
  return (!(*this == rhs));
}

void PESQ::print(std::ostream& os) const {
  os << "Endplug: " << (this->Plug()==0 ? "West" : "East")
     << " Octant: " << this->Octant()
     << " Layer: "  << this->Layer()
     << " Strip: "  << this->FirstStrip()
     << ", # of strips: " << this->NStrips() << std::endl;
  os << "\t" << "Energies:";
  for (int i = 0 ; i < this->_nstrips ; i++)
    os << " " << this->_energies[i];
  os << std::endl;
}

std::ostream& operator<<(std::ostream& os, const PESQ& thePesq) {
  thePesq.print(os);
  return os;
}

PESQ::~PESQ() {}

//===========================================================================
// Required by StreamableObject
//===========================================================================
void PESQ::Streamer(TBuffer& iobuffer) {
  
  //---------------------------------------------------------------------------
  // Read object from buffer
  //---------------------------------------------------------------------------
  if (iobuffer.IsReading()) {
    // PESQ_Coll has to set the _READ_VERSION of PESQ, since the version
    // information is not streamed out for each and every PESQ. This means
    // that there must be a unique version for PESQ_Coll for each version
    // of PESQ. If you make a new version of PESQ, make a new version of
    // PESQ_Coll as well, and update PESQ_Coll::Streamer!
    Version_t version = _READ_VERSION;
    if (version == 1) {
      // Version 1 has two unsigned shorts per strip: an address and an energy.
      // The address is arranged in a slightly different order than the
      // address used in the current version.
      iobuffer >> version;
      unsigned short oldAddress;
      iobuffer >> oldAddress;
      _address = ((oldAddress & 1) << 12) + (((oldAddress >> 4) & 1) << 11)
	+ (((oldAddress >> 1) & 7) << 8) + ((oldAddress >> 5) & 255);
      _nstrips = 1;
      unsigned short energy;
      iobuffer >> energy;
      _energies.push_back(energy);
    } else if (version == 2) {
      // Version 2 has a starting address, a number of contiguous strips,
      // and a list of energies for those strips.
      iobuffer >> _address >> _nstrips;
      unsigned short energy;
      for (int i = 0 ; i < _nstrips ; i++) {
	iobuffer >> energy;
	_energies.push_back(energy);
      }
    } else {
      ERRLOG( ELerror, "Unsupported PESQ version" )
	<< "@SUB=PESQ::Streamer(<isReading>)"
	<< "PESQ cannot be read"
	<< endmsg;
    }
  }
  
  //---------------------------------------------------------------------------
  // Write object to buffer
  //---------------------------------------------------------------------------
  else if (iobuffer.IsWriting()) {
    iobuffer << _address << _nstrips;
    for (int i = 0 ; i < _nstrips ; i++) iobuffer << _energies[i];
  }
  
  //---------------------------------------------------------------------------
  // Unanticipated action
  //---------------------------------------------------------------------------
  else { 
    ERRLOG( ELerror, "PESQ::Streamer(<unknown state>)")
      << "@SUB=PESQ::Streamer"
      << "NOTHING DONE." 
      << endmsg;
  } 
}

bool PESQ::postread(EventRecord* p) {return true;}

bool PESQ::prewrite(EventRecord* p) {return true;}