/* UTF-8 을 직접 읽는다 — 규칙, 그리고 거절해야 하는 것들(RFC 3629). */
#include <stdio.h>
#include <stddef.h>
#include <string.h>

/* UTF-8 의 규칙은 표 하나로 끝난다.
     0xxxxxxx                            → 1바이트, U+0000..U+007F
     110xxxxx 10xxxxxx                   → 2바이트, U+0080..U+07FF
     1110xxxx 10xxxxxx 10xxxxxx          → 3바이트, U+0800..U+FFFF
     11110xxx 10xxxxxx 10xxxxxx 10xxxxxx → 4바이트, U+10000..U+10FFFF
   후행 바이트는 언제나 10xxxxxx 다. 그래서 어느 바이트를 보든
   '글자의 시작인지 중간인지' 알 수 있다 — 이것이 자기동기화다. */

typedef enum { OK, BAD_LEAD, BAD_TRAIL, TRUNCATED, OVERLONG, SURROGATE, TOO_BIG } verdict;

static const char *why(verdict v)
{
    switch (v) {
    case OK:        return "ok";
    case BAD_LEAD:  return "a value that cannot be a lead byte";
    case BAD_TRAIL: return "a trail byte that is not 10xxxxxx";
    case TRUNCATED: return "not enough bytes";
    case OVERLONG:  return "overlong encoding - the value could be written shorter";
    case SURROGATE: return "surrogates (U+D800-DFFF) cannot be encoded";
    case TOO_BIG:   return "beyond U+10FFFF";
    }
    return "?";
}

/* 한 글자를 읽는다. 성공하면 소비한 바이트 수를 *len 에 넣는다. */
static verdict decode(const unsigned char *s, size_t n,
                      unsigned long *cp, size_t *len)
{
    if (n == 0) return TRUNCATED;
    unsigned char c = s[0];
    size_t need;
    unsigned long v;

    if (c < 0x80)                  { need = 1; v = c; }
    else if ((c & 0xE0) == 0xC0)   { need = 2; v = c & 0x1Fu; }
    else if ((c & 0xF0) == 0xE0)   { need = 3; v = c & 0x0Fu; }
    else if ((c & 0xF8) == 0xF0)   { need = 4; v = c & 0x07u; }
    else return BAD_LEAD;          /* 10xxxxxx 로 시작하거나 11111xxx */

    if (n < need) return TRUNCATED;
    for (size_t i = 1; i < need; i++) {
        if ((s[i] & 0xC0) != 0x80) return BAD_TRAIL;
        v = (v << 6) | (unsigned long)(s[i] & 0x3Fu);
    }

    /* 여기부터가 '문법은 맞지만 받아들이면 안 되는' 것들이다 */
    static const unsigned long lowest[5] = { 0, 0, 0x80, 0x800, 0x10000 };
    if (v < lowest[need])                return OVERLONG;
    if (v >= 0xD800UL && v <= 0xDFFFUL)  return SURROGATE;
    if (v > 0x10FFFFUL)                  return TOO_BIG;

    *cp = v; *len = need;
    return OK;
}

static void scan(const char *label, const unsigned char *s, size_t n)
{
    printf("\n[%s]", label);
    for (size_t i = 0; i < n; i++) printf(" %02X", s[i]);
    puts("");

    for (size_t pos = 0; pos < n; ) {
        unsigned long cp = 0;
        size_t len = 0;
        verdict v = decode(s + pos, n - pos, &cp, &len);
        if (v == OK) {
            printf("  %zu bytes -> U+%04lX\n", len, cp);
            pos += len;
        } else {
            printf("  rejected: %s\n", why(v));
            pos += 1;                /* 한 바이트만 버리고 다시 맞춘다 */
            break;
        }
    }
}

int main(void)
{
    /* 정상 */
    scan("ASCII", (const unsigned char *)"Hi", 2);
    scan("the Hangul syllable '한'", (const unsigned char *)"\xED\x95\x9C", 3);
    scan("emoji", (const unsigned char *)"\xF0\x9F\x98\x80", 4);

    /* 거절해야 하는 것들 */
    scan("starts with a trail byte", (const unsigned char *)"\x9C", 1);
    scan("three bytes cut short", (const unsigned char *)"\xED\x95", 2);
    scan("a byte that is not a trail byte", (const unsigned char *)"\xED\x41\x9C", 3);
    scan("overlong encoding C0 80", (const unsigned char *)"\xC0\x80", 2);
    scan("surrogate ED A0 80", (const unsigned char *)"\xED\xA0\x80", 3);
    scan("out of range F5 80 80 80", (const unsigned char *)"\xF5\x80\x80\x80", 4);

    puts("\nself-synchronization - point at any byte and you can find the character boundary:");
    const unsigned char *s = (const unsigned char *)"a한글b";
    size_t n = strlen((const char *)s);
    for (size_t i = 0; i < n; i++)
        printf("  byte %zu (%02X): %s\n", i, s[i],
               (s[i] & 0xC0) == 0x80 ? "inside a character" : "start of a character");
    return 0;
}

/* '글자 수'는 세 가지다 — 바이트, 코드포인트, 그리고 사람이 보는 글자. */
#include <locale.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>

/* 사람이 보는 한 글자(그래핌 클러스터)의 완전한 규칙은 유니코드 UAX #29 에
   있고, 제대로 구현하려면 표가 필요하다. 여기서는 자주 만나는 네 가지만
   추린 *간이 규칙*으로 센다 — 개념을 눈으로 보는 것이 목적이다.
     ① 결합 표시(U+0300~U+036F 등)는 앞 글자에 붙는다
     ② 한글 조합 자모(U+1100~U+11FF)는 앞 글자에 붙는다
     ③ ZWJ(U+200D) 다음 글자는 앞 글자에 붙는다
     ④ 지역 표시자(U+1F1E6~U+1F1FF)는 둘이 하나가 된다(국기) */
static int is_combining(unsigned long c)
{
    return (c >= 0x0300 && c <= 0x036F)     /* 결합 발음 기호 */
        || (c >= 0x1160 && c <= 0x11FF)     /* 한글 조합 중성·종성 */
        || (c >= 0xFE00 && c <= 0xFE0F)     /* 변이 선택자 */
        || (c >= 0x1F3FB && c <= 0x1F3FF);  /* 피부색 수정자 */
}
static int is_regional(unsigned long c) { return c >= 0x1F1E6 && c <= 0x1F1FF; }

static void measure(const char *label, const char *s)
{
    size_t bytes = strlen(s);
    size_t cps = 0, clusters = 0;

    mbstate_t st;
    memset(&st, 0, sizeof st);

    unsigned long prev = 0;
    int prev_was_zwj = 0, prev_regional = 0;

    for (size_t pos = 0; pos < bytes; ) {
        wchar_t wc = 0;
        size_t r = mbrtowc(&wc, s + pos, bytes - pos, &st);
        if (r == (size_t)-1 || r == (size_t)-2) break;
        if (r == 0) r = 1;
        pos += r;
        cps++;

        unsigned long c = (unsigned long)wc;
        int joins = (cps > 1) && (is_combining(c) || prev_was_zwj || c == 0x200D
                                  || (is_regional(c) && prev_regional));
        if (!joins) clusters++;

        prev_was_zwj = (c == 0x200D);
        prev_regional = is_regional(c) && !prev_regional;
        prev = c;
    }
    (void)prev;

    printf("  bytes %2zu  code points %2zu  visible characters %2zu   %s\n",
           bytes, cps, clusters, label);
}

int main(void)
{
    const char *loc = setlocale(LC_CTYPE, "C.UTF-8");
    if (!loc) loc = setlocale(LC_CTYPE, "en_US.UTF-8");
    if (!loc) { puts("no UTF-8 locale - skipping this demonstration"); return 0; }

    puts("[the same letter can be written two ways]");
    measure("\"가\" precomposed U+AC00",            "\uAC00");
    measure("\"가\" decomposed U+1100 U+1161",     "\u1100\u1161");
    measure("\"e\\u0301\" a combining accent",        "e\u0301");
    measure("\"\\u00E9\" a precomposed letter",    "\u00E9");

    puts("\n[an emoji can be several code points that look like one character]");
    measure("a smiling face",              "\U0001F600");
    measure("a family (joined with ZWJ)", "\U0001F468\u200D\U0001F469\u200D\U0001F467");
    measure("a flag (two regional indicators)", "\U0001F1F0\U0001F1F7");
    measure("a waving hand + skin tone",     "\U0001F44B\U0001F3FD");

    puts("\n[one sentence]");
    measure("\"Hello, 세계!\"", "Hello, 세계!");

    puts("\nin short: before asking for a 'character count', decide *which layer* you are counting.");
    puts("  bytes = the unit of storage and transmission,  code points = the unit of Unicode,");
    puts("  grapheme clusters = what the cursor steps over at once (UAX #29).");
    puts("the count above is a simplified version using four common rules - a complete decision");
    puts("belongs to a dedicated library such as ICU.");
    return 0;
}

/* 레거시 2바이트 인코딩 — 후행 바이트가 아스키와 겹칠 때 무슨 일이 나는가. */
#include <stdio.h>
#include <string.h>

/* 인코딩마다 '선행 바이트'와 '후행 바이트'의 범위가 다르다.
   위험한 것은 후행 바이트 범위가 아스키 영역과 겹치는 인코딩이다. */
static void show_table(void)
{
    puts("byte ranges per encoding (two-byte characters)");
    puts("  encoding    lead byte          trail byte            can 0x5C('\\') be a trail?");
    puts("  EUC-KR      A1-FE              A1-FE                 no");
    puts("  CP949(UHC)  81-FE              41-5A,61-7A,81-FE     no");
    puts("  Shift_JIS   81-9F,E0-FC        40-7E,80-FC           * yes");
    puts("  Big5        81-FE              40-7E,A1-FE           * yes");
    puts("  GBK         81-FE              40-FE (except 7F)     * yes");
}

/* Shift_JIS 로 적은 경로: C:\表\ソ.txt
   表 = 95 5C, ソ = 83 5C — 둘 다 후행 바이트가 0x5C 다(iconv 로 확인). */
static const unsigned char sjis_path[] = {
    'C', ':', 0x5C, 0x95, 0x5C, 0x5C, 0x83, 0x5C, '.', 't', 'x', 't', 0
};

/* EUC-KR 로 적은 경로: C:\한글.txt  (한 = C7 D1, 글 = B1 DB) */
static const unsigned char euckr_path[] = {
    'C', ':', 0x5C, 0xC7, 0xD1, 0xB1, 0xDB, '.', 't', 'x', 't', 0
};

static int sjis_is_lead(unsigned char c)
{ return (c >= 0x81 && c <= 0x9F) || (c >= 0xE0 && c <= 0xFC); }

static int euckr_is_lead(unsigned char c) { return c >= 0xA1 && c <= 0xFE; }

/* 선행 바이트를 건너뛰며 마지막 구분자를 찾는다 — 올바른 방법 */
static long safe_last_sep(const unsigned char *s, int (*is_lead)(unsigned char))
{
    long last = -1;
    for (size_t i = 0; s[i]; ) {
        if (is_lead(s[i]) && s[i + 1]) { i += 2; continue; }  /* 두 바이트 문자 */
        if (s[i] == 0x5C) last = (long)i;
        i += 1;
    }
    return last;
}

static void dump(const char *label, const unsigned char *s)
{
    printf("  %-10s", label);
    for (size_t i = 0; s[i]; i++) printf(" %02X", s[i]);
    puts("");
}

static void test(const char *name, const unsigned char *path,
                 int (*is_lead)(unsigned char))
{
    printf("\n[%s]\n", name);
    dump("bytes", path);

    /* 흔히 쓰는 방법 — 바이트만 보고 마지막 '\' 를 찾는다 */
    const char *hit = strrchr((const char *)path, 0x5C);
    long naive = hit ? (long)(hit - (const char *)path) : -1;
    long safe  = safe_last_sep(path, is_lead);

    printf("  last '\\' found by strrchr:     position %ld\n", naive);
    printf("  a scan that knows lead bytes:  position %ld\n", safe);
    if (naive == safe) puts("  -> the same. Safe in this encoding.");
    else {
        puts("  -> different! strrchr mistook the *trail byte* of a character for the separator.");
        printf("     cutting there leaves the file name as the broken fragment \"");
        for (size_t i = (size_t)naive + 1; path[i]; i++) printf("%02X ", path[i]);
        puts("\".");
    }
}

int main(void)
{
    show_table();
    test("Shift_JIS: C:\\表\\ソ.txt", sjis_path, sjis_is_lead);
    test("EUC-KR: C:\\한글.txt", euckr_path, euckr_is_lead);

    puts("\nthis accident is famous enough to have a name - in Japan, 'dame-moji' (ダメ文字),");
    puts("typically letters such as 表, ソ, 十 and ダ. UTF-8 does not have the problem:");
    puts("its trail bytes are always 0x80 or above, so they never collide with ASCII.");

    const unsigned char utf8_path[] = "C:\\한글.txt";
    dump("UTF-8", utf8_path);
    const char *h = strrchr((const char *)utf8_path, 0x5C);
    printf("  last '\\' found by strrchr:     position %ld - always right\n",
           h ? (long)(h - (const char *)utf8_path) : -1);
    return 0;
}