/* struct lconv — 로케일이 숫자와 통화에 대해 아는 것 전부. */
#include <limits.h>
#include <locale.h>
#include <stdio.h>

/* 문자열 멤버: 비어 있으면 눈에 보이게 표시한다 */
static const char *str(const char *s) { return (s && *s) ? s : "(empty string)"; }

/* char 멤버: CHAR_MAX 는 "이 로케일은 정하지 않았다"는 뜻이다 */
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);
}

/* grouping 문자열의 인코딩:
     각 바이트가 그 자리의 그룹 자릿수. CHAR_MAX 면 "더는 묶지 않는다",
     0 이면 "직전 값을 계속 되풀이한다". "\3" 은 3자리씩 무한, en_IN 은 "\3\2". */
static void show_grouping(const char *name, const char *g)
{
    printf("%-20s ", name);
    if (!*g) { puts("(empty string - 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("[non-monetary 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("[rules for assembling a monetary amount]");
    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\"  currency \"%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)
{
    /* 시작 로케일은 "C" 다. 표준이 이 값들을 직접 규정한다(§7.11). */
    puts("=== the \"C\" locale - the values the standard prescribes ===");
    dump_all();

    puts("\n=== comparing 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]);

    /* 자리 묶음이 3자리 고정이 아닌 로케일이 있다 — 인도식 표기 */
    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 digits from the right, then two at a time\" -");
    puts("    12345678 groups as 1,23,45,678 (the lakh and crore system).");

    /* 소수점이 바뀌면 printf 와 strtod 가 함께 바뀐다 */
    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 — 같은 시각이 로케일에 따라 다르게 적힌다. 그리고 안 바뀌는 서식. */
#include <locale.h>
#include <stdio.h>
#include <string.h>
#include <time.h>

/* 재현 가능한 시각을 쓴다: 2026-08-06 (목) 15:04:05 UTC */
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,               /* 목요일 */
        .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 weekday and the month" },
        { "%a %b",    "%a %b - abbreviated names of the weekday and the month" },
        { "%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 - a numeric format, also independent of the locale" },
    };

    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);
    }

    /* 시간대는 로케일이 아니라 TZ 환경 변수가 정한다 — 흔한 혼동이다. */
    puts("\nthe time zone comes from TZ, not from 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 는 사전순이 아니다. strcoll 과 정렬 키(strxfrm). */
#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("sorting the same words 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 available on this machine\n\n", locales[i]);
            continue;
        }
        printf("[%s]\n", locales[i]);
        sort_and_show("strcmp", by_strcmp);    /* 바이트 값 순서 — 로케일 무관 */
        sort_and_show("strcoll", by_strcoll);  /* 로케일이 정한 사전 순서 */
        putchar('\n');
    }

    /* strxfrm — 비교를 여러 번 할 때는 '정렬 키'를 한 번 만들어 두는 편이 낫다.
       변환한 키끼리는 strcmp 로 견주어도 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("\nchecking that strcmp on the keys agrees with strcoll:");
    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)) ? "agree" : "disagree");
    }
    return 0;
}