//
//
//
// purpose: Establish connection to online_ccdb, read current values
//          of the DAC settings for each ADC125 channel of each FDC
//          Crate (identified by ROC number). It also read for each
//          channel the sigma of the pedestal and calculates a sparsification
//          factor based on the sparsification factor.
//          SPARSIFICATIONVALUE_i = SIGMA_i * SPARSIFICATIONFACTOR
//          i = ROC/SLOT/CHANNEL 
//
//          protection agains runaway DAC values is included.
//         
//          online_ccdb tables: XXX = FDC or CDC
//                             /XXX/dac_values  row for each channel
//                             /XXX/baseline    single row for all channels
//
//


//#include <CCDB/Calibration.h>
//#include <CCDB/MySQLCalibration.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <memory>
#include <stdlib.h>
#include "ccdb_main.hxx"

extern "C" {
#include "ccdb_inc.h"
#include <ctype.h>
}

extern int Thresholds[20][72];
extern int DAC_Values[20][72];

extern int FA125ReadOutMode;
extern int FA125Latency;
extern int FA125WindowSize;
extern int FA125NSB;
extern int FA125NSA;
extern int FA125NP;

int DACDefault;

string create_connection_string()
{
	/* creates example connection string to ccdb demo sqlite database*/
	string ccdb_home(getenv("CCDB_CONNECTION"));
	return ccdb_home;
}

void init_DACValues(int val){

	for (int k=0;k<20;k++){
		for (int j=0;j<72;j++){
			Thresholds[k][j] = 100;
			DAC_Values[k][j] = val;      
		}
	}

}

void set_DAC_Defaults(char *detector){

	DACDefault = FDCDACDefault;
	if (toupper(detector[0]) == 'C'){
		DACDefault = CDCDACDefault;
	}

	init_DACValues(DACDefault);

}


int GetDACfromdatabase(int ROC, char *detector){

	// retrieve configuration data for this particular ROC from data base
	// returns number of ADCs in this crate and fills the arrays DAC_Values[slots][channels]
	// and Thresholds[slot][channels]

	int NADCS = 0 ;
	char DET[128];
	DACDefault = FDCDACDefault;
	if (toupper(detector[0]) == 'C'){
		sprintf(DET,"CDC");
		DACDefault = CDCDACDefault;
	} else {
		sprintf(DET,"FDC");
	}

	MySQLCalibration *calib = new MySQLCalibration(100);

	string connection_str = create_connection_string();    
	if (!connection_str.size()) {
		cout<<"ERROR: CCDB_CONNECTION not defined!"<<endl;
		return -1;
	}

	//connect
	int result = calib->Connect(connection_str);
	if (!result) {
		cout<<"ERROR: CCDB connection failed!"<<endl;
		return -2;
	}

	// get data for crate configuration
	// how many ADCs are in this crate
	vector < vector <double> > crate;
	char table[128];
	sprintf(table, "/%s/crate_setup",DET);
	calib->GetCalib(crate, table);
	for(int row = 0; row < crate.size(); row++) {
		int R  = (int) crate[row][0];
		if (R==ROC) {
			NADCS =  (int) crate[row][1];
		} 
	}

	// get data for base line
	// what is the target baseline and the multiplication factor for the sigma (ped width)  
	vector < vector <double> > bl;
	table[128];
	sprintf(table, "/%s/baseline",DET);
	calib->GetCalib(bl, table);

	double targetbaseline = bl[0][0];
	double baselinefactor = bl[0][1];
	double sparsificationfactor = bl[0][2]; // needed to calculate threshold=baseline+this*ped_width



	// get common timing thresholds for the timing alorithm
	// this is required with the new firmware of the fadc125
	vector < vector <double> > thresh;
	table[128];
	sprintf(table, "/%s/common_timing_thresholds",DET);
	calib->GetCalib(bl, table);
	int LowTimingThreshold  = (int)bl[0][0];
	int HighTimingThreshold = (int)bl[0][1];


	// scale factors for the Integral, Amplitude and Pedestal
	vector < vector <double> > scales;
	table[128];
	sprintf(table, "/%s/scale_factors",DET);
	calib->GetCalib(bl, table);
	int IBIT = (int)bl[0][0];
	int ABIT = (int)bl[0][1];
	int PBIT = (int)bl[0][2];

	// get data for DAC values
	vector < vector <double> > data;
	sprintf(table, "/%s/dac_values",DET);
	calib->GetCalib(data, table);

	if (data.size()<1){
		init_DACValues(DACDefault);
	} else {
		cout<<"Database table "<<table <<" found!"<<endl;
	}

	for(int row = 0; row < data.size(); row++) {

		int R = (int) data[row][0];

		if (R==ROC) {

			int slot = (int)data[row][1];
			int ch = (int)data[row][2];
			if (slot>10){
				slot -= 5;
			} else {
				slot -= 3;
			}
			int DACValue = (int) data[row][4];
			if ((DACValue<1000) || (DACValue>DACDefault)){
				DACValue = DACDefault;
			}      
			DAC_Values[slot][ch] = DACValue;


			int bl = (int) data[row][5]; 

			double sig = data[row][6];
			Thresholds[slot][ch] = (int)(sparsificationfactor*sig +0.5);
			
			if (Thresholds[slot][ch]<HighTimingThreshold){
			  Thresholds[slot][ch] = HighTimingThreshold+10;
			}
		}
	}

	return NADCS;
}


int GetCrateConfigfromdatabase(int ROC, char *detector){

	// reads crate configuraion for this roc
	// returns number of ADCs in this crate

	int NADCS = 0 ;
	char DET[128];
	if (toupper(detector[0]) == 'C'){
		sprintf(DET,"CDC");
	} else {
		sprintf(DET,"FDC");
	}

	MySQLCalibration *calib = new MySQLCalibration(100);

	string connection_str = create_connection_string();    
	if (!connection_str.size()) {
		cout<<"ERROR: CCDB_CONNECTION not defined!"<<endl;
		return -1;
	}

	//connect
	int result = calib->Connect(connection_str);
	if (!result) {
		cout<<"ERROR: CCDB connection failed!"<<endl;
		return -2;
	}

	// get data for crate configuration
	vector < vector <double> > crate;
	char table[128];
	sprintf(table, "/%s/crate_setup",DET);
	calib->GetCalib(crate, table);
	for(int row = 0; row < crate.size(); row++) {
		int R  = (int) crate[row][0];
		if (R==ROC) {
			NADCS =  (int) crate[row][1];
		} 
	}

	return NADCS;
}


int GetReadOutConfigfromdatabase(char *detector){

	// reads the parameters of the ADC configuration for the detector
	// this is valid for all ROC containing ADCs of the detector
	// retreives readoutmode, latency, windowsize, NSB, NSA and NP
	// and returns readout mode

	int NADCS = 0 ;
	char DET[128];
	if (toupper(detector[0]) == 'C'){
		sprintf(DET,"CDC");
	} else {
		sprintf(DET,"FDC");
	}

	MySQLCalibration *calib = new MySQLCalibration(100);

	string connection_str = create_connection_string();    
	if (!connection_str.size()) {
		cout<<"ERROR: CCDB_CONNECTION not defined!"<<endl;
		return -1;
	}

	//connect
	int result = calib->Connect(connection_str);
	if (!result) {
		cout<<"ERROR: CCDB connection failed!"<<endl;
		return -2;
	}

	// get data for crate configuration
	vector < vector <double> > RO_config;
	char table[128];
	sprintf(table, "/%s/readout_config",DET);
	calib->GetCalib(RO_config, table);
	FA125ReadOutMode = (int) RO_config[0][0];
	FA125Latency  = (int) RO_config[0][1];
	FA125WindowSize = (int) RO_config[0][2];
	FA125NSB = (int) RO_config[0][3];
	FA125NSA = (int) RO_config[0][4];
	FA125NP = (int) RO_config[0][5];


	return FA125ReadOutMode;
}
// ==========================================================
// **********************************************************
//
// start of class DetectorReadoutConfig 
// Member function definitions
//
// **********************************************************
// ==========================================================

void DetectorReadoutConfig::InitDACValues(){
  
  for (int ROC=0;ROC<20;ROC++){
    for (int slot=0;slot<20;slot++){
      for (int ch=0;ch<ADC_Channels;ch++){
	FADC125_DAC_VALUES[ROC][slot][ch] = DACDefault;
	FADC125_THRESHOLD_VALUES[ROC][slot][ch] = 0;    
      }
    }
  }
  
}


DetectorReadoutConfig::DetectorReadoutConfig(const string DN, 
					     const string R, 
					     const string V, 
					     const string D,
					     const string S){
  
  sprintf(DetectorName,"%s",DN.c_str());
  sprintf(RunVal,"%s",R.c_str());
  sprintf(Variation,"%s",V.c_str());
  sprintf(Date,"%s",D.c_str());
  sprintf(Suffix,"%s",S.c_str());

  // convert DetectorName to all upper case characters
  for (int i=0; i<strlen(DetectorName); i++){
    DetectorName[i] = toupper(DetectorName[i]);
  }
  
  string DeTector(DetectorName); // string used to determine Detector Type
  
  if ( (DeTector.find("CDC") != string::npos) ||
       (DeTector.find("FDC") != string::npos) ){
    //cout<<"Detector "<<DetectorName<<" is supported"<<endl;
    ADC_Type = 2; // ADC type is FA125
    ADC_Channels = FA125Channels;
    if (DeTector.find("CDC") != string::npos) {
      DetectorIndex = 1;
      DACDefault = CDCDACDefault;
      Has_TDCs = 0;
    } else if (DeTector.find("FDC") != string::npos)  {
      DetectorIndex = 2;
      DACDefault = FDCDACDefault;
      Has_TDCs = 1;
    }
    
    
  } else {
    cout<<"Detector "<<DetectorName<<" is NOT supported"<<endl;
    calibDB = NULL;
    return;
  }
  
  
  calibDB = new MySQLCalibration(100);
  
  string connection_str = create_connection_string();    
  if (!connection_str.size()) {
    cout<<"ERROR: CCDB_CONNECTION not defined!"<<endl;
    calibDB = NULL;
    return;
  }
  
  //connect
  int result = calibDB->Connect(connection_str);
  if (!result) {
    cout<<"ERROR: CCDB connection failed!"<<endl;
    calibDB = NULL;
    return;
  }

  char specifics[128];
  sprintf(specifics,":%s:%s:%s",RunVal,Variation,Date);
  
  // get data for fa125 configuration
  vector < vector <double> > RO_config;
  char table[128];
  sprintf(table, "/%s/readout_config%s",DetectorName,specifics);

  calibDB->GetCalib(RO_config, table);
  FA125_MODE = (int) RO_config[0][0];
  FA125_W_OFFSET  = (int) RO_config[0][1];
  FA125_W_WIDTH = (int) RO_config[0][2];
  FA125_NSB = (int) RO_config[0][3];
  FA125_NSA = (int) RO_config[0][4];
  FA125_NPEAK = (int) RO_config[0][5];
  
  
  // get crate configuration
  vector < vector <double> > crate;
  table[128];
  sprintf(table, "/%s/crate_setup%s",DetectorName,specifics);
  calibDB->GetCalib(crate, table);
  
  if (DetectorIndex == 1) {
    NumberOfCrates = crate.size();
    for(int row = 0; row < NumberOfCrates; row++) {
      DetectorROCNumber[row] = (int) crate[row][0];
      DetectorCrateModules[row] = (int) crate[row][1];
    }
  } else if (DetectorIndex == 2) {
    NumberOfCrates = crate.size() - 4; // only counting fadc crates
    int idx =0;
    for(int row = 1; row < NumberOfCrates+2; row++) {
      if (row!=3){
	DetectorROCNumber[idx] = (int) crate[row][0];
	DetectorCrateModules[idx++] = (int) crate[row][1];
      }
    }
    
  }
  
  // get data for base line determination
  vector < vector <double> > bl;
  table[128];
  sprintf(table, "/%s/baseline%s",DetectorName,specifics);
  calibDB->GetCalib(bl, table);
  
  FADC125_TARGET_BASELINE = (int) bl[0][0];
  FADC125_THRESHOLD_FACTOR = (float) bl[0][2];
  
  // get common timing thresholds for the timing alorithm
  // this is required with the new firmware of the fadc125
  vector < vector <double> > thresh;
  table[128];
  sprintf(table, "/%s/common_timing_thresholds%s",DetectorName,specifics);
  calibDB->GetCalib(bl, table);
  int LowTimingThreshold  = (int)bl[0][0];
  int HighTimingThreshold = (int)bl[0][1];

  FADC125_COMMON_LTT = LowTimingThreshold;
  FADC125_COMMON_HTT = HighTimingThreshold;

  // scale factors for the Integral, Amplitude and Pedestal
  vector < vector <double> > scales;
  table[128];
  sprintf(table, "/%s/scale_factors%s",DetectorName,specifics);
  calibDB->GetCalib(bl, table);
  FADC125_IBIT = (int)bl[0][0];
  FADC125_ABIT = (int)bl[0][1];
  FADC125_PBIT = (int)bl[0][2];

  // get DAC values and determine sparsification thresholds
  vector < vector <double> > data;
  sprintf(table, "/%s/dac_values%s",DetectorName,specifics);
  //cout<<"read table "<<table<<endl;
  calibDB->GetCalib(data, table);
  
  if (data.size()<1){
    InitDACValues();
  } 
  
  for(int row = 0; row < data.size(); row++) {
    
    int ROC = (int) data[row][0];
    if (DetectorIndex == 2) {
      ROC -= 2;
      if (ROC>2){
	ROC -= 1; 
      }
    } else if (DetectorIndex == 1) {
      ROC -= 1;
    }
    int slot = (int)data[row][1];
    int ch = (int)data[row][2];
    if (slot>10){
      slot -= 5;
    } else {
      slot -= 3;
    }
    int DACValue = (int) data[row][4];
    if ((DACValue<1000) || (DACValue>DACDefault)){
      DACValue = DACDefault;
    }      
    FADC125_DAC_VALUES[ROC][slot][ch] = DACValue;
    
    float bl = (float) data[row][5]; 
    float sig = (float) data[row][6];
    
    FADC125_BASELINE_VALUES[ROC][slot][ch] = bl;
    FADC125_SIGMA_VALUES[ROC][slot][ch] = sig;
    
    int Threshold = int (FADC125_THRESHOLD_FACTOR*sig + 0.5);
    if (Threshold< FADC125_COMMON_HTT){
      Threshold = FADC125_COMMON_HTT + 10;
    }
    FADC125_THRESHOLD_VALUES[ROC][slot][ch] = Threshold;    
  }
}

void DetectorReadoutConfig::Convert2Lower(char* str){
  
  int len = strlen(str);
  for (int k=0; k<len; k++){
    str[k] = tolower(str[k]);
  }
  
}


void DetectorReadoutConfig::Print(int OFS, int DACOnly){
  
  
  cout<<"# Detector Readout Configuration: "<<DetectorName<<endl<<endl;;
  cout<<"DACOnly = " << DACOnly << endl;
  stringstream CreateStream[20];
  
  // generate print outs for each crate separately to stream OFS
  for (int k=0; k<NumberOfCrates; k++){
    
    int ROCID = k;
    if (DetectorIndex == 2) {
      ROCID +=2;
      if (ROCID>3){
	ROCID += 1;
      }
    } else if (DetectorIndex == 1) {
      ROCID +=1;
    }
    char RocName[128];
    sprintf(RocName,"ROC%s%d",DetectorName,ROCID);
    Convert2Lower(RocName);
    
    CreateStream[k]<<endl<<"################"<<endl<<"CRATE    "<<RocName<<endl<<"################"<<endl<<endl;
    
    for (int slot=0; slot<DetectorCrateModules[k]; slot++){
      
      int SLOT = slot+3;
      if (SLOT>10){
	SLOT+=2;
      }
      CreateStream[k]<<endl<<"################"<<endl<<"FADC125_SLOTS   "<<SLOT<<endl<<"################"<<endl<<endl;
      
      // print out DAC values
      for (int ch=0; ch<ADC_Channels; ch++){ 
	
	if (!(ch%18)){
	  CreateStream[k]<<endl;
	  char name[128];
	  sprintf(name,"FADC125_DAC_CH_%02d_%02d   ",ch,ch+17);
	  CreateStream[k]<<name;
	}
	CreateStream[k]<<"  "<<  FADC125_DAC_VALUES[k][slot][ch];
	
      }
      CreateStream[k]<<endl<<endl;
      
      // print out Thresholds
      for (int ch=0; ch<ADC_Channels; ch++){ 
	
	if (!(ch%18)){
	  CreateStream[k]<<endl;
	  char name[128];
	  sprintf(name,"FADC125_THR_CH_%02d_%02d   ",ch,ch+17);
	  CreateStream[k]<<name;
	}
	CreateStream[k]<<"  "<<  FADC125_THRESHOLD_VALUES[k][slot][ch];
	
      }
      CreateStream[k]<<endl<<endl;
      
      // print out Baselines
      for (int ch=0; ch<ADC_Channels; ch++){ 
	
	if (!(ch%18)){
	  CreateStream[k]<<endl;
	  char name[128];
	  sprintf(name,"FADC125_BL_CH_%02d_%02d   ",ch,ch+17);
	  CreateStream[k]<<name;
	}
	CreateStream[k]<<"  "<< std::fixed << std::setprecision(2) << FADC125_BASELINE_VALUES[k][slot][ch];
	
      }
      CreateStream[k]<<endl<<endl;
      
      // print out Baselines
      for (int ch=0; ch<ADC_Channels; ch++){ 
	
	if (!(ch%18)){
	  CreateStream[k]<<endl;
	  char name[128];
	  sprintf(name,"FADC125_SIG_CH_%02d_%02d   ",ch,ch+17);
	  CreateStream[k]<<name;
	}
	CreateStream[k]<<"  "<<  FADC125_SIGMA_VALUES[k][slot][ch];
	
      }
      CreateStream[k]<<endl<<endl;
      
      // channels to be disabled for this modle
      CreateStream[k] << "FADC125_CH_ENB   0xFFFFFF  0xFFFFFF  0xFFFFFF"  <<endl<<endl;
      CreateStream[k] << "FADC125_CH_DIS   0x0  0x0  0x0"  <<endl<<endl;

      // common thresholds for timing alorithm
      CreateStream[k] << "FADC125_COMMON_LTT  "<<FADC125_COMMON_LTT<<endl;
      CreateStream[k] << "FADC125_COMMON_HTT  "<<FADC125_COMMON_HTT<<endl;

      
    } // end of loop over modules
    
    { // add multiplication factor
      char name[128];
      sprintf(name, "FADC125_FACTOR   %d", FADC125_THRESHOLD_FACTOR);
    }
    
    if (OFS == 0){
      string SP = PrintADCMode(); // common to the Crate 
      cout<<SP;
      cout<<CreateStream[k].rdbuf();	
    } else{	
      string SP = PrintADCMode();   // common to the Crate   
      char fnam[128];
      // files are written to local directory "./config" with hard coded file names
      sprintf(fnam,"config/%s_fadc125_%s.cnf",RocName,Suffix); 
      ofstream OFile;
      OFile.open(fnam);
      if(DACOnly == 1){
	//cout << "Printing Crate Setup" << endl;
	OFile<<SP;
      }
      //cout << "Printing DAC and THR" << endl;
      OFile<<CreateStream[k].rdbuf();
      OFile.close();
    }
    
  }
  
}

string DetectorReadoutConfig::PrintADCMode(){
  
  stringstream S1;
  
  if (ADC_Type == 2) {
    
    S1<<"FA125_MODE       "<< FA125_MODE <<endl;
    S1<<"FA125_W_OFFSET   "<< FA125_W_OFFSET <<endl;
    S1<<"FA125_W_WIDTH    "<< FA125_W_WIDTH <<endl; 
    S1<<"FA125_NSB        "<< FA125_NSB <<endl;  
    S1<<"FA125_NSA        "<< FA125_NSA <<endl;  
    S1<<"FA125_NPEAK      "<< FA125_NPEAK <<endl;
    S1<<"FA125_THRESHOLD_FACTOR      "<< FADC125_THRESHOLD_FACTOR <<endl;

    S1<<"FADC125_IBIT     "<< FADC125_IBIT <<endl;  
    S1<<"FADC125_ABIT     "<< FADC125_ABIT <<endl;  
    S1<<"FADC125_PBIT     "<< FADC125_PBIT <<endl;  

  } else if (ADC_Type == 1) {
    
    S1<<"FA250_MODE       "<< FA250_MODE <<endl;
    S1<<"FA250_W_OFFSET   "<< FA250_W_OFFSET <<endl;
    S1<<"FA250_W_WIDTH    "<< FA250_W_WIDTH <<endl; 
    S1<<"FA250_NSB        "<< FA250_NSB <<endl;  
    S1<<"FA250_NSA        "<< FA250_NSA <<endl;  
    S1<<"FA250_NPEAK      "<< FA250_NPEAK <<endl;
    
  }
  
  return S1.str();
  
}

// NOTE: the following is not save programing AT ALL!!!!!
void DetectorReadoutConfig::GetVariation(char *c){
  sprintf(c,"%s",Variation);
  return;
}
void DetectorReadoutConfig::GetDate(char *c){
  sprintf(c,"%s",Date);
  return;
}
void DetectorReadoutConfig::GetRunVal(char *c){
  sprintf(c,"%s",RunVal);
  return;
}
void DetectorReadoutConfig::GetSuffix(char *c){
  sprintf(c,"%s",Suffix);
  return;
}