#include "hitofcalpar.h"
#include "hades.h"
#include "hspectrometer.h"
#include "hdetpario.h"
#include "hpario.h"
#include "hitofdetector.h"

using namespace std;
#include <iostream>
#include <iomanip>

ClassImp(HiTofCalPar)
ClassImp(HiTofCalParSec)
ClassImp(HiTofCalParMod)
ClassImp(HiTofCalParCell)

//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////////////
// HiTofCalPar
//
// HiTofCalPar is used to manage of all parameters for calibration
// which contains all HiTofCalParCell objects. One HiTofCalParCell
// object contains calibration parameters of one cell.
//
//////////////////////////////////////////////////////////////////////


HiTofCalParCell::HiTofCalParCell()
{
    reset();
}

void HiTofCalParCell::reset()
{
    for(Int_t i = 0; i< NCHAN; i++){
	fOffset [i] = 0.0;
	fSlope  [i] = 1.;
	fadcPar0[i] = 0.0;
	fadcPar1[i] = 0.0;
	fadcPar2[i] = 0.0;
	ftwcPar0[i] = 0.0;
	ftwcPar1[i] = 0.0;
	ftwcPar2[i] = 0.0;
    }
}

void    HiTofCalParCell::fill(HiTofCalParCell& c)
{
      for(Int_t i = 0; i< NCHAN; i++){
	fOffset [i] = c.getOffset(i);
	fSlope  [i] = c.getSlope(i);
	fadcPar0[i] = c.getAdcPar0(i);
	fadcPar1[i] = c.getAdcPar1(i);
	fadcPar2[i] = c.getAdcPar2(i);
	ftwcPar0[i] = c.getTwcPar0(i);
	ftwcPar1[i] = c.getTwcPar1(i);
	ftwcPar2[i] = c.getTwcPar2(i);
    }
}
Float_t  HiTofCalParCell::calibrateTime(Int_t i,Float_t time)
{
    // to be implemented
    time += fOffset[i];
    return time;
}

Float_t  HiTofCalParCell::calibrateTime_walkcorr(Int_t i,Float_t time,Float_t width)
{
    // to be implemented
    time -= (fSlope [i]*width);
    time -= fadcPar0[i];
    time += fOffset[i];

    return time;
}

Float_t  HiTofCalParCell::correctSignalPropagation_walkcorr(Int_t i,Float_t time,Float_t theta)
{
    // to be implemented
    time -=   ( (fadcPar1[i]/1000.) * ( (theta-17)*(theta-17) ) );
    return time;
}


Float_t  HiTofCalParCell::calibrateCharge(Int_t i,Float_t width)
{
    // to be implemented
    return width;
}

HiTofCalParMod::HiTofCalParMod(Int_t n)
{
  // constructor creates an array of pointers of type HiTofCalParCell
    array = new TObjArray(n);
    for(Int_t c=0 ; c<n ; c++) {
	array->AddAt(new HiTofCalParCell(),c);
    }
}

HiTofCalParMod::~HiTofCalParMod(void)
{
  // destructor
  if(array) {
      array->Delete();
      delete array;
  }
}


HiTofCalParSec::HiTofCalParSec(Int_t n)
{
  // constructor creates an array of pointers of type HiTofCalParCell
    array = new TObjArray(n);
    for(Int_t m=0 ; m<n ; m++){
	array->AddAt(new HiTofCalParMod(),m);
    }
}

HiTofCalParSec::~HiTofCalParSec(void)
{
    // destructor
    if(array) {
	array->Delete();
	delete array;
    }
}

HiTofCalPar::HiTofCalPar(const Char_t* name,const Char_t* title,
			 const Char_t* context,
			Int_t n)
: HParSet(name,title,context)
{
    strcpy(detName,"iTof");
    array = new TObjArray(n);
    for (Int_t s=0; s<n; s++) {
	array->AddAt(new HiTofCalParSec(),s);
    }
}


HiTofCalPar::~HiTofCalPar()
{
    if(array){
	array->Delete();
	delete array;
    }
}

Bool_t HiTofCalPar::init(HParIo* inp,Int_t* set)
{
    // intitializes the container from an input
    // set additional information for itof detector

    HDetParIo* input = inp->getDetParIo("HiTofParIo");
    if (input) return (input->init(this,set));
    return kFALSE;
}

Int_t HiTofCalPar::write(HParIo* output)
{
    // writes the itof container to the output defined in the runtime
    // database

    HDetParIo* out = output->getDetParIo("HiTofParIo");
    if (out) return out->write(this);
    return -1;
}

void HiTofCalPar::clear()
{
    // sets the default values
    for(Int_t i0=0;i0<getSize();i0++) {
	HiTofCalParSec& sec=(*this)[i0];
	HiTofCalParMod& mod=sec[0];
	Int_t n2=mod.getSize();
	for(Int_t i2=0;i2<n2;i2++) mod[i2].reset();
    }

    status=kFALSE;
    resetInputVersions();
}

void HiTofCalPar::putAsciiHeader(TString& header)
{
    // to be implemented
    // puts the ascii header to the string used in HTofParAsciiFileIo
    header=
	"# Calibration parameters for the iTOF detector\n"
	"# Format:\n"
	"# sector  module  cell slot offset slope AdcPar0  AdcPar1  AdcPar2  Twc0  Twc1  Twc2\n";
}

Bool_t HiTofCalPar::writeline(Char_t *buf,Int_t s, Int_t m, Int_t c,Int_t sl)
{
    // to be implemented
    // writes one line to the buffer used by ascii file I/O
    HiTofCalParCell& cell=(*this)[s][m][c];
               // s   m  c   sl  off    slope  apar0  apar1  apar2  twpar0 twpar1 twpar2
    sprintf(buf,"%2i% 2i %2i %2i %10.5f %10.3f %10.5f %10.3f %10.5g %10.5g %10.5g %10.5g\n",
	   s,m,c,sl,
	   cell.getOffset(sl),
	   cell.getSlope(sl),
	   cell.getAdcPar0(sl),
	   cell.getAdcPar1(sl),
	   cell.getAdcPar2(sl),
	   cell.getTwcPar0(sl),
	   cell.getTwcPar1(sl),
	   cell.getTwcPar2(sl)
	  );
    return kTRUE;
}

void HiTofCalPar::readline(const Char_t *buf, Int_t *set)
{
    // to be implemented
    // decodes one line read from ascii file I/O
    Int_t s,m,c,sl;
    Float_t offset,slope;
    Float_t adcpar0,adcpar1,adcpar2,twcpar0,twcpar1,twcpar2;

    Int_t n = sscanf(buf, "%i%i%i%i%f%f%f%f%g%g%g%g",
		     &s,&m,&c,&sl,
                     &offset,&slope,
		     &adcpar0,&adcpar1,&adcpar2,
		     &twcpar0,&twcpar1,&twcpar2);

    if (n<12) {
	Error("readline", "Not enough values in line %s\n", buf);
    } else if (n > 12){
	Error("readline", "Too many values in line %s\n", buf);
    } else {

	if(s < 0 || s > 5) return;

	HiTofCalParCell& cell=(*this)[s][m][c];
	cell.setOffset(sl,offset);
	cell.setSlope(sl,slope);
	cell.setAdcPar0(sl,adcpar0);
	cell.setAdcPar1(sl,adcpar1);
	cell.setAdcPar2(sl,adcpar2);
	cell.setTwcPar0(sl,twcpar0);
	cell.setTwcPar1(sl,twcpar1);
	cell.setTwcPar2(sl,twcpar2);

	set[s]=999;    // maxmodules*nsec = 1 * 6
    }
}

Float_t HiTofCalPar::calibrateTime(Int_t s,Int_t m,Int_t c,Int_t i,Float_t rawTime)
{
    HiTofCalParCell& cell = (*this)[s][m][c];
    return cell.calibrateTime(i,rawTime);
}

Float_t HiTofCalPar::calibrateTime_walkcorr(Int_t s,Int_t m,Int_t c,Int_t i,Float_t rawTime,Float_t width)
{
    HiTofCalParCell& cell = (*this)[s][m][c];
    return cell.calibrateTime_walkcorr(i,rawTime,width);
}

Float_t  HiTofCalPar::correctSignalPropagation_walkcorr(Int_t s,Int_t m,Int_t c,Int_t i,Float_t calTime,Float_t theta)
{
    HiTofCalParCell& cell = (*this)[s][m][c];
    return cell.correctSignalPropagation_walkcorr(i,calTime,theta);
}

Float_t HiTofCalPar::calibrateCharge(Int_t s,Int_t m,Int_t c,Int_t i,Float_t width)
{
    HiTofCalParCell& cell = (*this)[s][m][c];
    return cell.calibrateCharge(i,width);
}

void HiTofCalPar::printParam(void)
{
    // to be implemented
    // prints the parameters
    TString header;
    putAsciiHeader(header);
    cout<<header<<endl;
    Text_t buf[1000];
    Int_t n0 = getSize();
    for(Int_t i0=0; i0<n0; i0++) { // sector
	Int_t n2 = (*this)[i0][0].getSize(); // 1 module -> ncells  skip mod loop
	for(Int_t i2=0; i2<n2; i2++) {
	    for(Int_t i3=0; i3<NCHAN; i3++) {
	    if (writeline(buf, i0, 0, i2,i3)) printf(buf,strlen(buf));
	    }
	}

    }
    printf("==============================================================\n");
}

void HiTofCalPar::printDummy()
{
    // prints a dummy format
    TString header;
    cout<<"##############################################################################"<<endl;
    putAsciiHeader(header);
    cout<<header;
    cout<<"##############################################################################"<<endl;
    cout<<"[iTofCalPar]"<<endl;
    cout<<"//----------------------------------------------------------------------------"<<endl;
    HiTofCalParCell cell;
    cell.reset();
    Int_t m=0;
    for(Int_t s=0; s<6; s++) { // sector
	for(Int_t c=0; c<3; c++) {
	    for(Int_t sl=0; sl<NCHAN; sl++) {
		// s   m  c   sl  off    slope  apar0  apar1  apar2  twpar0 twpar1 twpar2
		printf("%2i% 2i %2i %2i %10.5f %10.3f %10.5f %10.3f %10.5g %10.5g %10.5g %10.5g\n",
			s,m,c,sl,
			cell.getOffset(sl),
			cell.getSlope(sl),
			cell.getAdcPar0(sl),
			cell.getAdcPar1(sl),
			cell.getAdcPar2(sl),
			cell.getTwcPar0(sl),
			cell.getTwcPar1(sl),
			cell.getTwcPar2(sl)
		       );
	    }
	}

    }
    cout<<"##############################################################################"<<endl;
}