#include <cstdlib>
#include <fstream>

#include <Stntuple/data/TClcConstants.hh>
#include <Stntuple/obj/TClcDataBlock.hh>


ClassImp(TClcDataBlock)

//______________________________________________________________________________
void TClcDataBlock::ReadV1(TBuffer &R__b)
{
  R__b.ReadStaticArray(fAdcData);
  fTdcData.Streamer(R__b);
  InitIsolatedChannels(); 
}

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

  if (R__b.IsReading()) 
    {
      Clear();
      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
      if      (R__v == 1) ReadV1(R__b);
      else
	{
	  R__b.ReadStaticArray(fAdcData);
	  fTdcData.Streamer(R__b);
	  fListOfIsolatedChannels.Streamer(R__b);
	  InitTdcChannels();
	  InitIsolatedChannels();
	}   
    }
  else
    {
      R__b.WriteVersion(TClcDataBlock::IsA());
      R__b.WriteArray(fAdcData, kNChannels);
      fTdcData.Streamer(R__b);
      fListOfIsolatedChannels.Streamer(R__b);
    }
}


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

  int old = -1;
  int ich, nw;
  fNAdcHits = kNChannels;
  fTdc.SetData(fTdcData.GetArray());
  nw = fTdc.NDataWords();

  for (int i=0; i<nw; i++) {
    TTdcWord* x   = fTdc.Data(i);
    ich = x->ChannelId();
    if (ich != old) {
      if(ich<0 || ich>95) {
        printf("Bad Clc Data TDC word=%d channel=%d\n",i,ich);
      } else {
	fChannel[ich].fTdcWord = x;
	old                    = ich;
      }
    }
    fChannel[ich].fNTdcHits++;
  }
  
  return 0;
}

//_____________________________________________________________________________
Int_t TClcDataBlock::InitIsolatedChannels(){
  
  int nw;
  for (int i=0; i<kNChannels; i++)
    {
      fChannel[i].SetIsolated(0);
    } 
  
  nw = fListOfIsolatedChannels.NDataWords();
  for (int i=0; i<nw; i++) 
    {
      fChannel[fListOfIsolatedChannels[i]].SetIsolated(1);
    }
  
  return 0;
}

//_____________________________________________________________________________
TClcDataBlock::TClcDataBlock():
  fTdcData(100)
{
  fRunNumber    = -1;
  fEventNumber  = -1;
  fInitialized  =  0;
					// default version of the calibration
					// constants
  fCalibVersion =  0;
  fCalibRun     = -1;
  fCalibDone    =  0;
  fListOfIsolatedChannels.Clear();
					// initialize transient part to allow 
					// fast I/O (reading the data in 
					// 2 blocks)
  fTdcData.Clear();

  for (int i=0; i<kNChannels; i++) {
    fChannel[i].fAdcData  = &fAdcData[i];
    fChannel[i].fNTdcHits = 0;
  }
					// this may not be the right place for
					// the initialization, but keep it here
					// for the moment
  int ich = 0;
  for (int m=0; m<kNModules; m++) {
    for (int l=0; l<TClcModule::kNLayers; l++) {
      for (int i=0; i<TClcLayer::kNChannels; i++) {
	TClcChannel* ch = fChannel+ich;

					// set constants for this channel

	fModule[m].Layer(l)->SetChannel(i,ch);
	ich++;
      }
    }
  }
}

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



//_____________________________________________________________________________
void TClcDataBlock::Clear(Option_t* opt) {
  fTdcData.Clear();
  // zero the part of data array corresponding to word count
  *(fTdcData.GetArray()) = 0;
  fListOfIsolatedChannels.Clear();
  fTdc.SetData(&TTdcModule::kZero);

  for (int i=0; i<kNChannels; i++) { fAdcData[i] = 0; }

  for (int i=0; i<kNModules; i++) {
    fModule[i].Clear();
  }
  fInitialized = 0;
}


//_____________________________________________________________________________
//  in principle need to print CLC data in 2 big columns such that the
//  output would take about 48 lines
//-----------------------------------------------------------------------------
void TClcDataBlock::Print(const char* opt) const {
  // print method

  TClcDataBlock* block = (TClcDataBlock*) this;

  printf("  run/event : %7i / %7i , N(TDC hits) = %5i\n",
	 f_EventNumber, f_RunNumber,NTdcHits());
  printf(" ch#  Adc   NTdcHits Start Width CH# First\n");
  for (int i=0; i<kNChannels; i++) {
    TClcChannel* ch = (TClcChannel*) block->Channel(i);
    printf("%3i %5i  %5i",i,ch->AdcCounts(),ch->NTdcHits());
    int first = 1;
    if (ch->NTdcHits()) {
      for (int j=0; j<ch->NTdcHits(); j++) {
	if (! first) {
	  printf("                ");
	}
	first = 0;
	TTdcWord* tdc = ch->TdcWord(j);
	printf("    %5i %5i %2i %1i\n",
	       tdc->LeadingEdge(),
	       tdc->Width(),
	       tdc->ChannelId(),
	       tdc->First());
      }
    }
    else {
      printf("\n");
    }
  }
}

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

  // first implementation: read a given file

  if ( (fCalibRun == run_number) && fCalibDone) return 0;

  char fn[100], c[200];
  int i, bad, done;
  float t0, t1w, a0w, b1w, b2w, slope, t0w;

  sprintf(fn,"%s/clc/r%i_v%03i.txt",getenv("MYDB"),run_number,fCalibVersion);

  done = 0;

  FILE* f = fopen(fn,"r");
  if (f) {

    while ( ((c[0]=getc(f)) != EOF) && !done) {
					// check if it is a comment line
      if (c[0] != '#') {
	ungetc(c[0],f);
					// read channel number
	fscanf(f,"%i",&i);
	fscanf(f,"%i",&bad  );
	fscanf(f,"%f",&t0   );
	fscanf(f,"%f",&t1w  );
	fscanf(f,"%f",&a0w  );
	fscanf(f,"%f",&b1w  );
	fscanf(f,"%f",&b2w  );
	fscanf(f,"%f",&slope);
	fscanf(f,"%f",&t0w  );

	if (i < 96) {
	  
	  TClcChannel* ch = Channel(i);

	  ch->SetBad  (bad  );
	  ch->SetT0   (t0   );
	  ch->SetT1W  (t1w  );
	  ch->SetA0W  (a0w  );
	  ch->SetB1W  (b1w  );
	  ch->SetB2W  (b2w  );
	  ch->SetSlope(slope);
	  ch->SetT0W  (t0w  );
	}
	else if (i < 98) {
					// channels 96 and 97 are used to
					// define global calib constants
					// for the WEST and EAST modules
	  TClcModule* m = Module(i-96);
	  m->SetRefChannel(bad);
	  m->SetT0        (t0 );
	  m->SetT0W       (t0w);
					// pass values of global delays to
					// the layers

	  for (int j=0; j<TClcModule::kNLayers; j++) {
	    TClcLayer* lay = m->Layer(j);
	    lay->SetT0 (t0 );
	    lay->SetT0W(t0w);
	  }
	  if (i == 97) done = 1;
	}
      }
      else {
					// skip line
	fgets(c,100,f);
      }
    }
    fclose(f);
    fCalibRun  = run_number;
    fCalibDone = 1;
    return 0;
  }
  else {
					// can't read calibrations
    return -1;
  }
}