/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "percent-util.h"
#include "tests.h"
#include "time-util.h"

static void test_parse_percent(void) {
        assert_se(parse_percent("") == -EINVAL);
        assert_se(parse_percent("foo") == -EINVAL);
        assert_se(parse_percent("0") == -EINVAL);
        assert_se(parse_percent("0.1") == -EINVAL);
        assert_se(parse_percent("50") == -EINVAL);
        assert_se(parse_percent("100") == -EINVAL);
        assert_se(parse_percent("-1") == -EINVAL);
        assert_se(parse_percent("0%") == 0);
        assert_se(parse_percent("55%") == 55);
        assert_se(parse_percent("100%") == 100);
        assert_se(parse_percent("-7%") == -ERANGE);
        assert_se(parse_percent("107%") == -ERANGE);
        assert_se(parse_percent("%") == -EINVAL);
        assert_se(parse_percent("%%") == -EINVAL);
        assert_se(parse_percent("%1") == -EINVAL);
        assert_se(parse_percent("1%%") == -EINVAL);
        assert_se(parse_percent("3.2%") == -EINVAL);
}

static void test_parse_percent_unbounded(void) {
        assert_se(parse_percent_unbounded("101%") == 101);
        assert_se(parse_percent_unbounded("400%") == 400);
}

static void test_parse_permille(void) {
        assert_se(parse_permille("") == -EINVAL);
        assert_se(parse_permille("foo") == -EINVAL);
        assert_se(parse_permille("0") == -EINVAL);
        assert_se(parse_permille("50") == -EINVAL);
        assert_se(parse_permille("100") == -EINVAL);
        assert_se(parse_permille("-1") == -EINVAL);
        assert_se(parse_permille("0.1") == -EINVAL);
        assert_se(parse_permille("5%") == 50);
        assert_se(parse_permille("5.5%") == 55);
        assert_se(parse_permille("5.12%") == -EINVAL);

        assert_se(parse_permille("0‰") == 0);
        assert_se(parse_permille("555‰") == 555);
        assert_se(parse_permille("1000‰") == 1000);
        assert_se(parse_permille("-7‰") == -ERANGE);
        assert_se(parse_permille("1007‰") == -ERANGE);
        assert_se(parse_permille("‰") == -EINVAL);
        assert_se(parse_permille("‰‰") == -EINVAL);
        assert_se(parse_permille("‰1") == -EINVAL);
        assert_se(parse_permille("1‰‰") == -EINVAL);
        assert_se(parse_permille("3.2‰") == -EINVAL);
        assert_se(parse_permille("0.1‰") == -EINVAL);

        assert_se(parse_permille("0%") == 0);
        assert_se(parse_permille("55%") == 550);
        assert_se(parse_permille("55.5%") == 555);
        assert_se(parse_permille("100%") == 1000);
        assert_se(parse_permille("-7%") == -ERANGE);
        assert_se(parse_permille("107%") == -ERANGE);
        assert_se(parse_permille("%") == -EINVAL);
        assert_se(parse_permille("%%") == -EINVAL);
        assert_se(parse_permille("%1") == -EINVAL);
        assert_se(parse_permille("1%%") == -EINVAL);
        assert_se(parse_permille("3.21%") == -EINVAL);
        assert_se(parse_permille("0.1%") == 1);
}

static void test_parse_permille_unbounded(void) {
        assert_se(parse_permille_unbounded("1001‰") == 1001);
        assert_se(parse_permille_unbounded("4000‰") == 4000);
        assert_se(parse_permille_unbounded("2147483647‰") == 2147483647);
        assert_se(parse_permille_unbounded("2147483648‰") == -ERANGE);
        assert_se(parse_permille_unbounded("4294967295‰") == -ERANGE);
        assert_se(parse_permille_unbounded("4294967296‰") == -ERANGE);

        assert_se(parse_permille_unbounded("101%") == 1010);
        assert_se(parse_permille_unbounded("400%") == 4000);
        assert_se(parse_permille_unbounded("214748364.7%") == 2147483647);
        assert_se(parse_permille_unbounded("214748364.8%") == -ERANGE);
        assert_se(parse_permille_unbounded("429496729.5%") == -ERANGE);
        assert_se(parse_permille_unbounded("429496729.6%") == -ERANGE);
}

static void test_parse_permyriad(void) {
        assert_se(parse_permyriad("") == -EINVAL);
        assert_se(parse_permyriad("foo") == -EINVAL);
        assert_se(parse_permyriad("0") == -EINVAL);
        assert_se(parse_permyriad("50") == -EINVAL);
        assert_se(parse_permyriad("100") == -EINVAL);
        assert_se(parse_permyriad("-1") == -EINVAL);

        assert_se(parse_permyriad("0‱") == 0);
        assert_se(parse_permyriad("555‱") == 555);
        assert_se(parse_permyriad("1000‱") == 1000);
        assert_se(parse_permyriad("-7‱") == -ERANGE);
        assert_se(parse_permyriad("10007‱") == -ERANGE);
        assert_se(parse_permyriad("‱") == -EINVAL);
        assert_se(parse_permyriad("‱‱") == -EINVAL);
        assert_se(parse_permyriad("‱1") == -EINVAL);
        assert_se(parse_permyriad("1‱‱") == -EINVAL);
        assert_se(parse_permyriad("3.2‱") == -EINVAL);

        assert_se(parse_permyriad("0‰") == 0);
        assert_se(parse_permyriad("555.5‰") == 5555);
        assert_se(parse_permyriad("1000.0‰") == 10000);
        assert_se(parse_permyriad("-7‰") == -ERANGE);
        assert_se(parse_permyriad("1007‰") == -ERANGE);
        assert_se(parse_permyriad("‰") == -EINVAL);
        assert_se(parse_permyriad("‰‰") == -EINVAL);
        assert_se(parse_permyriad("‰1") == -EINVAL);
        assert_se(parse_permyriad("1‰‰") == -EINVAL);
        assert_se(parse_permyriad("3.22‰") == -EINVAL);

        assert_se(parse_permyriad("0%") == 0);
        assert_se(parse_permyriad("55%") == 5500);
        assert_se(parse_permyriad("55.5%") == 5550);
        assert_se(parse_permyriad("55.50%") == 5550);
        assert_se(parse_permyriad("55.53%") == 5553);
        assert_se(parse_permyriad("100%") == 10000);
        assert_se(parse_permyriad("-7%") == -ERANGE);
        assert_se(parse_permyriad("107%") == -ERANGE);
        assert_se(parse_permyriad("%") == -EINVAL);
        assert_se(parse_permyriad("%%") == -EINVAL);
        assert_se(parse_permyriad("%1") == -EINVAL);
        assert_se(parse_permyriad("1%%") == -EINVAL);
        assert_se(parse_permyriad("3.212%") == -EINVAL);
}

static void test_parse_permyriad_unbounded(void) {
        assert_se(parse_permyriad_unbounded("1001‱") == 1001);
        assert_se(parse_permyriad_unbounded("4000‱") == 4000);
        assert_se(parse_permyriad_unbounded("2147483647‱") == 2147483647);
        assert_se(parse_permyriad_unbounded("2147483648‱") == -ERANGE);
        assert_se(parse_permyriad_unbounded("4294967295‱") == -ERANGE);
        assert_se(parse_permyriad_unbounded("4294967296‱") == -ERANGE);

        assert_se(parse_permyriad_unbounded("101‰") == 1010);
        assert_se(parse_permyriad_unbounded("400‰") == 4000);
        assert_se(parse_permyriad_unbounded("214748364.7‰") == 2147483647);
        assert_se(parse_permyriad_unbounded("214748364.8‰") == -ERANGE);
        assert_se(parse_permyriad_unbounded("429496729.5‰") == -ERANGE);
        assert_se(parse_permyriad_unbounded("429496729.6‰") == -ERANGE);

        assert_se(parse_permyriad_unbounded("99%") == 9900);
        assert_se(parse_permyriad_unbounded("40%") == 4000);
        assert_se(parse_permyriad_unbounded("21474836.47%") == 2147483647);
        assert_se(parse_permyriad_unbounded("21474836.48%") == -ERANGE);
        assert_se(parse_permyriad_unbounded("42949672.95%") == -ERANGE);
        assert_se(parse_permyriad_unbounded("42949672.96%") == -ERANGE);
}

static void test_scale(void) {
        /* Check some fixed values */
        assert_se(UINT32_SCALE_FROM_PERCENT(0) == 0);
        assert_se(UINT32_SCALE_FROM_PERCENT(50) == UINT32_MAX/2+1);
        assert_se(UINT32_SCALE_FROM_PERCENT(100) == UINT32_MAX);

        assert_se(UINT32_SCALE_FROM_PERMILLE(0) == 0);
        assert_se(UINT32_SCALE_FROM_PERMILLE(500) == UINT32_MAX/2+1);
        assert_se(UINT32_SCALE_FROM_PERMILLE(1000) == UINT32_MAX);

        assert_se(UINT32_SCALE_FROM_PERMYRIAD(0) == 0);
        assert_se(UINT32_SCALE_FROM_PERMYRIAD(5000) == UINT32_MAX/2+1);
        assert_se(UINT32_SCALE_FROM_PERMYRIAD(10000) == UINT32_MAX);

        /* Make sure there's no numeric noise on the 0%…100% scale when converting from percent and back. */
        for (int percent = 0; percent <= 100; percent++) {
                log_debug("%i%% → %" PRIu32 " → %i%%",
                          percent,
                          UINT32_SCALE_FROM_PERCENT(percent),
                          UINT32_SCALE_TO_PERCENT(UINT32_SCALE_FROM_PERCENT(percent)));

                assert_se(UINT32_SCALE_TO_PERCENT(UINT32_SCALE_FROM_PERCENT(percent)) == percent);
        }

        /* Make sure there's no numeric noise on the 0‰…1000‰ scale when converting from permille and back. */
        for (int permille = 0; permille <= 1000; permille++) {
                log_debug("%i‰ → %" PRIu32 " → %i‰",
                          permille,
                          UINT32_SCALE_FROM_PERMILLE(permille),
                          UINT32_SCALE_TO_PERMILLE(UINT32_SCALE_FROM_PERMILLE(permille)));

                assert_se(UINT32_SCALE_TO_PERMILLE(UINT32_SCALE_FROM_PERMILLE(permille)) == permille);
        }

        /* Make sure there's no numeric noise on the 0‱…10000‱ scale when converting from permyriad and back. */
        for (int permyriad = 0; permyriad <= 10000; permyriad++) {
                log_debug("%i‱ → %" PRIu32 " → %i‱",
                          permyriad,
                          UINT32_SCALE_FROM_PERMYRIAD(permyriad),
                          UINT32_SCALE_TO_PERMYRIAD(UINT32_SCALE_FROM_PERMYRIAD(permyriad)));

                assert_se(UINT32_SCALE_TO_PERMYRIAD(UINT32_SCALE_FROM_PERMYRIAD(permyriad)) == permyriad);
        }
}

int main(int argc, char *argv[]) {
        test_setup_logging(LOG_DEBUG);

        test_parse_percent();
        test_parse_percent_unbounded();
        test_parse_permille();
        test_parse_permille_unbounded();
        test_parse_permyriad();
        test_parse_permyriad_unbounded();
        test_scale();

        return 0;
}