#include "evt/Event.hh"
#include <Bbos/bank_interface.hh>

#include "CalorGeometry/CalorKey.hh"

#include "CalorGeometry/CalConstants.hh"
#include "CalorGeometry/CalParameters.hh"

#include "CalorObjects/CalTower.hh"
#include <CalorObjects/CalData.hh>

#include <Stntuple/obj/TCalDataBlock.hh>
#include <Stntuple/mod/InitStntupleDataBlocks.hh>

//_____________________________________________________________________________
Int_t StntupleInitCalTower(TCalTower* Pasha, const CalTower* Pierre) {


  Pasha->SetValidCode(Pierre->validCode());

  int   adc;
  int   ieta   = Pierre->iEta();
  int   iphi   = Pierre->iPhi();

  Pasha->SetEtaPhi(ieta,iphi);

  Pasha->SetHadEnergy(Pierre->hadEnergy());
  Pasha->SetEmEnergy (Pierre->emEnergy ());
  Pasha->SetHadCOGPhi(Pierre->hadCOGPhi());
  Pasha->SetEmCOGPhi (Pierre->emCOGPhi ());

  Int_t   t1, t2, n1, n2;

  t1 = -999;
  t2 = -999;
  n1 = 0;
  n2 = 0;
//-----------------------------------------------------------------------------
// as there is no overlap between the CHA and PHA, t1 is CHA/PHA time, 
// t2 is always WHA time
//-----------------------------------------------------------------------------
  CellKey k1;
  if (Pierre->includesDetector(CHA)) 
    {
      k1 = CellKey(ieta,iphi,CHA);
      n1 = Pierre->nTDCHits(k1);
      
      if (n1 > 0) 
	{
	  Int_t iminTime = 9999;
	  Int_t itmp = 0;
	  for (int iN=0; iN<n1; ++iN) 
	    {
	      itmp = (int) Pierre->time(k1,iN);
	      if (abs(itmp) < iminTime) {iminTime = itmp;}
	    }
	  t1 = iminTime;
	}
    }
  else if (Pierre->includesDetector(PHA)) 
    {
      k1 = CellKey(ieta,iphi,PHA);
      n1 = Pierre->nTDCHits(k1);
      if (n1 > 0)
	{
	  Int_t iminTime = 9999;
	  Int_t itmp = 0;
	  for (int iN=0; iN<n1; ++iN) 
	    {
	      itmp = (int) Pierre->time(k1,iN);
	      if (abs(itmp) < iminTime) {iminTime = itmp;}
	    }
	  t1 = iminTime;
	}
    }

  if (Pierre->includesDetector(WHA)) {
    CellKey k2 = CellKey(ieta,iphi,WHA);
    n2 = Pierre->nTDCHits(k2);
    if (n2 > 0) {
      Int_t iminTime = 9999;
      Int_t itmp = 0;
      for (int iN=0; iN<n2; ++iN) {
	itmp = (int) Pierre->time(k2,iN);
	if (abs(itmp) < iminTime) {iminTime = itmp;}
      }
      t2 = iminTime;
    }
  }
  
  Pasha->SetNTdcHits(n1,n2);
  Pasha->SetHadTdc  (t1,t2);
  
  int nem    = Pierre->nEmPmt ();
  int nhad   = Pierre->nHadPmt();

  for (int i=0; i<4; i++) {

    if (i < nem ) {
      adc = Pierre->emPmt(i);
      if (adc > 65535) adc = 65535;
      Pasha->SetEmPmt(i,Pierre->emPmt(i));
    }
    else          Pasha->SetEmPmt(i,0);


    if (i < nhad) {
      adc = Pierre->hadPmt(i);
      if (adc > 65535) adc = 65535;
      Pasha->SetHadPmt(i,adc);
    }
    else          Pasha->SetHadPmt(i,0);
  }
  return 0;
}


//_____________________________________________________________________________
Int_t StntupleInitCalDataBlock(TStnDataBlock* block, AbsEvent* event, int mode) 
{
  // initialize CAL data block with the `event' data

  int                ev_number, rn_number;

  ev_number = AbsEnv::instance()->trigNumber();
  rn_number = AbsEnv::instance()->runNumber();

  if (block->Initialized(ev_number,rn_number)) return 0;

  TCalDataBlock* data = (TCalDataBlock*) block;
  data->Clear();

 // make a handle to a CalData object.   

  CalData_ch cal_data;
  TCalTower* t;

  CalData::Error result = CalData::find(cal_data);
  
  if (result != CalData::OK){
    return -1;
  }

  cal_data->totalEnergies(data->fEmEnergy,data->fHadEnergy);

  float DEP2PART_CORR = 2.50; // (error : +/-0.63)
  for (CalData::ConstIterator it=cal_data->begin(); it!=cal_data->end(); ++it) {
    const CalTower* pierre = it.tower();
    int ok = 0;
    for (int i=0; i<pierre->nEmPmt(); i++) {
      if (pierre->emPmt(i) >= data->AdcThreshold()) {
	ok = 1;
	break;
      }
    }

    if (! ok) {
					// check HAD channels

      for (int i=0; i<pierre->nHadPmt(); i++) {
	if (pierre->hadPmt(i) >= data->AdcThreshold()) {
	  ok = 1;
	  break;
	}
      }
    }

    if (ok) {
					// one of the readout channels is above
					// the threshold, tower to be stored
      t = data->NewTower();
      StntupleInitCalTower(t,pierre);
					// note that packed energies are used
					// for SumEt calculation, thus the 
					// number may be slightly different
					// from that stored in METS
      if (t->IEta() > 3 && t->IEta() < 48) {
	data->fSumEt += t->Et();
	if (t->Et() > 0.1) {
	  float F_abs = 1.6;
	  if (t->Et() > 2.0) F_abs = 1.2;
	  data->fXiP     += F_abs*t->Et()*exp(t->Eta()); 
	  data->fXiPbar  += F_abs*t->Et()*exp(-1.0*t->Eta());
	}
      }
      else {
	float corr_et = DEP2PART_CORR*t->Et();
	if (t->IEta() <= 3) data->fSumEtMP[0] += corr_et;
	else data->fSumEtMP[1] += corr_et;
	data->fMEtXMP  += corr_et*cos(t->Phi());
	data->fMEtYMP  += corr_et*t->Et()*sin(t->Phi());
	if (corr_et > 0.02) {
	  data->fXiP     +=  corr_et*exp(t->Eta()); 
	  data->fXiPbar  +=  corr_et*exp(-1.0*t->Eta());
	}
      }
    }
  }

  data->fXiP        = data->fXiP/1960.;
  data->fXiPbar     = data->fXiPbar/1960.;
  data->fNMPHits[0] = data->GetMPMultiplicity(0,0.02,1);
  data->fNMPHits[1] = data->GetMPMultiplicity(1,0.02,1);

					// on return set event and run numbers
					// to mark block as initialized
  data->f_RunNumber   = rn_number;
  data->f_EventNumber = ev_number;

  return 0;
}