/* struct lconv — everything a locale knows about numbers and money. */
#include <limits.h>
#include <locale.h>
#include <stdio.h>

/* String members: show emptiness visibly */
static const char *str(const char *s) { return (s && *s) ? s : "(empty)"; }

/* char members: CHAR_MAX means "this locale does not say" */
static void show_char(const char *name, char v)
{
    if (v == CHAR_MAX) printf("  %-20s CHAR_MAX (not specified)\n", name);
    else               printf("  %-20s %d\n", name, v);
}

/* How the grouping string is encoded:
     each byte is the group size at that position. CHAR_MAX means "no more
     grouping", 0 means "repeat the previous value forever". "\3" is groups of
     three without end; en_IN uses "\3\2". */
static void show_grouping(const char *name, const char *g)
{
    printf("%-20s ", name);
    if (!*g) { puts("(empty — no grouping)"); return; }
    for (const char *p = g; *p; p++) {
        if (*p == CHAR_MAX) printf("CHAR_MAX ");
        else                printf("%d ", *p);
    }
    puts("");
}

static void dump_all(void)
{
    struct lconv *L = localeconv();

    puts("[plain numbers]");
    printf("  %-20s \"%s\"\n", "decimal_point", str(L->decimal_point));
    printf("  %-20s \"%s\"\n", "thousands_sep", str(L->thousands_sep));
    show_grouping("  grouping", L->grouping);

    puts("[monetary numbers]");
    printf("  %-20s \"%s\"\n", "mon_decimal_point", str(L->mon_decimal_point));
    printf("  %-20s \"%s\"\n", "mon_thousands_sep", str(L->mon_thousands_sep));
    show_grouping("  mon_grouping", L->mon_grouping);
    printf("  %-20s \"%s\"\n", "positive_sign", str(L->positive_sign));
    printf("  %-20s \"%s\"\n", "negative_sign", str(L->negative_sign));
    printf("  %-20s \"%s\"\n", "currency_symbol", str(L->currency_symbol));
    printf("  %-20s \"%s\"\n", "int_curr_symbol", str(L->int_curr_symbol));
    show_char("frac_digits", L->frac_digits);
    show_char("int_frac_digits", L->int_frac_digits);

    puts("[how the monetary form is assembled]");
    show_char("p_cs_precedes", L->p_cs_precedes);
    show_char("p_sep_by_space", L->p_sep_by_space);
    show_char("p_sign_posn", L->p_sign_posn);
    show_char("n_cs_precedes", L->n_cs_precedes);
    show_char("n_sep_by_space", L->n_sep_by_space);
    show_char("n_sign_posn", L->n_sign_posn);
}

/* 여러 로케일을 한 줄씩 견주어 본다 */
static void compare_row(const char *name)
{
    if (!setlocale(LC_ALL, name)) {
        printf("  %-14s (not on this machine)\n", name);
        return;
    }
    struct lconv *L = localeconv();
    printf("  %-14s point \"%s\"  thousands \"%s\"  symbol \"%s\"  ISO \"%s\"\n",
           name, str(L->decimal_point), str(L->thousands_sep),
           str(L->currency_symbol), str(L->int_curr_symbol));
}

int main(void)
{
    /* A program starts in "C". The standard fixes these values (§7.11). */
    puts("=== the \"C\" locale — the values the standard fixes ===");
    dump_all();

    puts("\n=== compared across locales ===");
    static const char *names[] = {
        "C", "en_US.UTF-8", "ko_KR.UTF-8", "de_DE.UTF-8",
        "fr_FR.UTF-8", "ja_JP.UTF-8", "en_IN.UTF-8",
    };
    for (size_t i = 0; i < sizeof names / sizeof *names; i++)
        compare_row(names[i]);

    /* Grouping is not always three digits — the Indian system */
    puts("\n=== grouping is not always three digits ===");
    static const char *grp[] = { "C", "en_US.UTF-8", "en_IN.UTF-8" };
    for (size_t i = 0; i < sizeof grp / sizeof *grp; i++) {
        if (!setlocale(LC_ALL, grp[i])) {
            printf("  %-14s (not on this machine)\n", grp[i]);
            continue;
        }
        printf("  %-14s ", grp[i]);
        show_grouping("grouping", localeconv()->grouping);
    }
    puts("  -> en_IN's 3,2 means \"three from the right, then two at a time\" —");
    puts("    12345678 is grouped as 1,23,45,678 (the lakh/crore system).");

    /* Change the decimal point and printf and strtod change together */
    puts("\n=== LC_NUMERIC changes printf ===");
    static const char *num_locales[] = { "C", "de_DE.UTF-8", "fr_FR.UTF-8" };
    for (size_t i = 0; i < sizeof num_locales / sizeof *num_locales; i++) {
        if (!setlocale(LC_NUMERIC, num_locales[i])) {
            printf("  %-14s (not on this machine)\n", num_locales[i]);
            continue;
        }
        printf("  %-14s printf(\"%%.2f\", 1234.5) -> %.2f\n",
               num_locales[i], 1234.5);
    }
    return 0;
}

/* LC_TIME — one instant written differently. And the formats that never move. */
#include <locale.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

/* A fixed instant so the run is reproducible: 2026-08-06 (Thu) 15:04:05 */
static struct tm fixed_time(void)
{
    struct tm t = {
        .tm_year = 2026 - 1900, .tm_mon = 8 - 1, .tm_mday = 6,
        .tm_hour = 15, .tm_min = 4, .tm_sec = 5,
        .tm_wday = 4,               /* Thursday */
        .tm_yday = 217, .tm_isdst = 0,
    };
    return t;
}

static void row(const char *locale, const char *fmt)
{
    char buf[256];
    struct tm t = fixed_time();

    if (!setlocale(LC_TIME, locale)) {
        printf("  %-14s (not on this machine)\n", locale);
        return;
    }
    size_t n = strftime(buf, sizeof buf, fmt, &t);
    if (n == 0) { printf("  %-14s (buffer too small)\n", locale); return; }
    printf("  %-14s %s\n", locale, buf);
}

int main(void)
{
    static const char *locales[] = {
        "C", "en_US.UTF-8", "ko_KR.UTF-8", "de_DE.UTF-8",
        "fr_FR.UTF-8", "ja_JP.UTF-8",
    };
    static const struct { const char *fmt, *what; } cases[] = {
        { "%c",       "%c  — the locale's own date-and-time form" },
        { "%x",       "%x  — the locale's own date form" },
        { "%X",       "%X  — the locale's own time form" },
        { "%A %B",    "%A %B — full names of the day and the month" },
        { "%a %b",    "%a %b — abbreviated names" },
        { "%p %I:%M", "%p %I:%M — am/pm and the 12-hour clock" },
        { "%F %T",    "%F %T — ISO 8601. *independent of the locale*" },
        { "%Y-%m-%d", "%Y-%m-%d — numeric forms are locale-independent too" },
    };

    for (size_t c = 0; c < sizeof cases / sizeof *cases; c++) {
        printf("\n%s\n", cases[c].what);
        for (size_t i = 0; i < sizeof locales / sizeof *locales; i++)
            row(locales[i], cases[c].fmt);
    }

    /* The time zone comes from TZ, not from the locale — a common mix-up. */
    puts("\nThe zone is set by TZ, not by LC_TIME:");
    setlocale(LC_TIME, "C");
    struct tm t = fixed_time();
    char buf[128];
    strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S %Z(%z)", &t);
    printf("  %s\n", buf);
    return 0;
}

/* LC_COLLATE — strcmp is not dictionary order. strcoll, and sort keys. */
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static const char *words[] = {
    "Zebra", "apfel", "Apfel", "Äpfel", "banane", "Öl", "Zoo", "zoo",
};
#define N (sizeof words / sizeof *words)

static int by_strcmp(const void *a, const void *b)
{ return strcmp(*(const char *const *)a, *(const char *const *)b); }

static int by_strcoll(const void *a, const void *b)
{ return strcoll(*(const char *const *)a, *(const char *const *)b); }

static void sort_and_show(const char *label, int (*cmp)(const void *, const void *))
{
    const char *v[N];
    memcpy(v, words, sizeof v);
    qsort(v, N, sizeof *v, cmp);
    printf("  %-10s", label);
    for (size_t i = 0; i < N; i++) printf(" %s", v[i]);
    putchar('\n');
}

int main(void)
{
    static const char *locales[] = { "C", "en_US.UTF-8", "de_DE.UTF-8", "ko_KR.UTF-8" };

    puts("The same words sorted two ways.");
    printf("  input     ");
    for (size_t i = 0; i < N; i++) printf(" %s", words[i]);
    puts("\n");

    for (size_t i = 0; i < sizeof locales / sizeof *locales; i++) {
        if (!setlocale(LC_ALL, locales[i])) {
            printf("[%s] not on this machine\n\n", locales[i]);
            continue;
        }
        printf("[%s]\n", locales[i]);
        sort_and_show("strcmp", by_strcmp);    /* byte order — locale-independent */
        sort_and_show("strcoll", by_strcoll);  /* the locale's dictionary order */
        putchar('\n');
    }

    /* strxfrm — when comparing many times, build a "sort key" once.
       Keys compared with strcmp come out in the same order as strcoll. */
    puts("strxfrm freezes a locale comparison into a key:");
    for (size_t i = 0; i < sizeof locales / sizeof *locales; i++) {
        if (!setlocale(LC_ALL, locales[i])) continue;

        char key[64];
        size_t need = strxfrm(key, "Äpfel", sizeof key);
        printf("  %-12s \"Äpfel\" -> key of %zu bytes: ", locales[i], need);
        if (need >= sizeof key) { puts("(buffer too small)"); continue; }
        for (size_t k = 0; k < need && k < 12; k++)
            printf("%02X ", (unsigned char)key[k]);
        puts(need > 12 ? "..." : "");
    }

    puts("\nDo the keys compare the same way strcoll does?");
    for (size_t i = 0; i < sizeof locales / sizeof *locales; i++) {
        if (!setlocale(LC_ALL, locales[i])) continue;
        char ka[64], kb[64];
        const char *a = "Äpfel", *b = "banane";
        if (strxfrm(ka, a, sizeof ka) >= sizeof ka) continue;
        if (strxfrm(kb, b, sizeof kb) >= sizeof kb) continue;
        int c1 = strcoll(a, b), c2 = strcmp(ka, kb);
        printf("  %-12s strcoll %s 0, key strcmp %s 0 — %s\n", locales[i],
               c1 < 0 ? "<" : c1 > 0 ? ">" : "=",
               c2 < 0 ? "<" : c2 > 0 ? ">" : "=",
               ((c1 < 0) == (c2 < 0) && (c1 > 0) == (c2 > 0)) ? "same" : "different");
    }
    return 0;
}