//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////////////////////////////
//
//  HStart2CalRunPar
//
//   Container to keep mean offsets per strip for the start
//   for a list of runs. Speciality : This container is derived
//   from HParCond, but uses the ASCII IO write() from HStartParAsciiFileIo
//   due to formating problems.
//
//   //##################################################
//
//   HOWTO FILL the container in a macro:
//
//   HStart2CalRunPar p("HStart2CalRunPar_test","HStart2CalRunPar_test");
//
//   HStar2CalRunPars data;
//   data.setVal( 0 , 30.); // first strip offset
//   .... 7 more strips
//   data.print()
//
//   p.addRun(runID,&data,kFALSE); // set channel in macro to write to ROOT/ASCII
//   ..... more runIDs
//   p.finishRunList();  // sort the list of runIDs at the end
//                       // only needed when not reading from
//                       // ASCII, ROOT or ORACLE
//
//   //##################################################
//
//   HOWTO USE the container:
//
//   HStart2CalRunPar* p = (HStart2CalRunPar*)gHades->getRuntimeDb()->getContainer("Start2CalRunPar");
//   HStar2CalRunPars data;
//   Bool_t remap=kFALSE
//   Bool_t found = p->getRun(runid,&data,remap); // get params for a given runID (see doumentation for meaning of remap)
//
//   p->printParams();                        // print container content
//   p->printRun(runID);                      // print a single run
//   Bool_t ok = p->findRunID(runID);         // is this runID inside ?
//   Int_t first,last;
//   p->getRangeRunID(first,last);            // get first and last runID inside the container
//   Int_t n = p->getNRunIDs();               // get the number runIDs inside the container
//
//////////////////////////////////////////////////////////////
//
//
//////////////////////////////////////////////////////////////////////////////


#include "hparamlist.h"
#include "hstart2calrunpar.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hrun.h"
#include "hdetpario.h"
#include "hparasciifileio.h"
#include "hdetparasciifileio.h"
#include "hstartparasciifileio.h"
#include "TBuffer.h"



ClassImp(HStart2CalRunPar)


HStart2CalRunPar::HStart2CalRunPar(const Char_t* name    ,
				   const Char_t* title   ,
				   const Char_t* context
				  ) : HParCond(name, title, context)
{
    fMIter = fMRunID.end();
}

HStart2CalRunPar::~HStart2CalRunPar()
{
    reset(1);
}

void HStart2CalRunPar::clear()
{
    fMIter = fMRunID.end();
}

void HStart2CalRunPar::printParams()
{
    // print the content of the container
    // in the order of all data per runID

    sort(fVRunID.begin(),fVRunID.end());

    Info("printParams()","Container: %s",GetName());

    for(UInt_t i = 0; i < fVRunID.size(); i ++ ){
	Int_t runId = fVRunID[i];
        printRun(runId);
    }
}

void HStart2CalRunPar::printRun(Int_t runID)
{
    // print a single run
    map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(runID);
    if(iter != fMRunID.end()) {
	HStart2CalRunPars* p = iter->second;
	if(p){
	    p->print(runID);
	}
    } else {
	Warning("printRun()","RunID = %i not found!",runID);
    }
}

void HStart2CalRunPar::putParams(HParamList* l)
{
    if (!l) return;

    if(fVRunID.size() > 0)
    {
	sort(fVRunID.begin(),fVRunID.end());

	//-------------------------------------------------------
        // fill param list as linearized array
        Int_t npars = 8; //default

	if(fVRunID.size() > 0) {
	    map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(fVRunID[0]);
	    if(iter != fMRunID.end()){
                 npars = iter->second->getNVals();
	    }
	}

	TArrayD arFull(fVRunID.size()*(npars+1)+1);
	arFull.SetAt(npars,0);

	for(UInt_t i = 0; i < fVRunID.size(); i ++ )
	{
	    Int_t runId = fVRunID[i];

	    map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(runId);
	    if(iter != fMRunID.end()){
		HStart2CalRunPars* ar = iter->second;
		if(ar){
		    arFull.SetAt(runId, 0 + i*(npars+1) + 1);
		    for(Int_t j=0;j<npars;j++){
			arFull.SetAt(ar->getVal(j),j+1 + i*(npars+1) + 1);
		    }
		}
	    }
	}
	l->add("startOffsets", arFull);

    } else {
	Warning("putParams()","No Runs contained in map!");
    }
}

Bool_t HStart2CalRunPar::getParams(HParamList* l)
{
   if (!l) return kFALSE;

   TArrayD arFull;
   if (!l->fill("startOffsets",  &arFull))  return kFALSE;

   Int_t npars = (Int_t) arFull.At(0);
   Int_t nRuns = (arFull.GetSize()-1)/(npars+1);

   for(Int_t i = 0; i < nRuns; i ++ )
   {
       Int_t runId = (Int_t) arFull.At(i*(npars+1) + 1);

       HStart2CalRunPars p(npars);

       for(Int_t j = 0; j < npars; j ++){
	   p.setVal(j,arFull.At(j+1 + i*(npars+1) + 1));
       }
       addRun(runId,&p);
   }

   sort(fVRunID.begin(),fVRunID.end());

   return kTRUE;
}

Int_t HStart2CalRunPar::write(HParIo* output) {
    // writes the parameter container to the output
    

    TString name = output->ClassName();
    
    if(name == "HParAsciiFileIo"){

	HDetParIo* out = output->getDetParIo("HStartParIo");
	if(out){
	    return out->write(this);
	} else {
            Error("write()","HStartParIo not found, but needed for ASCII io write. You have to add the HStartDetector!");
	    return -1;
	}
    } else {
	HDetParIo* out = output->getDetParIo("HCondParIo");
	if(out){
	    return out->write(this);
	} else return -1;
    }
    return -1;
}

void HStart2CalRunPar::putAsciiHeader(TString& b)
{
    // header information needed by HStartParAsciiFileIo::write
    b = "# Start2 mean offsets per strip per run\n";
}

Int_t HStart2CalRunPar::write(fstream& pFile)
{
    // needed by HStartParAsciiFileIo::write
    sort(fVRunID.begin(),fVRunID.end());

    //-----------------------------------------------------
    pFile<<"startOffsets: Double_t \\"<<endl;
    Int_t npars = 8;
    if(fVRunID.size()>0){
	map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(fVRunID[0]);
	HStart2CalRunPars* p = iter->second;
        npars = p->getNVals();
    }
    pFile<<" "<<npars;
    for(UInt_t i = 0; i < fVRunID.size(); i ++ ){
	Int_t runID = fVRunID[i];
	pFile<<" "<<runID;
	map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(runID);
	if(iter != fMRunID.end()) {
	    HStart2CalRunPars* p = iter->second;
	    if(p){
		for(Int_t j = 0; j < p->getNVals(); j ++){
                    pFile<<" "<<p->getVal(j);
		}
                if(i<fVRunID.size()-1) pFile<<" \\"<<endl;
                else                   pFile<<endl;
	    }
	}
    }
    //-----------------------------------------------------
    return 0;
}
Bool_t HStart2CalRunPar::init(HParIo* inp,Int_t* set) {
    // intitializes the container from an input

    HRun* currentRun = gHades->getRuntimeDb()->getCurrentRun();
    Int_t runID      = currentRun->getRunId();

    Bool_t rc = kTRUE;

    if(!findRunID(runID))
    {
	HDetParIo* input = inp->getDetParIo("HCondParIo");

	rc = kFALSE;

	TString name = inp->ClassName();


	//--------------------------------------
	// clean up container : map + runid list
	reset(1);
	//--------------------------------------

	if (input) rc = input->init(this,set);

	if(rc && name == "HParAsciiFileIo"){
	    setStatic();
	}

        finishRunList();// sort runIDS
    }

    return rc;
}



void HStart2CalRunPar::getRunIDList(TArrayI* ar)
{
    // coppies the list of runIDs into the TArrayI.
    // The array will be rested before.
    sort(fVRunID.begin(),fVRunID.end());
    if(ar && fVRunID.size() > 0){
	ar->Reset();

	ar->Set(fVRunID.size());
	for(UInt_t i = 0; i < fVRunID.size(); i ++ ){
	    ar->SetAt(fVRunID[i],i);
	}
    }

}

void HStart2CalRunPar::printRunIDList()
{
    Info("printRunIDList()","Container: %s",GetName());
    for(UInt_t i = 0; i < fVRunID.size(); i ++ ){
	cout<<setw(5)<<i<<" = "<<fVRunID[i]<<endl;
    }
}
Bool_t HStart2CalRunPar::getRangeRunID(Int_t& first,Int_t& last)
{
    // returns the first and last runID in the container

    sort(fVRunID.begin(),fVRunID.end());

    first = -1;
    last  = -1;

    if(fVRunID.size() > 0) {
	first = fVRunID[0];
	last  = fVRunID[fVRunID.size()-1];
    }

    return kTRUE;
}

Bool_t HStart2CalRunPar::findRunID(Int_t runId)
{
    // returns kTRUE if the runID exists
    if(find(fVRunID.begin(),fVRunID.end(),runId) != fVRunID.end()) return kTRUE;
    else return kFALSE;
}

void HStart2CalRunPar::reset(Int_t level) {

    // empty all maps, vectors
    // of runIds and data
    // level  : 0 reset map
    //          1 reset map + runID list

    map<Int_t,HStart2CalRunPars*>::iterator iter;
    for( iter = fMRunID.begin(); iter != fMRunID.end(); ++iter ) {
	HStart2CalRunPars* ar = iter->second;
	delete ar;
    }
    fMRunID.clear();

    fMIter = fMRunID.end();

    if(level > 0) fVRunID.clear();

}

Bool_t HStart2CalRunPar::removeRun(Int_t runID, Int_t level) {

    // remove all maps for this runID
    // level = 0 : remove Data for runID, but keep runID in list of runs
    //       = 1 (default): remove Data for runID, and runID in list of runs

    map<Int_t,HStart2CalRunPars*>::iterator iter = fMRunID.find(runID);

    if(iter != fMRunID.end())
    {
	HStart2CalRunPars* ar = iter->second;
        delete ar;

	fMRunID.erase( iter );

	if(level > 0){
	    vector<Int_t>::iterator iterv = find(fVRunID.begin(),fVRunID.end(),runID);
	    fVRunID.erase( iterv );
	}

	fMIter = fMRunID.end();  // iter could be invalid
    } else {
	Error("removeRun()","RunID = %i not found!",runID);
	return kFALSE;
    }

    return kTRUE;
}

Bool_t HStart2CalRunPar::addRun(Int_t runID,HStart2CalRunPars* data, Bool_t overwrite) {

    // return data for this run to data
    // if overwrite = kTRUE, an existing data will be overwritten (default=kFALSE)

    if(!data){
	Error("addRun()","Recieved NULL pointer for RunID = %i!",runID);
        return kFALSE;
    }

    fMIter = fMRunID.find(runID);

    if(fMIter == fMRunID.end() || (overwrite && fMIter != fMRunID.end() ) )
    {
	if(fMIter != fMRunID.end()) removeRun(runID,0); // keep runID
	else                        fVRunID.push_back(runID);

	HStart2CalRunPars* ar = new HStart2CalRunPars(data->getNVals());
        ar->copyVals(data);
	fMRunID[runID] = ar;

    } else {
        Error("addRun()","RunID = %i already exists !",runID);
        return kFALSE;
    }
    return kTRUE;
}

Bool_t HStart2CalRunPar::getRun(Int_t runID,HStart2CalRunPars* data,Bool_t remap) {

    // return data for this run to data
    // data in data will be overwritten!
    // if the size does not fit data will
    // be adapted. remap = kFALSE return kFALSE
    // if runID was not found. remap == kTRUE (default)
    // allows a remap in case the runID is not found
    // to the the next smaller existing runID
    // will be used. This allows to provide calibration
    // parameters for preriods of time without the need
    // to dublicate the pars for each runID.

    if(!data) Error("addRun()","Recieved NULL pointer for RunID = %i!",runID);


    if(fMIter == fMRunID.end() || fMIter->first != runID) fMIter = fMRunID.find(runID);

    if(fMIter != fMRunID.end() )
    {
	HStart2CalRunPars* ar = fMIter->second;

	if(data->getNVals() < ar->getNVals()) {
	    Warning("getData()","Size of HStart2CalRunPars : in container %i vals, your input object %i vals ! ... Resize output object!",ar->getNVals(),data->getNVals());
	    data->setSize(ar->getNVals());
	}
	ar->getVals(data);

    } else {

        // loop the existing runs to find the next
	// smaller runid than runID and use this data
        // instead. Assumes the runs to sorted ascending
	if(!remap || fVRunID.size() > 0)
	{
            Bool_t found     = kFALSE;
            Int_t  replaceID = runID;

	    if(runID < fVRunID[0] ){ // runid is bfore all known runids

               found     = kTRUE;
	       replaceID = fVRunID[0];

	       getRun(replaceID,data);
	       Info("getData()","RunID = %i mapped to runID = %i (RunID smaller first RunID in Container)!",runID,replaceID);
	       return kTRUE;
	    }


	    for(Long64_t i = fVRunID.size() - 1; i >= 0 ; i--){  // Long64_t to avoid i>=0 in UInt_t
		if(fVRunID[i] < runID){
		    found     = kTRUE;
		    replaceID = fVRunID[i];
                    break;
		}
	    }

	    if(found)
	    {
                getRun(replaceID,data);
		Info("getData()","RunID = %i mapped to runID = %i (mapped to next smaller RunID)!",runID,replaceID);
		return kTRUE;

	    } else {

		Error("getData()","RunID = %i not found !",runID);
		return kFALSE;

	    }

	} else {
	    Error("getData()","RunID = %i not found (no Remap)!",runID);
	    return kFALSE;
	}
    }
    return kTRUE;
}

void HStart2CalRunPar::finishRunList()
{
    // to be called after last addRun() call
    // needed to sort runIDs in the case
    // the container is filled by hand.
    // For standard IO from ASCII,ROOT or ORACLE
    // input not needed!
    sort(fVRunID.begin(),fVRunID.end());
}



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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      HParCond::Streamer(R__b);
      {
         map<Int_t,HStart2CalRunPars*> &R__stl =  fMRunID;
         R__stl.clear();
         TClass *R__tcl2 = TBuffer::GetClass(typeid(class HStart2CalRunPars));
         if (R__tcl2==0) {
            Error("fMRunID streamer","Missing the TClass object for class HStart2CalRunPars !");
            return;
         }
         int R__i, R__n;
         R__b >> R__n;
         for (R__i = 0; R__i < R__n; R__i++) {
            int R__t;
            R__b >> R__t;
            HStart2CalRunPars* R__t2;
            R__t2 = (HStart2CalRunPars*)R__b.ReadObjectAny(R__tcl2);
            typedef int Value_t;
            std::pair<Value_t const, class HStart2CalRunPars * > R__t3(R__t,R__t2);
            R__stl.insert(R__t3);
         }
      }
      {
         vector<Int_t> &R__stl =  fVRunID;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            int R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, HStart2CalRunPar::IsA());
   } else {
      R__c = R__b.WriteVersion(HStart2CalRunPar::IsA(), kTRUE);
      HParCond::Streamer(R__b);
      {
         map<Int_t,HStart2CalRunPars*> &R__stl =  fMRunID;
         int R__n=int(R__stl.size());
         R__b << R__n;
         if(R__n) {
            map<Int_t,HStart2CalRunPars*>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << ((*R__k).first );
            R__b << ((*R__k).second);
            }
         }
      }
      {
         vector<Int_t> &R__stl =  fVRunID;
         int R__n=int(R__stl.size());
         R__b << R__n;
         if(R__n) {
            vector<Int_t>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}