#include "jansson_private.h"

#include "strbuffer.h"

#include <assert.h>

#include <errno.h>

#include <math.h>

#include <stdio.h>

#include <string.h>

/* need jansson_private_config.h to get the correct snprintf */

#ifdef HAVE_CONFIG_H

#include <jansson_private_config.h>

#endif

/*

  - This code assumes that the decimal separator is exactly one

    character.

  - If setlocale() is called by another thread between the call to

    get_decimal_point() and the call to sprintf() or strtod(), the

    result may be wrong. setlocale() is not thread-safe and should

    not be used this way. Multi-threaded programs should use

    uselocale() instead.

*/

static char get_decimal_point() {

    char buf[3];

    sprintf(buf, "%#.0f", 1.0); // "1." in the current locale

    return buf[1];

}

static void to_locale(strbuffer_t *strbuffer) {

    char point;

    char *pos;

    point = get_decimal_point();

    if (point == '.') {

        /* No conversion needed */

        return;

    }

    pos = strchr(strbuffer->value, '.');

    if (pos)

        *pos = point;

}

int jsonp_strtod(strbuffer_t *strbuffer, double *out) {

    double value;

    char *end;

    to_locale(strbuffer);

    errno = 0;

    value = strtod(strbuffer->value, &end);

    assert(end == strbuffer->value + strbuffer->length);

    if ((value == HUGE_VAL || value == -HUGE_VAL) && errno == ERANGE) {

        /* Overflow */

        return -1;

    }

    *out = value;

    return 0;

}

#if DTOA_ENABLED

/* see dtoa.c */

char *dtoa_r(double dd, int mode, int ndigits, int *decpt, int *sign, char **rve,

             char *buf, size_t blen);

int jsonp_dtostr(char *buffer, size_t size, double value, int precision) {

    /* adapted from `format_float_short()` in

     * https://github.com/python/cpython/blob/2cf18a44303b6d84faa8ecffaecc427b53ae121e/Python/pystrtod.c#L969

     */

    char digits[25];

    char *digits_end;

    int mode = precision == 0 ? 0 : 2;

    int decpt, sign, exp_len, exp = 0, use_exp = 0;

    int digits_len, vdigits_start, vdigits_end;

    char *p;

    if (dtoa_r(value, mode, precision, &decpt, &sign, &digits_end, digits, 25) == NULL) {

        // digits is too short => should not happen

        return -1;

    }

    digits_len = digits_end - digits;

    if (decpt <= -4 || decpt > 16) {

        use_exp = 1;

        exp = decpt - 1;

        decpt = 1;

    }

    vdigits_start = decpt <= 0 ? decpt - 1 : 0;

    vdigits_end = digits_len;

    if (!use_exp) {

        /* decpt + 1 to add ".0" if value is an integer */

        vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;

    } else {

        vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;

    }

    if (

        /* sign, decimal point and trailing 0 byte */

        (size_t)(3 +

                 /* total digit count (including zero padding on both sides) */

                 (vdigits_end - vdigits_start) +

                 /* exponent "e+100", max 3 numerical digits */

                 (use_exp ? 5 : 0)) > size) {

        /* buffer is too short */

        return -1;

    }

    p = buffer;

    if (sign == 1) {

        *p++ = '-';

    }

    /* note that exactly one of the three 'if' conditions is true,

      so we include exactly one decimal point */

    /* Zero padding on left of digit string */

    if (decpt <= 0) {

        memset(p, '0', decpt - vdigits_start);

        p += decpt - vdigits_start;

        *p++ = '.';

        memset(p, '0', 0 - decpt);

        p += 0 - decpt;

    } else {

        memset(p, '0', 0 - vdigits_start);

        p += 0 - vdigits_start;

    }

    /* Digits, with included decimal point */

    if (0 < decpt && decpt <= digits_len) {

        strncpy(p, digits, decpt - 0);

        p += decpt - 0;

        *p++ = '.';

        strncpy(p, digits + decpt, digits_len - decpt);

        p += digits_len - decpt;

    } else {

        strncpy(p, digits, digits_len);

        p += digits_len;

    }

    /* And zeros on the right */

    if (digits_len < decpt) {

        memset(p, '0', decpt - digits_len);

        p += decpt - digits_len;

        *p++ = '.';

        memset(p, '0', vdigits_end - decpt);

        p += vdigits_end - decpt;

    } else {

        memset(p, '0', vdigits_end - digits_len);

        p += vdigits_end - digits_len;

    }

    if (p[-1] == '.')

        p--;

    if (use_exp) {

        *p++ = 'e';

        exp_len = sprintf(p, "%d", exp);

        p += exp_len;

    }

    *p = '\0';

    return (int)(p - buffer);

}

#else /* DTOA_ENABLED == 0 */

static void from_locale(char *buffer) {

    char point;

    char *pos;

    point = get_decimal_point();

    if (point == '.') {

        /* No conversion needed */

        return;

    }

    pos = strchr(buffer, point);

    if (pos)

        *pos = '.';

}

int jsonp_dtostr(char *buffer, size_t size, double value, int precision) {

    int ret;

    char *start, *end;

    size_t length;

    if (precision == 0)

        precision = 17;

    ret = snprintf(buffer, size, "%.*g", precision, value);

    if (ret < 0)

        return -1;

    length = (size_t)ret;

    if (length >= size)

        return -1;

    from_locale(buffer);

    /* Make sure there's a dot or 'e' in the output. Otherwise

       a real is converted to an integer when decoding */

    if (strchr(buffer, '.') == NULL && strchr(buffer, 'e') == NULL) {

        if (length + 3 >= size) {

            /* No space to append ".0" */

            return -1;

        }

        buffer[length] = '.';

        buffer[length + 1] = '0';

        buffer[length + 2] = '\0';

        length += 2;

    }

    /* Remove leading '+' from positive exponent. Also remove leading

       zeros from exponents (added by some printf() implementations) */

    start = strchr(buffer, 'e');

    if (start) {

        start++;

        end = start + 1;

        if (*start == '-')

            start++;

        while (*end == '0')

            end++;

        if (end != start) {

            memmove(start, end, length - (size_t)(end - buffer));

            length -= (size_t)(end - start);

        }

    }

    return (int)length;

}

#endif