/*
 * This file is part of the bladeRF project:
 *   http://www.github.com/nuand/bladeRF
 *
 * Copyright (c) 2017-2018 Nuand LLC.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "conversions.h"

int str2version(const char *str, struct bladerf_version *version)
{
    unsigned long tmp;
    const char *start = str;
    char *end;

    /* Major version */
    errno = 0;
    tmp   = strtoul(start, &end, 10);
    if (errno != 0 || tmp > UINT16_MAX || end == start || *end != '.') {
        return -1;
    }
    version->major = (uint16_t)tmp;

    /* Minor version */
    if (end[0] == '\0' || end[1] == '\0') {
        return -1;
    }
    errno = 0;
    start = &end[1];
    tmp   = strtoul(start, &end, 10);
    if (errno != 0 || tmp > UINT16_MAX || end == start || *end != '.') {
        return -1;
    }
    version->minor = (uint16_t)tmp;

    /* Patch version */
    if (end[0] == '\0' || end[1] == '\0') {
        return -1;
    }
    errno = 0;
    start = &end[1];
    tmp   = strtoul(start, &end, 10);
    if (errno != 0 || tmp > UINT16_MAX || end == start ||
        (*end != '-' && *end != '\0')) {
        return -1;
    }
    version->patch = (uint16_t)tmp;

    version->describe = str;

    return 0;
}

const char *devspeed2str(bladerf_dev_speed speed)
{
    switch (speed) {
        case BLADERF_DEVICE_SPEED_HIGH:
            /* Yeah, the USB IF actually spelled it "Hi" instead of "High".
             * I know. It hurts me too. */
            return "Hi-Speed";

        case BLADERF_DEVICE_SPEED_SUPER:
            /* ...and no hyphen :( */
            return "SuperSpeed";

        default:
            return "Unknown";
    }
}

bladerf_log_level str2loglevel(const char *str, bool *ok)
{
    bladerf_log_level level = BLADERF_LOG_LEVEL_ERROR;
    bool valid              = true;

    if (!strcasecmp(str, "critical")) {
        level = BLADERF_LOG_LEVEL_CRITICAL;
    } else if (!strcasecmp(str, "error")) {
        level = BLADERF_LOG_LEVEL_ERROR;
    } else if (!strcasecmp(str, "warning")) {
        level = BLADERF_LOG_LEVEL_WARNING;
    } else if (!strcasecmp(str, "info")) {
        level = BLADERF_LOG_LEVEL_INFO;
    } else if (!strcasecmp(str, "debug")) {
        level = BLADERF_LOG_LEVEL_DEBUG;
    } else if (!strcasecmp(str, "verbose")) {
        level = BLADERF_LOG_LEVEL_VERBOSE;
    } else {
        valid = false;
    }

    *ok = valid;
    return level;
}

const char *module2str(bladerf_module m)
{
    switch (m) {
        case BLADERF_MODULE_RX:
            return "RX";
        case BLADERF_MODULE_TX:
            return "TX";
        default:
            return "Unknown";
    }
}

bladerf_module str2module(const char *str)
{
    if (!strcasecmp(str, "RX")) {
        return BLADERF_MODULE_RX;
    } else if (!strcasecmp(str, "TX")) {
        return BLADERF_MODULE_TX;
    } else {
        return BLADERF_MODULE_INVALID;
    }
}

const char *channel2str(bladerf_channel ch)
{
    switch (ch) {
        case BLADERF_CHANNEL_RX(0):
            return "RX1";
        case BLADERF_CHANNEL_TX(0):
            return "TX1";
        case BLADERF_CHANNEL_RX(1):
            return "RX2";
        case BLADERF_CHANNEL_TX(1):
            return "TX2";
        default:
            return "Unknown";
    }
}

bladerf_channel str2channel(char const *str)
{
    bladerf_channel rv;

    if (strcasecmp(str, "rx") == 0 || strcasecmp(str, "rx1") == 0) {
        rv = BLADERF_CHANNEL_RX(0);
    } else if (strcasecmp(str, "rx2") == 0) {
        rv = BLADERF_CHANNEL_RX(1);
    } else if (strcasecmp(str, "tx") == 0 || strcasecmp(str, "tx1") == 0) {
        rv = BLADERF_CHANNEL_TX(0);
    } else if (strcasecmp(str, "tx2") == 0) {
        rv = BLADERF_CHANNEL_TX(1);
    } else {
        rv = BLADERF_CHANNEL_INVALID;
    }

    return rv;
}

bladerf_direction channel2direction (bladerf_channel ch) {
    if (ch == BLADERF_CHANNEL_RX(0) || ch == BLADERF_CHANNEL_RX(1)) {
        return BLADERF_RX;
    } else {
        return BLADERF_TX;
    }
}

const char *direction2str(bladerf_direction dir)
{
    switch (dir) {
        case BLADERF_RX:
            return "RX";
        case BLADERF_TX:
            return "TX";
        default:
            return "Unknown";
    }
}

const char *trigger2str(bladerf_trigger_signal trigger)
{
    switch (trigger) {
        case BLADERF_TRIGGER_J71_4:
            return "J71-4";

        case BLADERF_TRIGGER_J51_1:
            return "J51-1";

        case BLADERF_TRIGGER_MINI_EXP_1:
            return "MiniExp-1";

        case BLADERF_TRIGGER_USER_0:
            return "User-0";

        case BLADERF_TRIGGER_USER_1:
            return "User-1";

        case BLADERF_TRIGGER_USER_2:
            return "User-2";

        case BLADERF_TRIGGER_USER_3:
            return "User-3";

        case BLADERF_TRIGGER_USER_4:
            return "User-4";

        case BLADERF_TRIGGER_USER_5:
            return "User-5";

        case BLADERF_TRIGGER_USER_6:
            return "User-6";

        case BLADERF_TRIGGER_USER_7:
            return "User-7";

        default:
            return "Unknown";
    }
}

bladerf_trigger_signal str2trigger(const char *str)
{
    if (!strcasecmp("J71-4", str)) {
        return BLADERF_TRIGGER_J71_4;
    } else if (!strcasecmp("J51-1", str)) {
        return BLADERF_TRIGGER_J51_1;
    } else if (!strcasecmp("Miniexp-1", str)) {
        return BLADERF_TRIGGER_MINI_EXP_1;
    } else if (!strcasecmp("User-0", str)) {
        return BLADERF_TRIGGER_USER_0;
    } else if (!strcasecmp("User-1", str)) {
        return BLADERF_TRIGGER_USER_1;
    } else if (!strcasecmp("User-2", str)) {
        return BLADERF_TRIGGER_USER_2;
    } else if (!strcasecmp("User-3", str)) {
        return BLADERF_TRIGGER_USER_3;
    } else if (!strcasecmp("User-4", str)) {
        return BLADERF_TRIGGER_USER_4;
    } else if (!strcasecmp("User-5", str)) {
        return BLADERF_TRIGGER_USER_5;
    } else if (!strcasecmp("User-6", str)) {
        return BLADERF_TRIGGER_USER_6;
    } else if (!strcasecmp("User-7", str)) {
        return BLADERF_TRIGGER_USER_7;
    } else {
        return BLADERF_TRIGGER_INVALID;
    }
}

const char *triggerrole2str(bladerf_trigger_role role)
{
    switch (role) {
        case BLADERF_TRIGGER_ROLE_MASTER:
            return "Master";
        case BLADERF_TRIGGER_ROLE_SLAVE:
            return "Slave";
        case BLADERF_TRIGGER_ROLE_DISABLED:
            return "Disabled";
        default:
            return "Unknown";
    }
}

bladerf_trigger_role str2triggerrole(const char *str)
{
    if (!strcasecmp("Master", str)) {
        return BLADERF_TRIGGER_ROLE_MASTER;
    } else if (!strcasecmp("Slave", str)) {
        return BLADERF_TRIGGER_ROLE_SLAVE;
    } else if (!strcasecmp("Disabled", str) || !strcasecmp("Off", str)) {
        return BLADERF_TRIGGER_ROLE_DISABLED;
    } else {
        return BLADERF_TRIGGER_ROLE_INVALID;
    }
}

int str2loopback(const char *str, bladerf_loopback *loopback)
{
    int status = 0;

    if (!strcasecmp("firmware", str)) {
        *loopback = BLADERF_LB_FIRMWARE;
    } else if (!strcasecmp("bb_txlpf_rxvga2", str)) {
        *loopback = BLADERF_LB_BB_TXLPF_RXVGA2;
    } else if (!strcasecmp("bb_txlpf_rxlpf", str)) {
        *loopback = BLADERF_LB_BB_TXLPF_RXLPF;
    } else if (!strcasecmp("bb_txvga1_rxvga2", str)) {
        *loopback = BLADERF_LB_BB_TXVGA1_RXVGA2;
    } else if (!strcasecmp("bb_txvga1_rxlpf", str)) {
        *loopback = BLADERF_LB_BB_TXVGA1_RXLPF;
    } else if (!strcasecmp("rf_lna1", str)) {
        *loopback = BLADERF_LB_RF_LNA1;
    } else if (!strcasecmp("rf_lna2", str)) {
        *loopback = BLADERF_LB_RF_LNA2;
    } else if (!strcasecmp("rf_lna3", str)) {
        *loopback = BLADERF_LB_RF_LNA3;
    } else if (!strcasecmp("rfic_bist", str)) {
        *loopback = BLADERF_LB_RFIC_BIST;
    } else if (!strcasecmp("none", str)) {
        *loopback = BLADERF_LB_NONE;
    } else {
        status = -1;
    }

    return status;
}

char const *loopback2str(bladerf_loopback loopback)
{
    switch (loopback) {
        case BLADERF_LB_BB_TXLPF_RXVGA2:
            return "bb_txlpf_rxvga2";

        case BLADERF_LB_BB_TXLPF_RXLPF:
            return "bb_txlpf_rxlpf";

        case BLADERF_LB_BB_TXVGA1_RXVGA2:
            return "bb_txvga1_rxvga2";

        case BLADERF_LB_BB_TXVGA1_RXLPF:
            return "bb_txvga1_rxlpf";

        case BLADERF_LB_RF_LNA1:
            return "rf_lna1";

        case BLADERF_LB_RF_LNA2:
            return "rf_lna2";

        case BLADERF_LB_RF_LNA3:
            return "rf_lna3";

        case BLADERF_LB_FIRMWARE:
            return "firmware";

        case BLADERF_LB_NONE:
            return "none";

        case BLADERF_LB_RFIC_BIST:
            return "rfic_bist";

        default:
            return "unknown";
    }
}

int str2lnagain(const char *str, bladerf_lna_gain *gain)
{
    *gain = BLADERF_LNA_GAIN_MAX;

    if (!strcasecmp("max", str) || !strcasecmp("BLADERF_LNA_GAIN_MAX", str)) {
        *gain = BLADERF_LNA_GAIN_MAX;
        return 0;
    } else if (!strcasecmp("mid", str) ||
               !strcasecmp("BLADERF_LNA_GAIN_MID", str)) {
        *gain = BLADERF_LNA_GAIN_MID;
        return 0;
    } else if (!strcasecmp("bypass", str) ||
               !strcasecmp("BLADERF_LNA_GAIN_BYPASS", str)) {
        *gain = BLADERF_LNA_GAIN_BYPASS;
        return 0;
    } else {
        *gain = BLADERF_LNA_GAIN_UNKNOWN;
        return -1;
    }
}

char const *tuningmode2str(bladerf_tuning_mode mode)
{
    switch (mode) {
        case BLADERF_TUNING_MODE_HOST:
            return "Host";
        case BLADERF_TUNING_MODE_FPGA:
            return "FPGA";
        default:
            return "Unknown";
    }
}

const char *backend_description(bladerf_backend b)
{
    switch (b) {
        case BLADERF_BACKEND_ANY:
            return "Any";

        case BLADERF_BACKEND_LINUX:
            return "Linux kernel driver";

        case BLADERF_BACKEND_LIBUSB:
            return "libusb";

        case BLADERF_BACKEND_CYPRESS:
            return "Cypress driver";

        case BLADERF_BACKEND_DUMMY:
            return "Dummy";

        default:
            return "Unknown";
    }
}

void sc16q11_to_float(const int16_t *in, float *out, unsigned int n)
{
    unsigned int i;

    for (i = 0; i < (2 * n); i += 2) {
        out[i]     = (float)in[i] * (1.0f / 2048.0f);
        out[i + 1] = (float)in[i + 1] * (1.0f / 2048.0f);
    }
}

void float_to_sc16q11(const float *in, int16_t *out, unsigned int n)
{
    unsigned int i;

    for (i = 0; i < (2 * n); i += 2) {
        out[i]     = (int16_t)(in[i] * 2048.0f);
        out[i + 1] = (int16_t)(in[i + 1] * 2048.0f);
    }
}

bladerf_cal_module str_to_bladerf_cal_module(const char *str)
{
    bladerf_cal_module module = BLADERF_DC_CAL_INVALID;

    if (!strcasecmp(str, "lpf_tuning") || !strcasecmp(str, "lpftuning") ||
        !strcasecmp(str, "tuning")) {
        module = BLADERF_DC_CAL_LPF_TUNING;
    } else if (!strcasecmp(str, "tx_lpf") || !strcasecmp(str, "txlpf")) {
        module = BLADERF_DC_CAL_TX_LPF;
    } else if (!strcasecmp(str, "rx_lpf") || !strcasecmp(str, "rxlpf")) {
        module = BLADERF_DC_CAL_RX_LPF;
    } else if (!strcasecmp(str, "rx_vga2") || !strcasecmp(str, "rxvga2")) {
        module = BLADERF_DC_CAL_RXVGA2;
    }

    return module;
}

const char *smb_mode_to_str(bladerf_smb_mode mode)
{
    switch (mode) {
        case BLADERF_SMB_MODE_DISABLED:
            return "Disabled";

        case BLADERF_SMB_MODE_OUTPUT:
            return "Output";

        case BLADERF_SMB_MODE_INPUT:
            return "Input";

        case BLADERF_SMB_MODE_UNAVAILBLE:
            return "Unavailable";

        default:
            return "Unknown";
    }
};

bladerf_smb_mode str_to_smb_mode(const char *str)
{
    if (!strcasecmp(str, "disabled") || !strcasecmp(str, "off")) {
        return BLADERF_SMB_MODE_DISABLED;
    } else if (!strcasecmp(str, "output")) {
        return BLADERF_SMB_MODE_OUTPUT;
    } else if (!strcasecmp(str, "input")) {
        return BLADERF_SMB_MODE_INPUT;
    } else if (!strcasecmp(str, "unavailable")) {
        return BLADERF_SMB_MODE_UNAVAILBLE;
    } else {
        return BLADERF_SMB_MODE_INVALID;
    }
}

bladerf_tuning_mode str_to_tuning_mode(const char *str)
{
    if (!strcasecmp(str, "fpga")) {
        return BLADERF_TUNING_MODE_FPGA;
    } else if (!strcasecmp(str, "host")) {
        return BLADERF_TUNING_MODE_HOST;
    } else {
        return BLADERF_TUNING_MODE_INVALID;
    }
}

unsigned int str2uint(const char *str,
                      unsigned int min,
                      unsigned int max,
                      bool *ok)
{
    unsigned int ret;
    char *optr;

    errno = 0;
    ret   = strtoul(str, &optr, 0);

    if (errno == ERANGE || (errno != 0 && ret == 0)) {
        *ok = false;
        return 0;
    }

    if (str == optr) {
        *ok = false;
        return 0;
    }

    if (ret >= min && ret <= max) {
        *ok = true;
        return (unsigned int)ret;
    }

    *ok = false;
    return 0;
}

int str2int(const char *str, int min, int max, bool *ok)
{
    long int ret;
    char *optr;

    errno = 0;
    ret   = strtol(str, &optr, 0);

    if ((errno == ERANGE && (ret == LONG_MAX || ret == LONG_MIN)) ||
        (errno != 0 && ret == 0)) {
        *ok = false;
        return 0;
    }

    if (str == optr) {
        *ok = false;
        return 0;
    }

    if (ret >= min && ret <= max) {
        *ok = true;
        return (int)ret;
    }

    *ok = false;
    return 0;
}

uint64_t str2uint64(const char *str, uint64_t min, uint64_t max, bool *ok)
{
    uint64_t ret;
    char *optr;

    errno = 0;
    ret   = (uint64_t)strtod(str, &optr);

    if ((errno == ERANGE && ret == ULONG_MAX) || (errno != 0 && ret == 0)) {
        *ok = false;
        return 0;
    }

    if (str == optr) {
        *ok = false;
        return 0;
    }

    if (ret >= min && ret <= max) {
        *ok = true;
        return ret;
    }

    *ok = false;
    return 0;
}

double str2double(const char *str, double min, double max, bool *ok)
{
    double ret;
    char *optr;

    errno = 0;
    ret   = strtod(str, &optr);

    if (errno == ERANGE || (errno != 0 && ret == 0)) {
        *ok = false;
        return NAN;
    }

    if (str == optr) {
        *ok = false;
        return NAN;
    }

    if (ret >= min && ret <= max) {
        *ok = true;
        return ret;
    }

    *ok = false;
    return NAN;
}

static uint64_t suffix_multiplier(const char *str,
                                  const struct numeric_suffix *suffixes,
                                  const size_t num_suff,
                                  bool *ok)
{
    unsigned i;

    *ok = true;

    if (!strlen(str))
        return 1;

    for (i = 0; i < num_suff; i++) {
        if (!strcasecmp(suffixes[i].suffix, str)) {
            return suffixes[i].multiplier;
        }
    }

    *ok = false;
    return 0;
}

unsigned int str2uint_suffix(const char *str,
                             unsigned int min,
                             unsigned int max,
                             const struct numeric_suffix *suffixes,
                             const size_t num_suff,
                             bool *ok)
{
    uint64_t mult;
    unsigned int rv;
    double val;
    char *optr;

    errno = 0;
    val   = strtod(str, &optr);

    if (errno == ERANGE || (errno != 0 && val == 0)) {
        *ok = false;
        return 0;
    }

    if (str == optr) {
        *ok = false;
        return 0;
    }

    mult = suffix_multiplier(optr, suffixes, num_suff, ok);
    if (!*ok)
        return false;

    rv = (unsigned int)(val * mult);

    if (rv >= min && rv <= max) {
        return rv;
    }

    *ok = false;
    return 0;
}

uint64_t str2uint64_suffix(const char *str,
                           uint64_t min,
                           uint64_t max,
                           const struct numeric_suffix *suffixes,
                           const size_t num_suff,
                           bool *ok)
{
    uint64_t mult, rv;
    long double val;
    char *optr;

    errno = 0;
    val   = strtold(str, &optr);

    if (errno == ERANGE && (errno != 0 && val == 0)) {
        *ok = false;
        return 0;
    }

    if (str == optr) {
        *ok = false;
        return 0;
    }

    mult = suffix_multiplier(optr, suffixes, num_suff, ok);
    if (!*ok)
        return false;

    rv = (uint64_t)(val * mult);
    if (rv >= min && rv <= max) {
        return rv;
    }

    *ok = false;
    return 0;
}

int str2bool(const char *str, bool *val)
{
    unsigned int i;

    char *str_true[]  = { "true", "t", "one", "1", "enable", "en", "on" };
    char *str_false[] = { "false", "f", "zero", "0", "disable", "dis", "off" };

    for (i = 0; i < ARRAY_SIZE(str_true); i++) {
        if (!strcasecmp(str_true[i], str)) {
            *val = true;
            return 0;
        }
    }

    for (i = 0; i < ARRAY_SIZE(str_false); i++) {
        if (!strcasecmp(str_false[i], str)) {
            *val = false;
            return 0;
        }
    }

    return BLADERF_ERR_INVAL;
}