//-----------------------
// This Class's Header --
//-----------------------
#include "CalorObjects/CESQColl.hh"
#include "AbsEnv/AbsEnv.hh"
#include "Experiment/Experiment.hh"

//---------------
// C++ Headers --
//---------------
#include <iostream>
#include "ErrorLogger_i/gERRLOG.hh"


// ROOT Headers :
#include "TBuffer.h"
#include "EdmUtilities/CdfClassImp.hh"


/**************************************************************************
 * CESQColl Default Constructor                                               *
 **************************************************************************/
CESQColl::CESQColl( void ) : _bufferSize(0), _chid(NULL), _energy(NULL) { }


/**************************************************************************
 * CESQColl Destructor
 **************************************************************************/

CESQColl::~CESQColl( void ) {
  if (_bufferSize > 0){
    delete[] _chid;
    delete[] _energy;
  }
}

int CESQColl::numberChannels() const { return int(_bufferSize);}
const uint2 *CESQColl::energy() const { return _energy;}
const uint2 *CESQColl::channelID() const { return _chid;}



//------------------------------------------------------------------------------// Inherited virtuals...
//------------------------------------------------------------------------------
std::string CESQColl::class_name(void) const      { return ("CESQColl"); }
Version_t   CESQColl::class_version(void) const   { return CESQColl::Class_Version(); }



/**************************************************************************
 * CESQColl Fill method
 **************************************************************************/

void CESQColl::Fill(uint2 bufferSize, const uint2* chid, const uint2* energy){
  _bufferSize = bufferSize;
  _chid       = new uint2[_bufferSize];
  _energy     = new uint2[_bufferSize];

  for (int i=0; i<bufferSize; i++){
    _chid[i]    = chid[i];
    _energy[i]  = energy[i];
  }
}


void CESQColl::destroy(void)  
{ 
  CESQColl::deallocate() ;
  delete this;
}

void CESQColl::deallocate(void)
{ 
  StorableObject::deallocate() ;
}


bool CESQColl::postread(EventRecord* p_record)   { return true; }
                                             
bool CESQColl::prewrite(EventRecord* p_record)   { return true; }
                                             
bool CESQColl::activate(EventRecord* p_record)   { return true; }
                                             
bool CESQColl::deactivate(EventRecord* p_record) { return true; }



/**************************************************************************
 * CESQColl::print                                                            *
 *      Print information for strips                                      *
 **************************************************************************/
void CESQColl::print(std::ostream& os) const
{
  
  os << "**************************************************"<< "\n" ;
  os << "Number of strips and wires " << _bufferSize << "\n" ;
  
  if (_bufferSize>0){


    for (int i=0; i<_bufferSize; i++){
      
      int module     = this->module(_chid[i]);
      int type       = this->stripType(_chid[i]);
      int side       = this->i_ew(_chid[i]);
      int stripnr    = this->stripNo(_chid[i]);
      
      if (type == 0){
	os << "Strip : " ;
	os << "Energy " << _energy[i] ;
	os << " channel ID " << _chid[i] ;
	os << "  module " << module ;
	os << "  side " << side ;
	os << " strip Number " << stripnr << "\n";
      } else {
	os << "Wire : " ;
	os << "Energy " << _energy[i] ;
	os << " channel ID " << _chid[i] ;
	os << "  module " << module ;
	os << "  side " << side ;
	os << " wire Number " << stripnr << "\n";      
      }
    }
  }
}


//===========================================================================
// Required by Streamable Object
//============================= ==============================================
  
void CESQColl::Streamer(TBuffer& iobuffer)
{
  unsigned int start      = 0 ;
  unsigned int byte_count = 0 ;
  
  if (iobuffer.IsReading())
    {
      Version_t original_version = iobuffer.ReadVersion(&start, &byte_count) ;
      StorableObject::Streamer(iobuffer);
      readFromBuffer(iobuffer);
      iobuffer.CheckByteCount(start, byte_count, CESQColl::IsA()) ;
    }
  else if (iobuffer.IsWriting())
    {
      byte_count = iobuffer.WriteVersion(CESQColl::IsA(), kTRUE) ;      
      Version_t current_version = class_version() ;
      {  
	StorableObject::Streamer(iobuffer);
	writeToBuffer(iobuffer);
      }
      iobuffer.SetByteCount(byte_count, kTRUE) ;    
    }
  else
    {
      std::cerr << "In CESQColl::Streamer: TBuffer is in unknown state"
                << std::endl;
    } 
}





void CESQColl::writeToBuffer(TBuffer &iobuffer)
 {
   iobuffer << _bufferSize;   
   if (_bufferSize > 0){
     iobuffer . WriteFastArray ( _chid, _bufferSize );
     iobuffer . WriteFastArray ( _energy, _bufferSize );
   }
 }



void CESQColl::readFromBuffer(TBuffer &iobuffer)
 {
  iobuffer >> _bufferSize;
  initializeBuffers();
  
  if (_bufferSize > 0){
    iobuffer . ReadFastArray ( _chid, _bufferSize );
    iobuffer . ReadFastArray ( _energy, _bufferSize );
  }
 }

void CESQColl::initializeBuffers(){
  if (_bufferSize > 0)    
    _energy = new uint2[_bufferSize];
    _chid = new uint2[_bufferSize];
}


//-----------------------------------------------------------------------------
// Functions to retrieve the collection from the event
//-----------------------------------------------------------------------------

CESQColl::Error CESQColl::find(CESQColl_ch& cHandle)
{
  EventRecord::ConstIterator ciEvent(AbsEnv::theEvent(),"CESQColl");
  
  if (ciEvent.is_valid())
    {
      cHandle = ciEvent;
      return OK;
    }
  else
    {
      cHandle.set_null();
      return ERROR;
    } 

}

CESQColl::Error CESQColl::find(CESQColl_ch& cHandle,
			       const StorableObject::Selector & selector)
{
  EventRecord::ConstIterator ciEvent(AbsEnv::theEvent(),"CESQColl");
  while (ciEvent.is_valid() && !selector(*ciEvent))
    {
      ++ciEvent;
    }
  if (ciEvent.is_valid()) 
    {
      cHandle = ciEvent;
      return OK;      
    } 
  else 
    {
      cHandle.set_null();
      return ERROR;
    }
}



CESQColl* CESQColl::clone(void) { return new CESQColl (*this); }

//=============================================================================
// ROOT I/O Hook
//=============================================================================

CdfClassImp(CESQColl)