//-----------------------------------------------------------------------------
// Oct 18, 2003  RLC: HATD data block.
//-----------------------------------------------------------------------------
#include "TBuffer.h"

#include <Stntuple/data/THatTdcData.hh>
#include <Stntuple/obj/THatDataBlock.hh>


ClassImp(THatDataBlock)

//_____________________________________________________________________________
THatDataBlock::THatDataBlock() :
  fHatd(200)
{
}

//_____________________________________________________________________________
THatDataBlock::~THatDataBlock() {
}


//______________________________________________________________________________
void THatDataBlock::Streamer(TBuffer &R__b) {
   // Stream an object of class THatDataBlock.

  if (R__b.IsReading()) {
    Clear();
    Version_t R__v = R__b.ReadVersion(); if (R__v) { }
    fHatd.Streamer(R__b);
    InitTdcChannels();
  }   
  else {
    R__b.WriteVersion(THatDataBlock::IsA());
    fHatd.Streamer(R__b);
  }
}


//_____________________________________________________________________________
Int_t THatDataBlock::InitTdcChannels() {
  // update transient data members

  int nw, loc, nw_total, itdc;

  fNHatdHits = 0;
  nw_total  = fHatd.NDataWords();
  loc       = 0;
  itdc      = 0;
  while (loc < nw_total) {
    fHatTdc[itdc++].SetData(fHatd.GetArray()+loc);
    THatTdcHeader header = (THatTdcHeader) fHatd[loc];

    nw = header.NDataWords();
    fNHatdHits += nw;
					// n(data words) +  header
    loc += nw+1;
  }
  return 0;
}


//_____________________________________________________________________________
// i is the TDC number
THatTdcHeader&  THatDataBlock::GetHatTdcHeader(Int_t i)   { 
  return *((THatTdcHeader*)fHatTdc[i].Header()); }

//_____________________________________________________________________________
// i is the TDC number. j=hit number
THatTdcWord&    THatDataBlock::GetHatTdcWord(Int_t i, Int_t j)   { 
  return *((THatTdcWord*)fHatTdc[i].Data(j)); }

//_____________________________________________________________________________
// get eta and phi indices from header and word
// this returns 0->23 in phi even in the plug region with 48 towers
// since those towers are ganged by 2
Int_t    THatDataBlock::GetEtaPhi(THatTdcHeader& h, THatTdcWord& w, 
			  Int_t& phi, Int_t& eta) {
  
  phi = (h.LowWedge() + w.Wedge());

  int rBit = h.RapidityBit();
  int rSeg = w.RapiditySeg();

  if(rBit==1) {
    eta = rSeg+16;
  } else {
    eta = rSeg;
  }
  eta = (w.Side()==0? 25-eta : eta+26 );
  
  return 0;
}

//_____________________________________________________________________________
// get data for eta and phi indicies
// user must check return value to see if the hit was present
// this returns 0->23 in phi even in the plug region with 48 towers
// since those towers are ganged by 2
Int_t    THatDataBlock::GetDataEtaPhi(THatTdcHeader& h, THatTdcWord& w, 
			      Int_t phi, Int_t eta) {
  h.Clear();
  w.Clear();
  int ip,ie;
  for(int m=0; m<kHatTdcs; m++) {
    THatTdcHeader& head = GetHatTdcHeader(m);
    for(int hit=0; hit<head.NDataWords(); hit++) {
      THatTdcWord& word = GetHatTdcWord(m,hit);
      GetEtaPhi(head,word,ip,ie);
      if(ip==phi && ie==eta) {
	h = head;
	w = word;
	return 0;
      }
    }
  }
  
  return 1;
}


//_____________________________________________________________________________
void THatDataBlock::Clear(Option_t* opt) {
  // make the data block looking like there is no data in it

  fHatd.Clear();
  for (int i=0; i<kHatTdcs; i++) {
    fHatTdc[i].SetData(&TTdcModule::kZero);
  }

  f_EventNumber     = 0;
  f_RunNumber       = 0;
  fLinksInitialized = 0;
}


//-----------------------------------------------------------------------------
void THatDataBlock::Print(const char* opt) const {

  printf(" *********************** HAT data block ************************\n");
  printf(" N(HAT D-hits) : %5i\n",NHatdHits());

  THatDataBlock* block = (THatDataBlock*) this;

  if (NHatdHits() == 0) { printf("No TDC hits.\n"); return; }

  printf(" TDC N(hits) Hit# LeadingEdge Width First RapBit  Side  LowWed ");
  printf(" Region RapSeg Wedge \n");

  for (int itdc=0; itdc<kHatTdcs; itdc++) {
    TTdcModule& tdc = block->HatTdc(itdc);
    int nhits = tdc.NDataWords();
    if (nhits > 0) {
      printf(" %3i %7i\n",itdc, nhits);

      THatTdcHeader* header = (THatTdcHeader*) tdc.Header();

      for (int i=0; i<nhits; i++) {
	THatTdcWord* data = (THatTdcWord*) tdc.Data(i);

	printf("            %3i %10i %6i %5i %6i %6i %6i %6i %6i %6i\n",
	       i,
	       data->LeadingEdge(),
	       data->Width(),
	       data->First(),
	       data->ChannelId(),
	       header->RapidityBit(),
	       data->Side(),
	       header->LowWedge(),
	       data->RapiditySeg(), 
	       data->Wedge() );

      }
    }
  }

}

//_____________________________________________________________________________
int THatDataBlock::ReadCalibrations(int run_number) {

  return 0;
}