// ---------------------------------------------------------------------
// -----              KrattaSlowControl source file                -----
// -----            Created 10/11/13  by P. Pawlowski              -----
// ---------------------------------------------------------------------


#include "KrattaSlowControl.hxx"
#include <cstring>

//ClassImp(KrattaRunFactors)

   KrattaRunFactors::KrattaRunFactors(int run_min, int run_max):
      RunMin(run_min),
      RunMax(run_max),
      RunNumber(RunMax - RunMin + 1),
      Factor(new double[RunNumber])
    {
      memset(Factor,0,RunNumber*sizeof(double));
    }

    KrattaRunFactors::~KrattaRunFactors(){
      delete Factor;
    }

    double KrattaRunFactors::GetFactor(int irun){
      if(OutOfRange(irun)) return 0;
       return Factor[irun - RunMin];
    }

    void KrattaRunFactors::SetFactor(int irun, double f){
      if(OutOfRange(irun)) return;
       Factor[irun - RunMin] = f;
    }

    void KrattaRunFactors::DumpFactors(void * x, int run_min, int run_max){
      if(!run_min) run_min = RunMin;
      if(!run_max) run_max = RunMax;

      size_t size = (run_max - run_min + 1)*sizeof(double);
       memcpy(x,&Factor[run_min - RunMin],size);
    }

    void KrattaRunFactors::LoadFactors(void * x, int run_min, int run_max){
      if(!run_min) run_min = RunMin;
      if(!run_max) run_max = RunMax;
      size_t size = (run_max - run_min + 1)*sizeof(double);
      memcpy(&Factor[run_min - RunMin],x,size);
    }

    size_t KrattaRunFactors::Read(FILE * f){
     return fread(Factor,RunNumber*sizeof(double),1,f);
    }

    size_t KrattaRunFactors::Write(FILE * f){
     return fwrite(Factor,RunNumber*sizeof(double),1,f);
    }

//ClassImp(KrattaSlowControl)

KrattaSlowControl::KrattaSlowControl(int run_min, int run_max):RunMin(run_min), RunMax(run_max){
      for(int ipar=0; ipar< KrattaFactorNumber;  ipar++)
	for(int imod=0; imod< KrattaModuleNumber;  imod++)
	  factors[ipar][imod] = new KrattaRunFactors(RunMin, RunMax);
  }
      KrattaSlowControl::KrattaSlowControl(const char * filename){
	FILE * file= fopen(filename, "rb");
	if(!file) {
	  printf("[KrattaSlowControl:] Cannot open file %s\n",filename);
	  exit(1);
	}
	size_t freadReturnValue = fread(&RunMin, sizeof(RunMin), 1, file);
  if ( freadReturnValue == 0){
   /// error occured
   printf("[KrattaSlowControl:] fread function failed (for %s), return value= %ld\n",filename, freadReturnValue);
  }
  freadReturnValue = fread(&RunMax, sizeof(RunMax), 1, file);
	if ( freadReturnValue == 0){
   /// error occured 
   printf("[KrattaSlowControl:] fread function failed (for %s), return value= %ld\n",filename, freadReturnValue);
  }
  for(int ipar=0; ipar< KrattaFactorNumber;  ipar++)
	  for(int imod=0; imod< KrattaModuleNumber;  imod++){
	    factors[ipar][imod] = new KrattaRunFactors(RunMin, RunMax);
	    factors[ipar][imod]->Read(file);
	  }
	  fclose(file);
      }

    KrattaSlowControl::~KrattaSlowControl(){
      for(int ipar=0; ipar< KrattaFactorNumber;  ipar++)
	for(int imod=0; imod< KrattaModuleNumber;  imod++)
	  delete factors[ipar][imod];
    }


      void KrattaSlowControl::SaveAs(const char * filename){
	FILE * file= fopen(filename , "wb");
	if(!file) {
	  printf("[KrattaSlowControl:] Cannot write to file %s\n",filename);
	  return;
	}
	fwrite(&RunMin, sizeof(RunMin), 1, file);
	fwrite(&RunMax, sizeof(RunMax), 1, file);
	for(int ipar=0; ipar< KrattaFactorNumber;  ipar++)
	  for(int imod=0; imod< KrattaModuleNumber;  imod++)
	    factors[ipar][imod]->Write(file);
      }

    double KrattaSlowControl::GetFactor(KrattaSignal  type, int module, int run){
      if(module<0 || module > KrattaModuleNumber) return 0;
      return factors[type][module]->GetFactor(run);
    }

    void KrattaSlowControl::SetFactor(KrattaSignal type, int module, int run, double f){
      if(module<0 || module > KrattaModuleNumber) return;
      factors[type][module]->SetFactor(run, f);
    }

    void KrattaSlowControl::LoadFactors(KrattaSignal  type, int module, void * x, int run_min, int run_max){
      if(module<0 || module > KrattaModuleNumber) return;
     factors[type][module]->LoadFactors(x, run_min, run_max);
    }

    void KrattaSlowControl::DumpFactors(KrattaSignal  type, int module, void * x, int run_min, int run_max){
      if(module<0 || module > KrattaModuleNumber) return;
      factors[type][module]->DumpFactors(x, run_min, run_max);
    }