//////////////////////////////////////////////////////////////////////////////
//
// $Id: $
//
//*-- Author  : JAM
//*-- Revised : Joern Adamczewski-Musch <j.adamczewski@gsi.de> 2017
//
//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////////////////////////////
//
//  HRich700ThresholdPar
//    Treestyle parameter container with trb3 time thresholds for rich700
//    Defined after example of hrichcalpar JAM Nov2017
//
//////////////////////////////////////////////////////////////////////////////

#include "hdetpario.h"
#include "hpario.h"
#include "hrich700thresholdpar.h"
//#include "hrich700pixelthreshold.h"
#include "richdef.h"

#include <fstream>

using namespace std;

ClassImp(HRich700ThresholdPar)

    HRich700ThresholdPar::HRich700ThresholdPar(const Char_t* name,
					       const Char_t* title, const Char_t* context) : HParSet(name, title, context)
{
    strcpy(detName, "Rich");

    fLoc.setNIndex(2);
    fParamsTable.set(2, RICH700_MAX_PMT+1, RICH700_MAX_PMTPIXELS+1);
    fParamsTable.setCellClassName("HRich700PixelThreshold");
    fParamsTable.makeObjTable();

    clear();

    status = kFALSE;
    resetInputVersions();

}

HRich700ThresholdPar::~HRich700ThresholdPar()
{
    fParamsTable.deleteTab();
}

void HRich700ThresholdPar::clear() {
    // initialize all pixels to 0, flag to -1

    // NOTE: first real pmt and pixel object index is 1
    // we initialize slots for 0 indices anyway to avoid root streamer trouble...
    HRich700PixelThreshold* pCell = NULL;
    for (Int_t pmt = 0; pmt <= RICH700_MAX_PMT; ++pmt) {
	fLoc[0] = pmt;
	for (Int_t pixel = 0; pixel <= RICH700_MAX_PMTPIXELS; ++pixel) {
	    fLoc[1] = pixel;
	    pCell = static_cast<HRich700PixelThreshold*>(fParamsTable.getSlot(
									      fLoc));
	    if (NULL != pCell) {
		pCell = new (pCell) HRich700PixelThreshold;
		pCell->reset();
		pCell->setPMT(pmt);
		pCell->setPixel(pixel);
	    } else {
		Error("HRich700ThresholdPar", "Slot not found:  %i %i ",
		      fLoc[0], fLoc[1]);
	    }
	} //pix
    } //pmt

}

Bool_t HRich700ThresholdPar::init(HParIo* inp, Int_t* set)
{
    // Initializes the container from an input

    HDetParIo* input = inp->getDetParIo("HRichParIo");
    if (NULL != input) {
	Bool_t returnValue = input->init(this, set);
#if DEBUG_LEVEL > 3
	printParams();
#endif
	return returnValue;
    }
    return kFALSE;
}

Int_t HRich700ThresholdPar::write(HParIo* output)
{
    // Writes the container to an output

    HDetParIo* out = output->getDetParIo("HRichParIo");
    if (NULL != out) {
	return out->write(this);
    }
    return -1;
}

Bool_t HRich700ThresholdPar::readline(const Char_t * buf)
{
    // Decodes one line read from ASCII file I/O and fills the pixels
    Bool_t rc = kFALSE;
    Int_t pmt = 0;
    Int_t pix = 0;
    Double_t t_min = 0.0;
    Double_t t_max = 0.0;
    Double_t tot_min = 0.0;
    Double_t tot_max = 0.0;
    Int_t flag = 0;
    Int_t n = sscanf(buf, "%i %i %lf %lf %lf %lf %i", &pmt, &pix, &t_min, &t_max,
		     &tot_min, &tot_max, &flag);
    // some debug:
    //	printf("HRich700ThresholdPar::readline() sees %d %d %e %e %e %e %d\n",
    //			pmt, pix, t_min, t_max, tot_min, tot_max, flag);

    if (7 == n) {
	rc = setPixelThreshold(pmt, pix, t_min, t_max, tot_min, tot_max, flag);
    } else {
	if (n < 7)
	    Error("readline", "Not enough values in line %s\n", buf);
	else
	    Error("readline", "Too many values in line %s\n", buf);
    }
    return rc;
}

void HRich700ThresholdPar::write(fstream& fout)
{
    // Writes the Rich Calibration Parameters to an ASCII file.

    HRich700PixelThreshold* pCell = NULL;
    for (Int_t pmt = 1; pmt <= RICH700_MAX_PMT; ++pmt) {
	fLoc[0] = pmt;
	for (Int_t pixel = 1; pixel <= RICH700_MAX_PMTPIXELS; ++pixel) {
	    fLoc[1] = pixel;
	    pCell = static_cast<HRich700PixelThreshold*>(fParamsTable.getSlot(
									      fLoc));
	    if (NULL != pCell) {
		if (-1 != pCell->getFlag()) {
		    fout.width(4); // pmt
		    fout << left << pCell->getPMT();
		    fout.width(4); // pix
		    fout << left << pCell->getPixel();
		    fout.width(10); // tmin
		    fout << left << pCell->getT_Min();
		    fout.width(10); // tmax
		    fout << left << pCell->getT_Max();
		    fout.width(10); // totmin
		    fout << left << pCell->getTot_Min();
		    fout.width(10); // totmax
		    fout << left << pCell->getTot_Max();
		    fout.width(4); // flag
		    fout << left << pCell->getFlag();
		    fout << endl;
		} // flag -1, is non initialized slot

	    } else {
		Error("HRich700ThresholdPar::write ", "Slot not found:  %i %i ",
		      fLoc[0], fLoc[1]);
	    }
	} //pix
    } //pmt

}

Bool_t HRich700ThresholdPar::setPixelThreshold(Int_t pmt, Int_t pix,
					       Double_t tmin, Double_t tmax, Double_t totmin, Double_t totmax,
					       Short_t flag)
{
    // IMPORTANT NOTE: first used object index in table is 1
    if ((pmt <= 0) || (pmt > RICH700_MAX_PMT) || (pix <= 0)
	|| (pix > RICH700_MAX_PMTPIXELS)) {
	Error("setPixelThreshold", "Wrong pixel coordinates");
	return kFALSE;
    }

    HRich700PixelThreshold* pCell = NULL;

    fLoc[0] = pmt;
    fLoc[1] = pix;

    pCell = static_cast<HRich700PixelThreshold*>(fParamsTable.getSlot(fLoc));
    if (NULL != pCell) {
	pCell->setParams(tmin, tmax, totmin, totmax, flag);
    } else {
	Error("HRich700ThresholdPar::setPixelThreshold", "Cell not found.");
	return kFALSE;
    }
    return kTRUE;
}

void HRich700ThresholdPar::printParams()
{
    // Prints the lookup table

    HRich700PixelThreshold* pCell = NULL;
    for (Int_t pmt = 1; pmt <= RICH700_MAX_PMT; ++pmt) {
	fLoc[0] = pmt;
	for (Int_t pixel = 1; pixel <= RICH700_MAX_PMTPIXELS; ++pixel) {
	    fLoc[1] = pixel;
	    pCell = static_cast<HRich700PixelThreshold*>(fParamsTable.getSlot(
									      fLoc));
	    if (NULL != pCell) {
		if (-1 != pCell->getFlag()) {
		    std::cout.width(4); // pmt
		    std::cout << left << pCell->getPMT(); // real pmt object index, not array index!
		    std::cout.width(4); // pix
		    std::cout << left << pCell->getPixel(); // real pmt pixel index, not array index!
		    std::cout.width(10); // tmin
		    std::cout << left << pCell->getT_Min();
		    std::cout.width(10); // tmax
		    std::cout << left << pCell->getT_Max();
		    std::cout.width(10); // totmin
		    std::cout << left << pCell->getTot_Min();
		    std::cout.width(10); // totmax
		    std::cout << left << pCell->getTot_Max();
		    std::cout.width(4); // flag
		    std::cout << left << pCell->getFlag();
		    std::cout << endl;
		} // flag -1, is non initialized slot

	    } else {
		Error("HRich700ThresholdPar::write ", "Slot not found:  %i %i ",
		      fLoc[0], fLoc[1]);
	    }
	} //pix
    } //pmt

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

}

void HRich700ThresholdPar::putAsciiHeader(TString & header) {
    // puts the ASCII header to the string used in HDetParAsciiFileIo
    header =
	"# Rich700 trb3 unpacker time threshold parameters\n"
	"# Format:\n"
	"# PMT \tPixel \tT_min (ns) \tT_max (ns) \tTot_min (ns) \tTot_max (ns) \tFlag (0=OK, 1=suppress pixel)\n";
}

HRich700PixelThreshold* HRich700ThresholdPar::getSlot(HLocation &loc) {
    return static_cast<HRich700PixelThreshold*>(fParamsTable.getSlot(loc));
}

HRich700PixelThreshold* HRich700ThresholdPar::getObject(HLocation &loc) {
    return static_cast<HRich700PixelThreshold*>(fParamsTable.getObject(loc));
}