// UTF-8 인코딩 예시
'A'    (U+0041) → 0x41           (1바이트)
'€'    (U+20AC) → 0xE2 0x82 0xAC (3바이트)  
'가'   (U+AC00) → 0xEA 0xB0 0x80 (3바이트)
'😀'   (U+1F600)→ 0xF0 0x9F 0x98 0x80 (4바이트)

// 기본 문자 타입들
char        // 1바이트, ASCII 문자용
wchar_t     // 와이드 문자, 크기는 시스템 의존적
char16_t    // C11에서 추가, UTF-16용 (2바이트)
char32_t    // C11에서 추가, UTF-32용 (4바이트)

#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    // 로케일 설정 (중요!)
    setlocale(LC_ALL, "");
    
    // 와이드 문자 리터럴
    wchar_t wc = L'가';
    
    // 와이드 문자열 리터럴
    wchar_t *ws = L"안녕하세요! Hello World! 🌍";
    
    // 출력
    wprintf(L"와이드 문자: %lc\n", wc);
    wprintf(L"와이드 문자열: %ls\n", ws);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>

// UTF-8 문자열을 와이드 문자열로 변환
wchar_t* utf8_to_wchar(const char* utf8_str) {
    size_t len = mbstowcs(NULL, utf8_str, 0);
    if (len == (size_t)-1) {
        return NULL; // 변환 실패
    }
    
    wchar_t* wstr = malloc((len + 1) * sizeof(wchar_t));
    if (wstr == NULL) {
        return NULL; // 메모리 할당 실패
    }
    
    mbstowcs(wstr, utf8_str, len + 1);
    return wstr;
}

// 와이드 문자열을 UTF-8로 변환
char* wchar_to_utf8(const wchar_t* wstr) {
    size_t len = wcstombs(NULL, wstr, 0);
    if (len == (size_t)-1) {
        return NULL; // 변환 실패
    }
    
    char* utf8_str = malloc(len + 1);
    if (utf8_str == NULL) {
        return NULL; // 메모리 할당 실패
    }
    
    wcstombs(utf8_str, wstr, len + 1);
    return utf8_str;
}

int main() {
    setlocale(LC_ALL, "");
    
    const char* utf8_input = "Hello 안녕하세요! 🌍";
    
    // UTF-8 → 와이드 문자
    wchar_t* wide_str = utf8_to_wchar(utf8_input);
    if (wide_str) {
        wprintf(L"와이드 문자열: %ls\n", wide_str);
        wprintf(L"길이: %zu 문자\n", wcslen(wide_str));
        
        // 와이드 문자 → UTF-8
        char* back_to_utf8 = wchar_to_utf8(wide_str);
        if (back_to_utf8) {
            printf("다시 UTF-8: %s\n", back_to_utf8);
            free(back_to_utf8);
        }
        
        free(wide_str);
    }
    
    return 0;
}

// 잘못된 예시 - 한글이 깨질 수 있음
#include <stdio.h>

int main() {
    printf("안녕하세요!\n"); // 깨질 수 있음!
    return 0;
}

// 올바른 해결책
#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    // 1. 로케일 설정
    setlocale(LC_ALL, "");
    
    // 2. 와이드 문자 사용
    wprintf(L"안녕하세요!\n");
    
    // 또는 UTF-8 BOM 있는 파일로 저장하고
    printf("안녕하세요!\n");
    
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <wchar.h>
#include <locale.h>

int main() {
    setlocale(LC_ALL, "");
    
    char utf8_str[] = "안녕"; // UTF-8로 인코딩됨
    wchar_t wide_str[] = L"안녕"; // 와이드 문자로 저장
    
    printf("UTF-8 바이트 길이: %zu\n", strlen(utf8_str)); // 6 (한글 1글자 = 3바이트)
    wprintf(L"와이드 문자 길이: %zu\n", wcslen(wide_str)); // 2 (실제 문자 개수)
    
    // 올바른 UTF-8 문자 개수 세기 (간단한 방법)
    int utf8_char_count = 0;
    for (int i = 0; utf8_str[i]; i++) {
        if ((utf8_str[i] & 0xC0) != 0x80) {
            utf8_char_count++;
        }
    }
    printf("UTF-8 문자 개수: %d\n", utf8_char_count); // 2
    
    return 0;
}

#include <stdio.h>
#include <wchar.h>
#include <uchar.h> // C11 이후

// 이식성을 위한 해결책
int main() {
    // C11의 char16_t, char32_t 사용
    char16_t utf16_str[] = u"안녕하세요!";
    char32_t utf32_str[] = U"안녕하세요!";
    
    printf("char16_t 크기: %zu바이트\n", sizeof(char16_t)); // 항상 2바이트
    printf("char32_t 크기: %zu바이트\n", sizeof(char32_t)); // 항상 4바이트
    printf("wchar_t 크기: %zu바이트\n", sizeof(wchar_t));   // 시스템 의존적
    
    return 0;
}

#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() {
    setlocale(LC_ALL, "");
    
    // UTF-8 파일 쓰기
    FILE* fp = fopen("test_utf8.txt", "w");
    if (fp) {
        fprintf(fp, "안녕하세요! Hello World!\n");
        fclose(fp);
    }
    
    // 와이드 문자로 파일 쓰기
    FILE* wfp = fopen("test_wide.txt", "w, ccs=UTF-8"); // Windows 전용
    if (wfp) {
        fwprintf(wfp, L"안녕하세요! Hello World!\n");
        fclose(wfp);
    }
    
    // 파일 읽기
    fp = fopen("test_utf8.txt", "r");
    if (fp) {
        char buffer[256];
        if (fgets(buffer, sizeof(buffer), fp)) {
            printf("읽은 내용: %s", buffer);
        }
        fclose(fp);
    }
    
    return 0;
}

#include <uchar.h>
#include <stdio.h>

int main() {
    // C11의 새로운 문자 타입들
    char8_t  utf8_char = u8'A';      // C23에서 추가
    char16_t utf16_char = u'가';     // UTF-16 문자
    char32_t utf32_char = U'🚀';     // UTF-32 문자
    
    // 문자열 리터럴
    char8_t  utf8_str[] = u8"Hello 안녕!";   // C23
    char16_t utf16_str[] = u"Hello 안녕!";   // C11
    char32_t utf32_str[] = U"Hello 안녕!";   // C11
    
    printf("char8_t 크기: %zu\n", sizeof(char8_t));   // 1바이트
    printf("char16_t 크기: %zu\n", sizeof(char16_t)); // 2바이트
    printf("char32_t 크기: %zu\n", sizeof(char32_t)); // 4바이트
    
    return 0;
}

#include <uchar.h>
#include <stdio.h>
#include <string.h>

int main() {
    char16_t utf16_str[] = u"안녕하세요!";
    char utf8_buffer[256];
    mbstate_t state = {0};
    
    // UTF-16을 UTF-8로 변환
    size_t utf8_len = 0;
    for (size_t i = 0; utf16_str[i]; i++) {
        size_t result = c16rtomb(utf8_buffer + utf8_len, 
                                utf16_str[i], &state);
        if (result != (size_t)-1) {
            utf8_len += result;
        }
    }
    utf8_buffer[utf8_len] = '\0';
    
    printf("UTF-8 결과: %s\n", utf8_buffer);
    
    return 0;
}

// 위험한 코드
char buffer[10];
strcpy(buffer, "안녕하세요"); // 한글 5글자 = 15바이트! 오버플로우!

// 안전한 코드
char buffer[50]; // 충분한 크기 확보
strncpy(buffer, "안녕하세요", sizeof(buffer) - 1);
buffer[sizeof(buffer) - 1] = '\0';

// 더 안전한 방법: 동적 할당
size_t needed = strlen("안녕하세요") + 1;
char* safe_buffer = malloc(needed);
if (safe_buffer) {
    strcpy(safe_buffer, "안녕하세요");
    // 사용 후 해제
    free(safe_buffer);
}

// 실무에서 사용하는 안전한 UTF-8 처리 예시
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

// UTF-8 문자열 유효성 검사
bool is_valid_utf8(const char* str) {
    const unsigned char* bytes = (const unsigned char*)str;
    
    while (*bytes) {
        if (*bytes < 0x80) {
            // ASCII 문자
            bytes++;
        } else if ((*bytes >> 5) == 0x06) {
            // 2바이트 문자
            if ((bytes[1] & 0xC0) != 0x80) return false;
            bytes += 2;
        } else if ((*bytes >> 4) == 0x0E) {
            // 3바이트 문자
            if ((bytes[1] & 0xC0) != 0x80 || 
                (bytes[2] & 0xC0) != 0x80) return false;
            bytes += 3;
        } else if ((*bytes >> 3) == 0x1E) {
            // 4바이트 문자
            if ((bytes[1] & 0xC0) != 0x80 || 
                (bytes[2] & 0xC0) != 0x80 || 
                (bytes[3] & 0xC0) != 0x80) return false;
            bytes += 4;
        } else {
            return false; // 잘못된 UTF-8
        }
    }
    return true;
}

// 안전한 문자열 복사
char* safe_utf8_copy(const char* src, size_t max_bytes) {
    if (!src || !is_valid_utf8(src)) {
        return NULL;
    }
    
    size_t src_len = strlen(src);
    size_t copy_len = (src_len < max_bytes) ? src_len : max_bytes;
    
    char* dest = malloc(copy_len + 1);
    if (!dest) return NULL;
    
    memcpy(dest, src, copy_len);
    dest[copy_len] = '\0';
    
    return dest;
}

int main() {
    const char* test_strings[] = {
        "Hello World!",
        "안녕하세요!",
        "Hello 🌍 World!",
        "\xFF\xFE", // 잘못된 UTF-8
        NULL
    };
    
    for (int i = 0; test_strings[i]; i++) {
        printf("문자열 %d: %s\n", i + 1, 
               is_valid_utf8(test_strings[i]) ? "유효함" : "무효함");
        
        if (is_valid_utf8(test_strings[i])) {
            char* copy = safe_utf8_copy(test_strings[i], 100);
            if (copy) {
                printf("복사됨: %s\n", copy);
                free(copy);
            }
        }
        printf("\n");
    }
    
    return 0;
}

void print_hex(const char* str) {
    printf("16진수: ");
    for (int i = 0; str[i]; i++) {
        printf("%02X ", (unsigned char)str[i]);
    }
    printf("\n");
}

int main() {
    char str[] = "안녕";
    printf("문자열: %s\n", str);
    print_hex(str); // UTF-8 바이트 시퀀스 확인
    return 0;
}

void analyze_utf8(const char* str) {
    const unsigned char* bytes = (const unsigned char*)str;
    int pos = 0;
    
    while (bytes[pos]) {
        printf("위치 %d: ", pos);
        
        if (bytes[pos] < 0x80) {
            printf("ASCII: %c (0x%02X)\n", bytes[pos], bytes[pos]);
            pos++;
        } else if ((bytes[pos] >> 5) == 0x06) {
            printf("2바이트 UTF-8: 0x%02X 0x%02X\n", 
                   bytes[pos], bytes[pos+1]);
            pos += 2;
        } else if ((bytes[pos] >> 4) == 0x0E) {
            printf("3바이트 UTF-8: 0x%02X 0x%02X 0x%02X\n", 
                   bytes[pos], bytes[pos+1], bytes[pos+2]);
            pos += 3;
        } else if ((bytes[pos] >> 3) == 0x1E) {
            printf("4바이트 UTF-8: 0x%02X 0x%02X 0x%02X 0x%02X\n", 
                   bytes[pos], bytes[pos+1], bytes[pos+2], bytes[pos+3]);
            pos += 4;
        } else {
            printf("잘못된 UTF-8: 0x%02X\n", bytes[pos]);
            pos++;
        }
    }
}

// 크로스 플랫폼 유니코드 처리 헤더
#ifndef UNICODE_UTILS_H
#define UNICODE_UTILS_H

#include <stddef.h>

#ifdef _WIN32
    #include <windows.h>
    typedef wchar_t platform_char_t;
    #define PLATFORM_TEXT(x) L##x
#else
    typedef char platform_char_t;
    #define PLATFORM_TEXT(x) x
#endif

// 플랫폼 독립적인 함수들
char* platform_to_utf8(const platform_char_t* str);
platform_char_t* utf8_to_platform(const char* utf8_str);
void platform_print(const char* utf8_str);

#endif

// 구현부
#ifdef _WIN32
char* platform_to_utf8(const platform_char_t* str) {
    int len = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
    char* utf8 = malloc(len);
    WideCharToMultiByte(CP_UTF8, 0, str, -1, utf8, len, NULL, NULL);
    return utf8;
}

platform_char_t* utf8_to_platform(const char* utf8_str) {
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8_str, -1, NULL, 0);
    wchar_t* wide = malloc(len * sizeof(wchar_t));
    MultiByteToWideChar(CP_UTF8, 0, utf8_str, -1, wide, len);
    return wide;
}

void platform_print(const char* utf8_str) {
    wchar_t* wide = utf8_to_platform(utf8_str);
    _putws(wide);
    free(wide);
}
#else
char* platform_to_utf8(const platform_char_t* str) {
    // Unix에서는 이미 UTF-8이므로 복사만
    size_t len = strlen(str) + 1;
    char* copy = malloc(len);
    strcpy(copy, str);
    return copy;
}

platform_char_t* utf8_to_platform(const char* utf8_str) {
    // Unix에서는 이미 UTF-8이므로 복사만
    size_t len = strlen(utf8_str) + 1;
    char* copy = malloc(len);
    strcpy(copy, utf8_str);
    return copy;
}

void platform_print(const char* utf8_str) {
    puts(utf8_str);
}
#endif

// 효율적인 UTF-8 문자 개수 세기
size_t count_utf8_chars_fast(const char* str) {
    size_t count = 0;
    const unsigned char* bytes = (const unsigned char*)str;
    
    // SIMD 최적화 가능한 부분
    while (*bytes) {
        // UTF-8 연속 바이트가 아닌 경우만 카운트
        if ((*bytes & 0xC0) != 0x80) {
            count++;
        }
        bytes++;
    }
    return count;
}

// 버퍼 재사용 예시
typedef struct {
    char* buffer;
    size_t capacity;
} reusable_buffer_t;

void init_buffer(reusable_buffer_t* buf) {
    buf->buffer = NULL;
    buf->capacity = 0;
}

char* get_buffer(reusable_buffer_t* buf, size_t needed_size) {
    if (buf->capacity < needed_size) {
        buf->buffer = realloc(buf->buffer, needed_size);
        buf->capacity = needed_size;
    }
    return buf->buffer;
}

void free_buffer(reusable_buffer_t* buf) {
    free(buf->buffer);
    buf->buffer = NULL;
    buf->capacity = 0;
}