#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 = "";

}

//########################## 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);
  
  
  ///========== get endpoint and endpoint folder handle
  ret = CAEN_FELib_GetHandle(handle, "/endpoint/dpppha", &ep_handle);
  if (ret != CAEN_FELib_Success) {
    ErrorMsg("Get Handle");
    return -2;
  }
  
  ret = CAEN_FELib_GetParentHandle(ep_handle, NULL, &ep_folder_handle);
  if (ret != CAEN_FELib_Success) {
    ErrorMsg("GetParentHandle");
    return -3;
  }

  ///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(){
  
  ret = CAEN_FELib_SetValue(ep_folder_handle, "/par/activeendpoint", "dpppha");
  if (ret != CAEN_FELib_Success) {
    ErrorMsg("Set active endpoint");
    return;
  }
  
  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_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\" : \"EVENT_SIZE\", \"type\" : \"SIZE_T\" } \
  ] \
  ");
  if (ret != CAEN_FELib_Success) {
    ErrorMsg("Set Read Data Format");
    return;
  }
}

struct event {
  uint8_t  channel;
  uint64_t timestamp;
  double   timestamp_us;
  uint16_t fine_timestamp;
  uint16_t energy;
  uint16_t flags_low_priority;
  uint16_t flags_high_priority;
  size_t   event_size;
  int32_t* analog_probes[2];
  uint8_t* digital_probes[4];
  uint8_t  analog_probes_type[2];
  uint8_t  digital_probes_type[4];
  size_t   n_allocated_samples;
  size_t   n_samples;
};

void Digitizer2Gen::ReadData(){
  printf("========= %s \n", __func__);
  
  event evt;
  
  ret = CAEN_FELib_ReadData(ep_handle, 100,
    evt.channel,
    evt.timestamp,
    evt.fine_timestamp,
    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.n_samples,
    evt.flags_low_priority,
    evt.flags_high_priority,
    evt.event_size
  );
  
  if( ret != CAEN_FELib_Success) {
    ErrorMsg("Set Read Data");
    return;
  }
}

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

  // Channel enable  
  WriteValue("/ch/0..63/par/ChEnable"  , "true");
  
  // Global trigger configuration
  ///WriteValue("/par/GlobalTriggerSource", "SwTrg");
  WriteValue("/par/GlobalTriggerSource", "SwTrg | TestPulse");
  WriteValue("/par/TestPulsePeriod"    , "100000000");
  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"  , "TimeFilter");
  WriteValue("/ch/0..63/par/WaveDigitalProbe0" , "Trigger");
  WriteValue("/ch/0..63/par/WaveDigitalProbe1" , "TimeFilterArmed");
  WriteValue("/ch/0..63/par/WaveDigitalProbe2" , "EnergyFilterBaselineFreeze");
  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"                  , "3");
  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;
}