#include "ClassDigitizer2Gen.h"

Digitizer2Gen::Digitizer2Gen(){  
  printf("======== %s \n",__func__);
  Initialization();
}

Digitizer2Gen::~Digitizer2Gen(){
  printf("======== %s \n",__func__);
  if(isConnected ) CloseDigitizer();
}

void Digitizer2Gen::Initialization(){
  printf("======== %s \n",__func__);

  handle = 0;
  ret = 0;
  isConnected = false;
  
  modelName = "";
  cupVersion = "";
  DPPVersion = "";
  DPPType = "";
  serialNumber = 0;
  adcBits = 0;
  nChannels = 0;
  adcRate = 0;
  ch2ns = 0;

  IPAddress = "";
  netMask = "";
  gateway = "";

  outFileIndex = 0;
  dataStartIndetifier = 0xAAA0;
  outFile = NULL;
  outFileSize = 0;

  evt = NULL;

}

//########################################### Handles functions
uint64_t Digitizer2Gen::GetHandle(const char * parameter){
  
  uint64_t par_handle;
  ret = CAEN_FELib_GetHandle(handle, parameter, &par_handle);
  if(ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return 0;
  }
  return par_handle;
  
}

uint64_t Digitizer2Gen::GetParentHandle(uint64_t handle){
  uint64_t par_handle;
  ret = CAEN_FELib_GetParentHandle(handle, NULL, &par_handle);
  if(ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return 0;
  }
  return par_handle;
}

std::string Digitizer2Gen::GetPath(uint64_t handle){
  char path[256];
  ret = CAEN_FELib_GetPath(handle, path);
  if(ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return "Error";
  }
  return path;
  
}

//########################################### Read Write
std::string Digitizer2Gen::ReadValue(const char * parameter){
  if( !isConnected ) return "not connected";
  //printf(" %s|%s \n", __func__, parameter);
  ret = CAEN_FELib_GetValue(handle, parameter, retValue);
  if (ret != CAEN_FELib_Success) return ErrorMsg(__func__);
  return retValue;
}

void Digitizer2Gen::WriteValue(const char * parameter, std::string value){
  if( !isConnected );
  printf(" %s| %-45s : %s\n", __func__, parameter, value.c_str());
  ret = CAEN_FELib_SetValue(handle, parameter, value.c_str());
  if (ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return;
  }
}

void Digitizer2Gen::SendCommand(const char * parameter){
  if( !isConnected );
  printf("Send Command : %s \n", parameter);
  ret = CAEN_FELib_SendCommand(handle, parameter);
  if (ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return;
  }
}

//########################################### Open digitizer
int Digitizer2Gen::OpenDigitizer(const char * url){
  
  printf("======== %s \n",__func__);

  ret = CAEN_FELib_Open(url, &handle);

  printf("===  ret : %d | %d \n", ret, CAEN_FELib_Success);
  
  if (ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return -1;
  }
  
  isConnected = true;

  modelName  = ReadValue("/par/ModelName");
  
  cupVersion = ReadValue("/par/cupver");  
  DPPVersion = ReadValue("/par/FPGA_FwVer");
  DPPType    = ReadValue("/par/FwType");

  serialNumber = atoi(ReadValue("/par/SerialNum").c_str());
  nChannels    = atoi(ReadValue("/par/NumCh").c_str());
  adcBits      = atoi(ReadValue("/par/ADC_Nbit").c_str());  
  adcRate      = atoi(ReadValue("/par/ADC_SamplRate").c_str());
  ch2ns = 1000/adcRate;
  
  IPAddress   = ReadValue("/par/IPAddress");
  netMask     = ReadValue("/par/Netmask");
  gateway     = ReadValue("/par/Gateway");

  printf("   IP address : %s\n", IPAddress.c_str());
  printf("     Net Mask : %s\n", netMask.c_str());
  printf("      Gateway : %s\n", gateway.c_str());
  
  printf("   Model name : %s\n", modelName.c_str());
  printf("  CUP version : %s\n", cupVersion.c_str());
  printf("     DPP Type : %s\n", DPPType.c_str());
  printf("  DPP Version : %s\n", DPPVersion.c_str());
  printf("Serial number : %d\n", serialNumber);
  printf("     ADC bits : %d\n", adcBits);
  printf("     ADC rate : %d Msps, ch2ns : %d ns\n", adcRate, ch2ns);
  printf("     Channels : %d\n", nChannels);


  ///SendCommand("/cmd/reset");

  return 0;
}

int Digitizer2Gen::CloseDigitizer(){
  printf("======== %s \n",__func__);
  ret = CAEN_FELib_Close(handle);
  if (ret != CAEN_FELib_Success) {
    ErrorMsg(__func__);
    return 0;
  }
  isConnected = false;

  return 0;
}

//########################################### DAQ
void Digitizer2Gen::StartACQ(){
  
  SendCommand("/cmd/armacquisition");
  SendCommand("/cmd/swstartacquisition");
    
}

void Digitizer2Gen::StopACQ(){
  
  SendCommand("/cmd/disarmacquisition");
  
}

void Digitizer2Gen::SetPHADataFormat(unsigned short dataFormat){
  
  ///========== get endpoint and endpoint folder handle
  if( dataFormat < 15 ){

    ret  = CAEN_FELib_GetHandle(handle, "/endpoint/dpppha", &ep_handle);
    ret |= CAEN_FELib_GetParentHandle(ep_handle, NULL, &ep_folder_handle);
    ret |= CAEN_FELib_SetValue(ep_folder_handle, "/par/activeendpoint", "dpppha");

    if (ret != CAEN_FELib_Success) {
      ErrorMsg("Set active endpoint");
      return;
    }

  }else{
    ret  = CAEN_FELib_GetHandle(handle, "/endpoint/raw", &ep_handle);
    ret |= CAEN_FELib_GetParentHandle(ep_handle, NULL, &ep_folder_handle);
    ret |= CAEN_FELib_SetValue(ep_folder_handle, "/par/activeendpoint", "raw");
    
    if (ret != CAEN_FELib_Success) {
      ErrorMsg("Set active endpoint");
      return;
    }
  }
  
  evt = new Event();
  evt->SetDataType(dataFormat);
  dataStartIndetifier += dataFormat;

  if( dataFormat == 0 ){  
    ret = CAEN_FELib_SetReadDataFormat(ep_handle, 
    "[ \
      { \"name\" : \"CHANNEL\", \"type\" : \"U8\" }, \
      { \"name\" : \"TIMESTAMP\", \"type\" : \"U64\" }, \
      { \"name\" : \"FINE_TIMESTAMP\", \"type\" : \"U16\" }, \
      { \"name\" : \"TIMESTAMP_NS\", \"type\" : \"U64\" }, \
      { \"name\" : \"ENERGY\", \"type\" : \"U16\" }, \
      { \"name\" : \"ANALOG_PROBE_1\", \"type\" : \"I32\", \"dim\" : 1 }, \
      { \"name\" : \"ANALOG_PROBE_2\", \"type\" : \"I32\", \"dim\" : 1 }, \
      { \"name\" : \"DIGITAL_PROBE_1\", \"type\" : \"U8\", \"dim\" : 1 }, \
      { \"name\" : \"DIGITAL_PROBE_2\", \"type\" : \"U8\", \"dim\" : 1 }, \
      { \"name\" : \"DIGITAL_PROBE_3\", \"type\" : \"U8\", \"dim\" : 1 }, \
      { \"name\" : \"DIGITAL_PROBE_4\", \"type\" : \"U8\", \"dim\" : 1 }, \
      { \"name\" : \"ANALOG_PROBE_1_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"ANALOG_PROBE_2_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"DIGITAL_PROBE_1_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"DIGITAL_PROBE_2_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"DIGITAL_PROBE_3_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"DIGITAL_PROBE_4_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"WAVEFORM_SIZE\", \"type\" : \"SIZE_T\" }, \
      { \"name\" : \"FLAGS_LOW_PRIORITY\", \"type\" : \"U16\"}, \
      { \"name\" : \"FLAGS_HIGH_PRIORITY\", \"type\" : \"U16\" }, \
      { \"name\" : \"TRIGGER_THR\", \"type\" : \"U16\" }, \
      { \"name\" : \"TIME_RESOLUTION\", \"type\" : \"U8\" }, \
      { \"name\" : \"BOARD_FAIL\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"FLUSH\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"AGGREGATE_COUNTER\", \"type\" : \"U32\" }, \
      { \"name\" : \"EVENT_SIZE\", \"type\" : \"SIZE_T\" } \
    ]");
  }

  if( dataFormat == 1 ){
    ret = CAEN_FELib_SetReadDataFormat(ep_handle, 
    "[ \
      { \"name\" : \"CHANNEL\", \"type\" : \"U8\" }, \
      { \"name\" : \"TIMESTAMP\", \"type\" : \"U64\" }, \
      { \"name\" : \"FINE_TIMESTAMP\", \"type\" : \"U16\" }, \
      { \"name\" : \"ENERGY\", \"type\" : \"U16\" }, \
      { \"name\" : \"ANALOG_PROBE_1\", \"type\" : \"I32\", \"dim\" : 1 }, \
      { \"name\" : \"ANALOG_PROBE_1_TYPE\", \"type\" : \"U8\" }, \
      { \"name\" : \"WAVEFORM_SIZE\", \"type\" : \"SIZE_T\" }, \
      { \"name\" : \"FLAGS_LOW_PRIORITY\", \"type\" : \"U16\"}, \
      { \"name\" : \"FLAGS_HIGH_PRIORITY\", \"type\" : \"U16\" }, \
      { \"name\" : \"TRIGGER_THR\", \"type\" : \"U16\" }, \
      { \"name\" : \"TIME_RESOLUTION\", \"type\" : \"U8\" }, \
      { \"name\" : \"BOARD_FAIL\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"FLUSH\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"AGGREGATE_COUNTER\", \"type\" : \"U32\" }, \
      { \"name\" : \"EVENT_SIZE\", \"type\" : \"SIZE_T\" } \
    ]");
  }

  if( dataFormat == 2 ){
    ret = CAEN_FELib_SetReadDataFormat(ep_handle, 
    "[ \
      { \"name\" : \"CHANNEL\", \"type\" : \"U8\" }, \
      { \"name\" : \"TIMESTAMP\", \"type\" : \"U64\" }, \
      { \"name\" : \"FINE_TIMESTAMP\", \"type\" : \"U16\" }, \
      { \"name\" : \"ENERGY\", \"type\" : \"U16\" }, \
      { \"name\" : \"FLAGS_LOW_PRIORITY\", \"type\" : \"U16\"}, \
      { \"name\" : \"FLAGS_HIGH_PRIORITY\", \"type\" : \"U16\" }, \
      { \"name\" : \"TRIGGER_THR\", \"type\" : \"U16\" }, \
      { \"name\" : \"TIME_RESOLUTION\", \"type\" : \"U8\" }, \
      { \"name\" : \"BOARD_FAIL\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"FLUSH\", \"type\" : \"BOOL\" }, \
      { \"name\" : \"AGGREGATE_COUNTER\", \"type\" : \"U32\" }, \
      { \"name\" : \"EVENT_SIZE\", \"type\" : \"SIZE_T\" } \
    ]");
  }

  if( dataFormat == 3 ){
    ret = CAEN_FELib_SetReadDataFormat(ep_handle, 
    "[ \
      { \"name\" : \"CHANNEL\", \"type\" : \"U8\" }, \
      { \"name\" : \"TIMESTAMP\", \"type\" : \"U64\" }, \
      { \"name\" : \"ENERGY\", \"type\" : \"U16\" } \
    ]");
  }

  if( dataFormat == 15 ){
    ret = CAEN_FELib_SetReadDataFormat(ep_handle, 
      " [ \
         { \"name\": \"DATA\",     \"type\": \"U8\", \"dim\": 1 }, \
         { \"name\": \"SIZE\",     \"type\": \"SIZE_T\" }, \
         { \"name\": \"N_EVENTS\", \"type\": \"U32\" } \
      ]"
    );
  }

  if (ret != CAEN_FELib_Success) {
    ErrorMsg("Set Read Data Format");
    return;
  }
}

int Digitizer2Gen::ReadData(){
  //printf("========= %s \n", __func__);

  if( evt->dataType == 0){
    ret = CAEN_FELib_ReadData(ep_handle, 100,
      &evt->channel,
      &evt->timestamp,
      &evt->fine_timestamp,
      &evt->timestamp_ns,
      &evt->energy,
      evt->analog_probes[0],
      evt->analog_probes[1],
      evt->digital_probes[0],
      evt->digital_probes[1],
      evt->digital_probes[2],
      evt->digital_probes[3],
      &evt->analog_probes_type[0],
      &evt->analog_probes_type[1],
      &evt->digital_probes_type[0],
      &evt->digital_probes_type[1],
      &evt->digital_probes_type[2],
      &evt->digital_probes_type[3],
      &evt->traceLenght,
      &evt->flags_low_priority,
      &evt->flags_high_priority,
      &evt->trigger_threashold,
      &evt->downSampling,
      &evt->board_fail,
      &evt->flush,
      &evt->aggCounter,
      &evt->event_size
    );
  }else if( evt->dataType == 1){
    ret = CAEN_FELib_ReadData(ep_handle, 100,
      &evt->channel,
      &evt->timestamp,
      &evt->fine_timestamp,
      &evt->energy,
      evt->analog_probes[0],
      &evt->analog_probes_type[0],
      &evt->traceLenght,
      &evt->flags_low_priority,
      &evt->flags_high_priority,
      &evt->trigger_threashold,
      &evt->downSampling,
      &evt->board_fail,
      &evt->flush,
      &evt->aggCounter,
      &evt->event_size
    );
  }else if( evt->dataType == 2){
    ret = CAEN_FELib_ReadData(ep_handle, 100,
      &evt->channel,
      &evt->timestamp,
      &evt->fine_timestamp,
      &evt->energy,
      &evt->flags_low_priority,
      &evt->flags_high_priority,
      &evt->trigger_threashold,
      &evt->downSampling,
      &evt->board_fail,
      &evt->flush,
      &evt->aggCounter,
      &evt->event_size
    );
  }else if( evt->dataType == 3){
    ret = CAEN_FELib_ReadData(ep_handle, 100,
      &evt->channel,
      &evt->timestamp,
      &evt->energy
    );
  }else if( evt->dataType == 15){
    ret = CAEN_FELib_ReadData(ep_handle, 100, evt->data, &evt->dataSize, &evt->n_events );
    //printf("data size: %lu byte\n", evt.dataSize);
  }else{
    return CAEN_FELib_UNKNOWN;
  }

  return ret;

  if( ret != CAEN_FELib_Success) {
    ErrorMsg("Set Read Data");
    return ret;
  }
}

void Digitizer2Gen::ReadDataRaw(){

}
//###########################################

void Digitizer2Gen::OpenOutFile(std::string fileName){
  outFileNameBase = fileName;
  sprintf(outFileName, "%s_%03d.sol", fileName.c_str(), outFileIndex);
  outFile = fopen(outFileName, "a+");
  fseek(outFile, 0L, SEEK_END);
  outFileSize = ftell(outFile);  // unsigned int =  Max ~4GB

}

void Digitizer2Gen::CloseOutFile(){
  fclose(outFile);
}

void Digitizer2Gen::SaveDataToFile(){

  if( outFileSize > (unsigned int) MaxOutFileSize){
    fclose(outFile);
    outFileIndex ++;
    sprintf(outFileName, "%s_%03d.sol", outFileNameBase.c_str(), outFileIndex);
    outFile = fopen(outFileName, "a+");
  }

  if( evt->dataType == 0){
    fwrite(&dataStartIndetifier, 2, 1, outFile);
    fwrite(&evt->channel, 1, 1, outFile);
    fwrite(&evt->energy, 2, 1, outFile);
    fwrite(&evt->timestamp, 6, 1, outFile);
    fwrite(&evt->fine_timestamp, 2, 1, outFile);
    fwrite(&evt->flags_high_priority, 1, 1, outFile);
    fwrite(&evt->flags_low_priority, 2, 1, outFile);
    fwrite(&evt->downSampling, 1, 1, outFile);
    fwrite(&evt->board_fail, 1, 1, outFile);
    fwrite(&evt->flush, 1, 1, outFile);
    fwrite(&evt->trigger_threashold, 2, 1, outFile);
    fwrite(&evt->event_size, 8, 1, outFile);
    fwrite(&evt->aggCounter, 4, 1, outFile);
    fwrite(&evt->traceLenght, 8, 1, outFile);
    fwrite(evt->analog_probes_type, 2, 1, outFile);
    fwrite(evt->digital_probes_type, 4, 1, outFile);
    fwrite(evt->analog_probes[0], evt->traceLenght*4, 1, outFile);
    fwrite(evt->analog_probes[1], evt->traceLenght*4, 1, outFile);
    fwrite(evt->digital_probes[0], evt->traceLenght, 1, outFile);
    fwrite(evt->digital_probes[1], evt->traceLenght, 1, outFile);
    fwrite(evt->digital_probes[2], evt->traceLenght, 1, outFile);
    fwrite(evt->digital_probes[3], evt->traceLenght, 1, outFile);
  }else if( evt->dataType == 1){
    fwrite(&dataStartIndetifier, 2, 1, outFile);
    fwrite(&evt->channel, 1, 1, outFile);
    fwrite(&evt->energy, 2, 1, outFile);
    fwrite(&evt->timestamp, 6, 1, outFile);
    fwrite(&evt->fine_timestamp, 2, 1, outFile);
    fwrite(&evt->flags_high_priority, 1, 1, outFile);
    fwrite(&evt->flags_low_priority, 2, 1, outFile);
    fwrite(&evt->traceLenght, 8, 1, outFile);
    fwrite(&evt->analog_probes_type[0], 1, 1, outFile);
    fwrite(evt->analog_probes[0], evt->traceLenght*4, 1, outFile);
  }else if( evt->dataType == 2){
    fwrite(&dataStartIndetifier, 2, 1, outFile);
    fwrite(&evt->channel, 1, 1, outFile);
    fwrite(&evt->energy, 2, 1, outFile);
    fwrite(&evt->timestamp, 6, 1, outFile);
    fwrite(&evt->fine_timestamp, 2, 1, outFile);
    fwrite(&evt->flags_high_priority, 1, 1, outFile);
    fwrite(&evt->flags_low_priority, 2, 1, outFile);
  }else if( evt->dataType == 3){
    fwrite(&dataStartIndetifier, 2, 1, outFile);
    fwrite(&evt->channel, 1, 1, outFile);
    fwrite(&evt->energy, 2, 1, outFile);
    fwrite(&evt->timestamp, 6, 1, outFile);
  }else if( evt->dataType == 15){
    fwrite(&dataStartIndetifier, 2, 1, outFile);
    fwrite(&evt->dataSize, 8, 1, outFile);
    fwrite(evt->data, evt->dataSize, 1, outFile);
  }
  
  outFileSize = ftell(outFile);  // unsigned int =  Max ~4GB

}


//###########################################
void Digitizer2Gen::ProgramPHA(bool testPulse){
  if( !isConnected ) return ;

  // Channel enable  
  WriteValue("/ch/0..63/par/ChEnable"  , "true");
  
  // Global trigger configuration
  if( testPulse ) {
    WriteValue("/par/GlobalTriggerSource", "SwTrg | TestPulse");
  }else{
    WriteValue("/par/GlobalTriggerSource", "SwTrg");
  }
  WriteValue("/par/TestPulsePeriod"    , "500000"); // 0.5 msec = 2kHz
  WriteValue("/par/TestPulseWidth"     , "16");
  
  // Wave configuration
  WriteValue("/ch/0..63/par/WaveTriggerSource" , "GlobalTriggerSource");
  WriteValue("/ch/0..63/par/ChRecordLengthS"   , "512");
  WriteValue("/ch/0..63/par/ChPreTriggerS"     , "100");
  WriteValue("/ch/0..63/par/WaveResolution"    , "RES8");  /// 8 ns 
  WriteValue("/ch/0..63/par/WaveAnalogProbe0"  , "ADCInput");
  WriteValue("/ch/0..63/par/WaveAnalogProbe1"  , "EnergyFilter");
  WriteValue("/ch/0..63/par/WaveDigitalProbe0" , "Trigger");
  WriteValue("/ch/0..63/par/WaveDigitalProbe1" , "TimeFilterArmed");
  WriteValue("/ch/0..63/par/WaveDigitalProbe2" , "EnergyFilterPeaking");
  WriteValue("/ch/0..63/par/WaveDigitalProbe3" , "EnergyFilterPeakReady");

  // Event configuration
  WriteValue("/ch/0..63/par/EventTriggerSource", "GlobalTriggerSource");
  
  // Filter parameters
  WriteValue("/ch/0..63/par/TimeFilterRiseTimeS"         , "10");
  WriteValue("/ch/0..63/par/TriggerThr"                  , "100");
  WriteValue("/ch/0..63/par/PulsePolarity"               , "Positive");
  WriteValue("/ch/0..63/par/EnergyFilterBaselineAvg"     , "Medium");
  WriteValue("/ch/0..63/par/EnergyFilterFineGain"        , "1.0");

  WriteValue("/ch/0..63/par/EnergyFilterRiseTimeS"       , "100");
  WriteValue("/ch/0..63/par/EnergyFilterFlatTopS"        , "100");
  WriteValue("/ch/0..63/par/EnergyFilterPoleZeroS"       , "1000");

  WriteValue("/ch/0..63/par/EnergyFilterPeakingPosition" , "80");

  WriteValue("/ch/0..63/par/TimeFilterRetriggerGuardS"   , "10");
  WriteValue("/ch/0..63/par/EnergyFilterPileupGuardT"    , "10");
  WriteValue("/ch/0..63/par/EnergyFilterBaselineGuardS"  , "100");

  WriteValue("/ch/0..63/par/EnergyFilterLFLimitation"    , "Off");
  
}

std::string Digitizer2Gen::ErrorMsg(const char * funcName){
  printf("======== %s | %s\n",__func__, funcName);
  char msg[1024];
  int ec = CAEN_FELib_GetLastError(msg);
  if (ec != CAEN_FELib_Success) {
    std::string errMsg = __func__;
    errMsg += " failed";
    printf("%s failed\n", __func__);
    return errMsg;
  }
  printf("last error: %s\n", msg);
  return msg;
}