#include "ToString.h"
#include "network_utils.h"

namespace sls {

std::string ToString(const slsDetectorDefs::ROI &roi) {
    std::ostringstream oss;
    oss << '[' << roi.xmin << ", " << roi.xmax << ']';
    return oss.str();
}

std::ostream &operator<<(std::ostream &os, const slsDetectorDefs::ROI &roi) {
    return os << ToString(roi);
}

std::string ToString(const slsDetectorDefs::rxParameters &r) {
    std::ostringstream oss;
    oss << '[' << "detType:" << r.detType << std::endl
        << "numberOfDetector.x:" << r.numberOfDetector.x << std::endl
        << "numberOfDetector.y:" << r.numberOfDetector.y << std::endl
        << "moduleId:" << r.moduleId << std::endl
        << "hostname:" << r.hostname << std::endl
        << "udpInterfaces:" << r.udpInterfaces << std::endl
        << "udp_dstport:" << r.udp_dstport << std::endl
        << "udp_dstip:" << sls::IpAddr(r.udp_dstip) << std::endl
        << "udp_dstmac:" << sls::MacAddr(r.udp_dstmac) << std::endl
        << "udp_dstport2:" << r.udp_dstport2 << std::endl
        << "udp_dstip2:" << sls::IpAddr(r.udp_dstip2) << std::endl
        << "udp_dstmac2:" << sls::MacAddr(r.udp_dstmac2) << std::endl
        << "frames:" << r.frames << std::endl
        << "triggers:" << r.triggers << std::endl
        << "bursts:" << r.bursts << std::endl
        << "analogSamples:" << r.analogSamples << std::endl
        << "digitalSamples:" << r.digitalSamples << std::endl
        << "expTimeNs:" << r.expTimeNs << std::endl
        << "periodNs:" << r.periodNs << std::endl
        << "subExpTimeNs:" << r.subExpTimeNs << std::endl
        << "subDeadTimeNs:" << r.subDeadTimeNs << std::endl
        << "activate:" << r.activate << std::endl
        << "quad:" << r.quad << std::endl
        << "dynamicRange:" << r.dynamicRange << std::endl
        << "timMode:" << r.timMode << std::endl
        << "tenGiga:" << r.tenGiga << std::endl
        << "roMode:" << r.roMode << std::endl
        << "adcMask:" << r.adcMask << std::endl
        << "adc10gMask:" << r.adc10gMask << std::endl
        << "roi.xmin:" << r.roi.xmin << std::endl
        << "roi.xmax:" << r.roi.xmax << std::endl
        << "countermask:" << r.countermask << std::endl
        << "burstType:" << r.burstType << std::endl
        << "exptime1:" << r.expTime1Ns << std::endl
        << "exptime2:" << r.expTime2Ns << std::endl
        << "exptime3:" << r.expTime3Ns << std::endl
        << "gateDelay1:" << r.gateDelay1Ns << std::endl
        << "gateDelay2:" << r.gateDelay2Ns << std::endl
        << "gateDelay3:" << r.gateDelay3Ns << std::endl
        << "gates:" << r.gates << std::endl
        << ']';
    return oss.str();
}

std::ostream &operator<<(std::ostream &os,
                         const slsDetectorDefs::rxParameters &r) {
    return os << ToString(r);
}

std::string ToString(const slsDetectorDefs::patternParameters &r) {
    std::ostringstream oss;
    oss << '[' << std::setfill('0') << std::endl;
    int addr_width = 4;
    int word_width = 16;
    for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
        if (r.word[i] != 0) {
            oss << "patword " << ToStringHex(i, addr_width) << " "
                << ToStringHex(r.word[i], word_width) << std::endl;
        }
    }
    oss << "patioctrl " << ToStringHex(r.patioctrl, word_width) << std::endl
        << "patlimits " << ToStringHex(r.patlimits[0], addr_width) << " "
        << ToStringHex(r.patlimits[1], addr_width) << std::endl
        << "patloop0 " << ToStringHex(r.patloop[0], addr_width) << " "
        << ToStringHex(r.patloop[1], addr_width) << std::endl
        << "patnloop0 " << r.patnloop[0] << std::endl
        << "patloop1 " << ToStringHex(r.patloop[2], addr_width) << " "
        << ToStringHex(r.patloop[3], addr_width) << std::endl
        << "patnloop1 " << r.patnloop[1] << std::endl
        << "patloop2 " << ToStringHex(r.patloop[4], addr_width) << " "
        << ToStringHex(r.patloop[5], addr_width) << std::endl
        << "patnloop2 " << r.patnloop[2] << std::endl
        << "patwait0 " << ToStringHex(r.patwait[0], addr_width) << std::endl
        << "patwaittime0 " << r.patwaittime[0] << std::endl
        << "patwait1 " << ToStringHex(r.patwait[1], addr_width) << std::endl
        << "patwaittime1 " << r.patwaittime[1] << std::endl
        << "patwait2 " << ToStringHex(r.patwait[2], addr_width) << std::endl
        << "patwaittime2 " << r.patwaittime[2] << std::endl
        << ']';
    return oss.str();
}

std::ostream &operator<<(std::ostream &os,
                         const slsDetectorDefs::patternParameters &r) {
    return os << ToString(r);
}

std::string ToString(const slsDetectorDefs::scanParameters &r) {
    std::ostringstream oss;
    oss << '[';
    if (r.enable) {
        oss << "enabled" << std::endl
            << "dac " << ToString(r.dacInd) << std::endl
            << "start " << r.startOffset << std::endl
            << "stop " << r.stopOffset << std::endl
            << "step " << r.stepSize << std::endl
            << "settleTime "
            << ToString(std::chrono::nanoseconds{r.dacSettleTime_ns})
            << std::endl;
    } else {
        oss << "disabled";
    }
    oss << ']';
    return oss.str();
}

std::ostream &operator<<(std::ostream &os,
                         const slsDetectorDefs::scanParameters &r) {
    return os << ToString(r);
}

std::string ToString(const defs::runStatus s) {
    switch (s) {
    case defs::ERROR:
        return std::string("error");
    case defs::WAITING:
        return std::string("waiting");
    case defs::RUNNING:
        return std::string("running");
    case defs::TRANSMITTING:
        return std::string("transmitting");
    case defs::RUN_FINISHED:
        return std::string("finished");
    case defs::STOPPED:
        return std::string("stopped");
    default:
        return std::string("idle");
    }
}

std::string ToString(const defs::detectorType s) {
    switch (s) {
    case defs::EIGER:
        return std::string("Eiger");
    case defs::GOTTHARD:
        return std::string("Gotthard");
    case defs::JUNGFRAU:
        return std::string("Jungfrau");
    case defs::CHIPTESTBOARD:
        return std::string("ChipTestBoard");
    case defs::MOENCH:
        return std::string("Moench");
    case defs::MYTHEN3:
        return std::string("Mythen3");
    case defs::GOTTHARD2:
        return std::string("Gotthard2");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::detectorSettings s) {
    switch (s) {
    case defs::STANDARD:
        return std::string("standard");
    case defs::FAST:
        return std::string("fast");
    case defs::HIGHGAIN:
        return std::string("highgain");
    case defs::DYNAMICGAIN:
        return std::string("dynamicgain");
    case defs::LOWGAIN:
        return std::string("lowgain");
    case defs::MEDIUMGAIN:
        return std::string("mediumgain");
    case defs::VERYHIGHGAIN:
        return std::string("veryhighgain");
    case defs::DYNAMICHG0:
        return std::string("dynamichg0");
    case defs::FIXGAIN1:
        return std::string("fixgain1");
    case defs::FIXGAIN2:
        return std::string("fixgain2");
    case defs::FORCESWITCHG1:
        return std::string("forceswitchg1");
    case defs::FORCESWITCHG2:
        return std::string("forceswitchg2");
    case defs::VERYLOWGAIN:
        return std::string("verylowgain");
    case defs::G1_HIGHGAIN:
        return std::string("g1_hg");
    case defs::G1_LOWGAIN:
        return std::string("g1_lg");
    case defs::G2_HIGHCAP_HIGHGAIN:
        return std::string("g2_hc_hg");
    case defs::G2_HIGHCAP_LOWGAIN:
        return std::string("g2_hc_lg");
    case defs::G2_LOWCAP_HIGHGAIN:
        return std::string("g2_lc_hg");
    case defs::G2_LOWCAP_LOWGAIN:
        return std::string("g2_lc_lg");
    case defs::G4_HIGHGAIN:
        return std::string("g4_hg");
    case defs::G4_LOWGAIN:
        return std::string("g4_lg");
    case defs::UNDEFINED:
        return std::string("undefined");
    case defs::UNINITIALIZED:
        return std::string("uninitialized");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::speedLevel s) {
    switch (s) {
    case defs::FULL_SPEED:
        return std::string("full_speed");
    case defs::HALF_SPEED:
        return std::string("half_speed");
    case defs::QUARTER_SPEED:
        return std::string("quarter_speed");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::timingMode s) {
    switch (s) {
    case defs::AUTO_TIMING:
        return std::string("auto");
    case defs::TRIGGER_EXPOSURE:
        return std::string("trigger");
    case defs::GATED:
        return std::string("gating");
    case defs::BURST_TRIGGER:
        return std::string("burst_trigger");
    case defs::TRIGGER_GATED:
        return std::string("trigger_gating");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::frameDiscardPolicy s) {
    switch (s) {
    case defs::NO_DISCARD:
        return std::string("nodiscard");
    case defs::DISCARD_EMPTY_FRAMES:
        return std::string("discardempty");
    case defs::DISCARD_PARTIAL_FRAMES:
        return std::string("discardpartial");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::fileFormat s) {
    switch (s) {
    case defs::HDF5:
        return std::string("hdf5");
    case defs::BINARY:
        return std::string("binary");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::externalSignalFlag s) {
    switch (s) {
    case defs::TRIGGER_IN_RISING_EDGE:
        return std::string("trigger_in_rising_edge");
    case defs::TRIGGER_IN_FALLING_EDGE:
        return std::string("trigger_in_falling_edge");
    case defs::INVERSION_ON:
        return std::string("inversion_on");
    case defs::INVERSION_OFF:
        return std::string("inversion_off");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::readoutMode s) {
    switch (s) {
    case defs::ANALOG_ONLY:
        return std::string("analog");
    case defs::DIGITAL_ONLY:
        return std::string("digital");
    case defs::ANALOG_AND_DIGITAL:
        return std::string("analog_digital");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::frameModeType s) {
    switch (s) {
    case defs::PEDESTAL:
        return std::string("pedestal");
    case defs::NEW_PEDESTAL:
        return std::string("newpedestal");
    case defs::FLATFIELD:
        return std::string("flatfield");
    case defs::NEW_FLATFIELD:
        return std::string("newflatfield");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::detectorModeType s) {
    switch (s) {
    case defs::COUNTING:
        return std::string("counting");
    case defs::INTERPOLATING:
        return std::string("interpolating");
    case defs::ANALOG:
        return std::string("analog");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::dacIndex s) {
    switch (s) {
    case defs::DAC_0:
        return std::string("dac 0");
    case defs::DAC_1:
        return std::string("dac 1");
    case defs::DAC_2:
        return std::string("dac 2");
    case defs::DAC_3:
        return std::string("dac 3");
    case defs::DAC_4:
        return std::string("dac 4");
    case defs::DAC_5:
        return std::string("dac 5");
    case defs::DAC_6:
        return std::string("dac 6");
    case defs::DAC_7:
        return std::string("dac 7");
    case defs::DAC_8:
        return std::string("dac 8");
    case defs::DAC_9:
        return std::string("dac 9");
    case defs::DAC_10:
        return std::string("dac 10");
    case defs::DAC_11:
        return std::string("dac 11");
    case defs::DAC_12:
        return std::string("dac 12");
    case defs::DAC_13:
        return std::string("dac 13");
    case defs::DAC_14:
        return std::string("dac 14");
    case defs::DAC_15:
        return std::string("dac 15");
    case defs::DAC_16:
        return std::string("dac 16");
    case defs::DAC_17:
        return std::string("dac 17");
    case defs::VSVP:
        return std::string("vsvp");
    case defs::VTRIM:
        return std::string("vtrim");
    case defs::VRPREAMP:
        return std::string("vrpreamp");
    case defs::VRSHAPER:
        return std::string("vrshaper");
    case defs::VSVN:
        return std::string("vsvn");
    case defs::VTGSTV:
        return std::string("vtgstv");
    case defs::VCMP_LL:
        return std::string("vcmp_ll");
    case defs::VCMP_LR:
        return std::string("vcmp_lr");
    case defs::VCAL:
        return std::string("vcal");
    case defs::VCMP_RL:
        return std::string("vcmp_rl");
    case defs::RXB_RB:
        return std::string("rxb_rb");
    case defs::RXB_LB:
        return std::string("rxb_lb");
    case defs::VCMP_RR:
        return std::string("vcmp_rr");
    case defs::VCP:
        return std::string("vcp");
    case defs::VCN:
        return std::string("vcn");
    case defs::VISHAPER:
        return std::string("vishaper");
    case defs::VTHRESHOLD:
        return std::string("vthreshold");
    case defs::VREF_DS:
        return std::string("vref_ds");
    case defs::VCASCN_PB:
        return std::string("vcascn_pb");
    case defs::VCASCP_PB:
        return std::string("vcascp_pb");
    case defs::VOUT_CM:
        return std::string("vout_cm");
    case defs::VCASC_OUT:
        return std::string("vcasc_out");
    case defs::VIN_CM:
        return std::string("vin_cm");
    case defs::VREF_COMP:
        return std::string("vref_comp");
    case defs::IB_TESTC:
        return std::string("ib_test_c");
    case defs::VB_COMP:
        return std::string("vb_comp");
    case defs::VDD_PROT:
        return std::string("vdd_prot");
    case defs::VIN_COM:
        return std::string("vin_com");
    case defs::VREF_PRECH:
        return std::string("vref_prech");
    case defs::VB_PIXBUF:
        return std::string("vb_pixbuf");
    case defs::VB_DS:
        return std::string("vb_ds");
    case defs::VREF_H_ADC:
        return std::string("vref_h_adc");
    case defs::VB_COMP_FE:
        return std::string("vb_comp_fe");
    case defs::VB_COMP_ADC:
        return std::string("vb_comp_adc");
    case defs::VCOM_CDS:
        return std::string("vcom_cds");
    case defs::VREF_RSTORE:
        return std::string("vref_rstore");
    case defs::VB_OPA_1ST:
        return std::string("vb_opa_1st");
    case defs::VREF_COMP_FE:
        return std::string("vref_comp_fe");
    case defs::VCOM_ADC1:
        return std::string("vcom_adc1");
    case defs::VREF_L_ADC:
        return std::string("vref_l_adc");
    case defs::VREF_CDS:
        return std::string("vref_cds");
    case defs::VB_CS:
        return std::string("vb_cs");
    case defs::VB_OPA_FD:
        return std::string("vb_opa_fd");
    case defs::VCOM_ADC2:
        return std::string("vcom_adc2");
    case defs::VCASSH:
        return std::string("vcassh");
    case defs::VTH2:
        return std::string("vth2");
    case defs::VRSHAPER_N:
        return std::string("vrshaper_n");
    case defs::VIPRE_OUT:
        return std::string("vipre_out");
    case defs::VTH3:
        return std::string("vth3");
    case defs::VTH1:
        return std::string("vth1");
    case defs::VICIN:
        return std::string("vicin");
    case defs::VCAS:
        return std::string("vcas");
    case defs::VCAL_N:
        return std::string("vcal_n");
    case defs::VIPRE:
        return std::string("vipre");
    case defs::VCAL_P:
        return std::string("vcal_p");
    case defs::VDCSH:
        return std::string("vdcsh");
    case defs::VBP_COLBUF:
        return std::string("vbp_colbuf");
    case defs::VB_SDA:
        return std::string("vb_sda");
    case defs::VCASC_SFP:
        return std::string("vcasc_sfp");
    case defs::VIPRE_CDS:
        return std::string("vipre_cds");
    case defs::IBIAS_SFP:
        return std::string("ibias_sfp");
    case defs::TRIMBIT_SCAN:
        return std::string("trimbit_scan");
    case defs::HIGH_VOLTAGE:
        return std::string("highvoltage");
    case defs::IO_DELAY:
        return std::string("iodelay");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const std::vector<defs::dacIndex> &vec) {
    std::ostringstream os;
    os << '[';
    if (!vec.empty()) {
        auto it = vec.begin();
        os << ToString(*it++);
        while (it != vec.end())
            os << ", " << ToString(*it++);
    }
    os << ']';
    return os.str();
}

std::string ToString(const defs::burstMode s) {
    switch (s) {
    case defs::BURST_OFF:
        return std::string("off");
    case defs::BURST_INTERNAL:
        return std::string("internal");
    case defs::BURST_EXTERNAL:
        return std::string("external");
    default:
        return std::string("Unknown");
    }
}

std::string ToString(const defs::timingSourceType s) {
    switch (s) {
    case defs::TIMING_INTERNAL:
        return std::string("internal");
    case defs::TIMING_EXTERNAL:
        return std::string("external");
    default:
        return std::string("Unknown");
    }
}

const std::string &ToString(const std::string &s) { return s; }

template <> defs::detectorType StringTo(const std::string &s) {
    if (s == "Eiger")
        return defs::EIGER;
    if (s == "Gotthard")
        return defs::GOTTHARD;
    if (s == "Jungfrau")
        return defs::JUNGFRAU;
    if (s == "ChipTestBoard")
        return defs::CHIPTESTBOARD;
    if (s == "Moench")
        return defs::MOENCH;
    if (s == "Mythen3")
        return defs::MYTHEN3;
    if (s == "Gotthard2")
        return defs::GOTTHARD2;
    throw sls::RuntimeError("Unknown detector type " + s);
}

template <> defs::detectorSettings StringTo(const std::string &s) {
    if (s == "standard")
        return defs::STANDARD;
    if (s == "fast")
        return defs::FAST;
    if (s == "highgain")
        return defs::HIGHGAIN;
    if (s == "dynamicgain")
        return defs::DYNAMICGAIN;
    if (s == "lowgain")
        return defs::LOWGAIN;
    if (s == "mediumgain")
        return defs::MEDIUMGAIN;
    if (s == "veryhighgain")
        return defs::VERYHIGHGAIN;
    if (s == "dynamichg0")
        return defs::DYNAMICHG0;
    if (s == "fixgain1")
        return defs::FIXGAIN1;
    if (s == "fixgain2")
        return defs::FIXGAIN2;
    if (s == "forceswitchg1")
        return defs::FORCESWITCHG1;
    if (s == "forceswitchg2")
        return defs::FORCESWITCHG2;
    if (s == "verylowgain")
        return defs::VERYLOWGAIN;
    if (s == "g1_hg")
        return defs::G1_HIGHGAIN;
    if (s == "g1_lg")
        return defs::G1_LOWGAIN;
    if (s == "g2_hc_hg")
        return defs::G2_HIGHCAP_HIGHGAIN;
    if (s == "g2_hc_lg")
        return defs::G2_HIGHCAP_LOWGAIN;
    if (s == "g2_lc_hg")
        return defs::G2_LOWCAP_HIGHGAIN;
    if (s == "g2_lc_lg")
        return defs::G2_LOWCAP_LOWGAIN;
    if (s == "g4_hg")
        return defs::G4_HIGHGAIN;
    if (s == "g4_lg")
        return defs::G4_LOWGAIN;
    throw sls::RuntimeError("Unknown setting " + s);
}

template <> defs::speedLevel StringTo(const std::string &s) {
    if (s == "full_speed")
        return defs::FULL_SPEED;
    if (s == "half_speed")
        return defs::HALF_SPEED;
    if (s == "quarter_speed")
        return defs::QUARTER_SPEED;
    throw sls::RuntimeError("Unknown speed " + s);
}

template <> defs::timingMode StringTo(const std::string &s) {
    if (s == "auto")
        return defs::AUTO_TIMING;
    if (s == "trigger")
        return defs::TRIGGER_EXPOSURE;
    if (s == "gating")
        return defs::GATED;
    if (s == "burst_trigger")
        return defs::BURST_TRIGGER;
    if (s == "trigger_gating")
        return defs::TRIGGER_GATED;
    throw sls::RuntimeError("Unknown timing mode " + s);
}

template <> defs::frameDiscardPolicy StringTo(const std::string &s) {
    if (s == "nodiscard")
        return defs::NO_DISCARD;
    if (s == "discardempty")
        return defs::DISCARD_EMPTY_FRAMES;
    if (s == "discardpartial")
        return defs::DISCARD_PARTIAL_FRAMES;
    throw sls::RuntimeError("Unknown frame discard policy " + s);
}

template <> defs::fileFormat StringTo(const std::string &s) {
    if (s == "hdf5")
        return defs::HDF5;
    if (s == "binary")
        return defs::BINARY;
    throw sls::RuntimeError("Unknown file format " + s);
}

template <> defs::externalSignalFlag StringTo(const std::string &s) {
    if (s == "trigger_in_rising_edge")
        return defs::TRIGGER_IN_RISING_EDGE;
    if (s == "trigger_in_falling_edge")
        return defs::TRIGGER_IN_FALLING_EDGE;
    if (s == "inversion_on")
        return defs::INVERSION_ON;
    if (s == "inversion_off")
        return defs::INVERSION_OFF;
    throw sls::RuntimeError("Unknown external signal flag " + s);
}

template <> defs::readoutMode StringTo(const std::string &s) {
    if (s == "analog")
        return defs::ANALOG_ONLY;
    if (s == "digital")
        return defs::DIGITAL_ONLY;
    if (s == "analog_digital")
        return defs::ANALOG_AND_DIGITAL;
    throw sls::RuntimeError("Unknown readout mode " + s);
}

template <> defs::frameModeType StringTo(const std::string &s) {
    if (s == "pedestal")
        return defs::PEDESTAL;
    if (s == "newpedestal")
        return defs::NEW_PEDESTAL;
    if (s == "flatfield")
        return defs::FLATFIELD;
    if (s == "newflatfield")
        return defs::NEW_FLATFIELD;
    throw sls::RuntimeError("Unknown frame mode " + s);
}

template <> defs::detectorModeType StringTo(const std::string &s) {
    if (s == "counting")
        return defs::COUNTING;
    if (s == "interpolating")
        return defs::INTERPOLATING;
    if (s == "analog")
        return defs::ANALOG;
    throw sls::RuntimeError("Unknown detector mode " + s);
}

template <> defs::dacIndex StringTo(const std::string &s) {
    if (s == "dac 0")
        return defs::DAC_0;
    if (s == "dac 1")
        return defs::DAC_1;
    if (s == "dac 2")
        return defs::DAC_2;
    if (s == "dac 3")
        return defs::DAC_3;
    if (s == "dac 4")
        return defs::DAC_4;
    if (s == "dac 5")
        return defs::DAC_5;
    if (s == "dac 6")
        return defs::DAC_6;
    if (s == "dac 7")
        return defs::DAC_7;
    if (s == "dac 8")
        return defs::DAC_8;
    if (s == "dac 9")
        return defs::DAC_9;
    if (s == "dac 10")
        return defs::DAC_10;
    if (s == "dac 11")
        return defs::DAC_11;
    if (s == "dac 12")
        return defs::DAC_12;
    if (s == "dac 13")
        return defs::DAC_13;
    if (s == "dac 14")
        return defs::DAC_14;
    if (s == "dac 15")
        return defs::DAC_15;
    if (s == "dac 16")
        return defs::DAC_16;
    if (s == "dac 17")
        return defs::DAC_17;
    if (s == "vsvp")
        return defs::VSVP;
    if (s == "vtrim")
        return defs::VTRIM;
    if (s == "vrpreamp")
        return defs::VRPREAMP;
    if (s == "vrshaper")
        return defs::VRSHAPER;
    if (s == "vsvn")
        return defs::VSVN;
    if (s == "vtgstv")
        return defs::VTGSTV;
    if (s == "vcmp_ll")
        return defs::VCMP_LL;
    if (s == "vcmp_lr")
        return defs::VCMP_LR;
    if (s == "vcal")
        return defs::VCAL;
    if (s == "vcmp_rl")
        return defs::VCMP_RL;
    if (s == "rxb_rb")
        return defs::RXB_RB;
    if (s == "rxb_lb")
        return defs::RXB_LB;
    if (s == "vcmp_rr")
        return defs::VCMP_RR;
    if (s == "vcp")
        return defs::VCP;
    if (s == "vcn")
        return defs::VCN;
    if (s == "vishaper")
        return defs::VISHAPER;
    if (s == "vthreshold")
        return defs::VTHRESHOLD;
    if (s == "vref_ds")
        return defs::VREF_DS;
    if (s == "vcascn_pb")
        return defs::VCASCN_PB;
    if (s == "vcascp_pb")
        return defs::VCASCP_PB;
    if (s == "vout_cm")
        return defs::VOUT_CM;
    if (s == "vcasc_out")
        return defs::VCASC_OUT;
    if (s == "vin_cm")
        return defs::VIN_CM;
    if (s == "vref_comp")
        return defs::VREF_COMP;
    if (s == "ib_test_c")
        return defs::IB_TESTC;
    if (s == "vb_comp")
        return defs::VB_COMP;
    if (s == "vdd_prot")
        return defs::VDD_PROT;
    if (s == "vin_com")
        return defs::VIN_COM;
    if (s == "vref_prech")
        return defs::VREF_PRECH;
    if (s == "vb_pixbuf")
        return defs::VB_PIXBUF;
    if (s == "vb_ds")
        return defs::VB_DS;
    if (s == "vref_h_adc")
        return defs::VREF_H_ADC;
    if (s == "vb_comp_fe")
        return defs::VB_COMP_FE;
    if (s == "vb_comp_adc")
        return defs::VB_COMP_ADC;
    if (s == "vcom_cds")
        return defs::VCOM_CDS;
    if (s == "vref_rstore")
        return defs::VREF_RSTORE;
    if (s == "vb_opa_1st")
        return defs::VB_OPA_1ST;
    if (s == "vref_comp_fe")
        return defs::VREF_COMP_FE;
    if (s == "vcom_adc1")
        return defs::VCOM_ADC1;
    if (s == "vref_l_adc")
        return defs::VREF_L_ADC;
    if (s == "vref_cds")
        return defs::VREF_CDS;
    if (s == "vb_cs")
        return defs::VB_CS;
    if (s == "vb_opa_fd")
        return defs::VB_OPA_FD;
    if (s == "vcom_adc2")
        return defs::VCOM_ADC2;
    if (s == "vcassh")
        return defs::VCASSH;
    if (s == "vth2")
        return defs::VTH2;
    if (s == "vrshaper_n")
        return defs::VRSHAPER_N;
    if (s == "vipre_out")
        return defs::VIPRE_OUT;
    if (s == "vth3")
        return defs::VTH3;
    if (s == "vth1")
        return defs::VTH1;
    if (s == "vicin")
        return defs::VICIN;
    if (s == "vcas")
        return defs::VCAS;
    if (s == "vcal_n")
        return defs::VCAL_N;
    if (s == "vipre")
        return defs::VIPRE;
    if (s == "vcal_p")
        return defs::VCAL_P;
    if (s == "vdcsh")
        return defs::VDCSH;
    if (s == "vbp_colbuf")
        return defs::VBP_COLBUF;
    if (s == "vb_sda")
        return defs::VB_SDA;
    if (s == "vcasc_sfp")
        return defs::VCASC_SFP;
    if (s == "vipre_cds")
        return defs::VIPRE_CDS;
    if (s == "ibias_sfp")
        return defs::IBIAS_SFP;
    if (s == "trimbit_scan")
        return defs::TRIMBIT_SCAN;
    if (s == "highvoltage")
        return defs::HIGH_VOLTAGE;
    if (s == "iodelay")
        return defs::IO_DELAY;

    throw sls::RuntimeError("Unknown dac Index " + s);
}

template <> defs::burstMode StringTo(const std::string &s) {
    if (s == "off")
        return defs::BURST_OFF;
    if (s == "internal")
        return defs::BURST_INTERNAL;
    if (s == "external")
        return defs::BURST_EXTERNAL;
    throw sls::RuntimeError("Unknown burst mode " + s);
}

template <> defs::timingSourceType StringTo(const std::string &s) {
    if (s == "internal")
        return defs::TIMING_INTERNAL;
    if (s == "external")
        return defs::TIMING_EXTERNAL;
    throw sls::RuntimeError("Unknown timing source type " + s);
}

template <> uint32_t StringTo(const std::string &s) {
    int base = s.find("0x") != std::string::npos ? 16 : 10;
    return std::stoul(s, nullptr, base);
}

template <> uint64_t StringTo(const std::string &s) {
    int base = s.find("0x") != std::string::npos ? 16 : 10;
    return std::stoull(s, nullptr, base);
}

template <> int StringTo(const std::string &s) {
    int base = s.find("0x") != std::string::npos ? 16 : 10;
    return std::stoi(s, nullptr, base);
}

template <> bool StringTo(const std::string &s) {
    int i = std::stoi(s, nullptr, 10);
    switch (i) {
    case 0:
        return false;
    case 1:
        return true;
    default:
        throw sls::RuntimeError("Unknown boolean. Expecting be 0 or 1.");
    }
}

template <> int64_t StringTo(const std::string &s) {
    int base = s.find("0x") != std::string::npos ? 16 : 10;
    return std::stol(s, nullptr, base);
}

} // namespace sls