// config.h
#ifndef CONFIG_H
#define CONFIG_H

// 컴파일 시 -DDEBUG 플래그로 디버그 모드 활성화
#ifdef DEBUG
    #define DEBUG_MODE 1
    #define OPTIMIZATION_LEVEL 0
    #define ENABLE_LOGGING 1
    #define ENABLE_ASSERTIONS 1
#else
    #define DEBUG_MODE 0
    #define OPTIMIZATION_LEVEL 3
    #define ENABLE_LOGGING 0
    #define ENABLE_ASSERTIONS 0
#endif

#if ENABLE_LOGGING
    #define LOG(level, fmt, ...) \
        printf("[%s] %s:%d: " fmt "\n", level, __FILE__, __LINE__, ##__VA_ARGS__)
    #define LOG_DEBUG(fmt, ...) LOG("DEBUG", fmt, ##__VA_ARGS__)
    #define LOG_INFO(fmt, ...) LOG("INFO", fmt, ##__VA_ARGS__)
    #define LOG_WARN(fmt, ...) LOG("WARN", fmt, ##__VA_ARGS__)
    #define LOG_ERROR(fmt, ...) LOG("ERROR", fmt, ##__VA_ARGS__)
#else
    #define LOG_DEBUG(fmt, ...)
    #define LOG_INFO(fmt, ...)
    #define LOG_WARN(fmt, ...)
    #define LOG_ERROR(fmt, ...)
#endif

#if ENABLE_ASSERTIONS
    #define ASSERT(condition) \
        do { \
            if (!(condition)) { \
                fprintf(stderr, "Assertion failed: %s, %s:%d\n", \
                        #condition, __FILE__, __LINE__); \
                abort(); \
            } \
        } while(0)
#else
    #define ASSERT(condition) ((void)0)
#endif

#endif // CONFIG_H

// main.c
#include "config.h"

int divide(int a, int b) {
    ASSERT(b != 0);  // 디버그 모드에서만 체크
    
    LOG_DEBUG("Dividing %d by %d", a, b);
    return a / b;
}

int main() {
    LOG_INFO("Program started");
    
    int result = divide(10, 2);
    LOG_INFO("Result: %d", result);
    
    #if DEBUG_MODE
    printf("Running in DEBUG mode\n");
    printf("Optimization level: %d\n", OPTIMIZATION_LEVEL);
    #else
    printf("Running in RELEASE mode\n");
    #endif
    
    LOG_INFO("Program finished");
    return 0;
}

// 컴파일 방법:
// 디버그: gcc -DDEBUG main.c -o main_debug
// 릴리즈: gcc main.c -o main_release

// platform.h
#ifndef PLATFORM_H
#define PLATFORM_H

// 플랫폼 자동 감지
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS
    #define OS_NAME "Windows"
#elif defined(__linux__)
    #define PLATFORM_LINUX
    #define OS_NAME "Linux"
#elif defined(__APPLE__) && defined(__MACH__)
    #define PLATFORM_MAC
    #define OS_NAME "macOS"
#else
    #define PLATFORM_UNKNOWN
    #define OS_NAME "Unknown"
    #warning "Unknown platform detected"
#endif

// 플랫폼별 함수 선언
#ifdef PLATFORM_WINDOWS
    #include <windows.h>
    #define SLEEP(ms) Sleep(ms)
    #define CLEAR_SCREEN() system("cls")
    #define PATH_MAX MAX_PATH
#else
    #include <unistd.h>
    #define SLEEP(ms) usleep((ms) * 1000)
    #define CLEAR_SCREEN() system("clear")
    #ifndef PATH_MAX
        #define PATH_MAX 4096
    #endif
#endif

// 컴파일러 감지
#if defined(__GNUC__)
    #define COMPILER_GCC
    #define COMPILER_NAME "GCC"
    #define COMPILER_VERSION __VERSION__
#elif defined(_MSC_VER)
    #define COMPILER_MSVC
    #define COMPILER_NAME "MSVC"
    #define STRINGIFY(x) #x
    #define TOSTRING(x) STRINGIFY(x)
    #define COMPILER_VERSION TOSTRING(_MSC_VER)
#elif defined(__clang__)
    #define COMPILER_CLANG
    #define COMPILER_NAME "Clang"
    #define COMPILER_VERSION __clang_version__
#endif

void print_platform_info() {
    printf("Operating System: %s\n", OS_NAME);
    printf("Compiler: %s\n", COMPILER_NAME);
    printf("Compiler Version: %s\n", COMPILER_VERSION);
}

#endif // PLATFORM_H

// features.h
#ifndef FEATURES_H
#define FEATURES_H

// 기능 플래그 정의
#define FEATURE_DATABASE 1
#define FEATURE_NETWORKING 1
#define FEATURE_GRAPHICS 0
#define FEATURE_AUDIO 0
#define FEATURE_ENCRYPTION 1

// 기능별 조건부 컴파일
#if FEATURE_DATABASE
    #include "database.h"
    #define DB_CONNECT(host) db_connect(host)
    #define DB_QUERY(sql) db_query(sql)
#else
    #define DB_CONNECT(host) ((void)0)
    #define DB_QUERY(sql) ((void)0)
#endif

#if FEATURE_NETWORKING
    #include "network.h"
    #define NET_SEND(data) network_send(data)
    #define NET_RECEIVE() network_receive()
#else
    #define NET_SEND(data) ((void)0)
    #define NET_RECEIVE() NULL
#endif

#if FEATURE_ENCRYPTION
    #include "crypto.h"
    #define ENCRYPT(data) encrypt_data(data)
    #define DECRYPT(data) decrypt_data(data)
#else
    #define ENCRYPT(data) (data)
    #define DECRYPT(data) (data)
#endif

void print_enabled_features() {
    printf("Enabled features:\n");
    #if FEATURE_DATABASE
    printf("  - Database\n");
    #endif
    #if FEATURE_NETWORKING
    printf("  - Networking\n");
    #endif
    #if FEATURE_GRAPHICS
    printf("  - Graphics\n");
    #endif
    #if FEATURE_AUDIO
    printf("  - Audio\n");
    #endif
    #if FEATURE_ENCRYPTION
    printf("  - Encryption\n");
    #endif
}

#endif // FEATURES_H

// 잘못된 예
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int x = 5;
int result = MAX(x++, 10);  // x가 두 번 증가할 수 있음!

// 더 안전한 방법 (C99 이상)
#define MAX(a, b) ({ \
    __typeof__(a) _a = (a); \
    __typeof__(b) _b = (b); \
    _a > _b ? _a : _b; \
})

// 또는 inline 함수 사용
static inline int max(int a, int b) {
    return a > b ? a : b;
}

// 문제가 될 수 있는 예
#define SQUARE(x) ((x) * (x))

double d = 3.5;
int result = SQUARE(d);  // 경고 없이 double이 int로 변환됨

// 해결책: 타입별로 다른 함수 사용
static inline int square_int(int x) { return x * x; }
static inline double square_double(double x) { return x * x; }

// 또는 C11의 _Generic 사용
#define SQUARE(x) _Generic((x), \
    int: square_int, \
    double: square_double \
)(x)

// 복잡한 매크로는 디버깅이 어려움
#define COMPLEX_CALC(a, b, c) \
    ((a) * (b) + (c) * ((a) - (b)) / ((c) + 1))

// 해결책: 중간 단계를 변수로 저장
#define COMPLEX_CALC_DEBUG(a, b, c) ({ \
    int _a = (a), _b = (b), _c = (c); \
    int _step1 = _a * _b; \
    int _step2 = _a - _b; \
    int _step3 = _c * _step2; \
    int _step4 = _c + 1; \
    _step1 + _step3 / _step4; \
})

// 좋은 매크로 예제
#define SAFE_FREE(ptr) \
    do { \
        if ((ptr) != NULL) { \
            free(ptr); \
            (ptr) = NULL; \
        } \
    } while(0)

#define ARRAY_LENGTH(arr) \
    (sizeof(arr) / sizeof((arr)[0]))

#define UNUSED(x) ((void)(x))

#define LIKELY(x) __builtin_expect(!!(x), 1)
#define UNLIKELY(x) __builtin_expect(!!(x), 0)

// 사용 예
int main() {
    int* data = malloc(100 * sizeof(int));
    
    // ... 데이터 사용 ...
    
    SAFE_FREE(data);  // NULL 체크와 포인터 초기화를 자동으로!
    
    int numbers[] = {1, 2, 3, 4, 5};
    for (size_t i = 0; i < ARRAY_LENGTH(numbers); i++) {
        printf("%d ", numbers[i]);
    }
    
    return 0;
}

#include <stdio.h>

#define BUILD_INFO() \
    printf("Build Info:\n"); \
    printf("  File: %s\n", __FILE__); \
    printf("  Date: %s\n", __DATE__); \
    printf("  Time: %s\n", __TIME__); \
    printf("  C Standard: %ldL\n", __STDC_VERSION__)

#define TRACE() \
    printf("[TRACE] %s:%d in %s()\n", __FILE__, __LINE__, __func__)

#define LOG_FUNCTION_ENTRY() \
    printf(">>> Entering %s() at %s:%d\n", __func__, __FILE__, __LINE__)

#define LOG_FUNCTION_EXIT() \
    printf("<<< Exiting %s() at %s:%d\n", __func__, __FILE__, __LINE__)

void example_function() {
    LOG_FUNCTION_ENTRY();
    
    printf("Doing some work...\n");
    TRACE();
    
    LOG_FUNCTION_EXIT();
}

int main() {
    BUILD_INFO();
    printf("\n");
    
    example_function();
    
    return 0;
}

/* 출력 예:
Build Info:
  File: main.c
  Date: Dec 25 2024
  Time: 14:30:25
  C Standard: 201112L

>>> Entering example_function() at main.c:15
Doing some work...
[TRACE] main.c:18 in example_function()
<<< Exiting example_function() at main.c:20
*/

// memory_debug.h
#ifndef MEMORY_DEBUG_H
#define MEMORY_DEBUG_H

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

#ifdef DEBUG_MEMORY

typedef struct {
    void* ptr;
    size_t size;
    const char* file;
    int line;
} MemoryAllocation;

#define MAX_ALLOCATIONS 10000
static MemoryAllocation allocations[MAX_ALLOCATIONS];
static int allocation_count = 0;

static void* debug_malloc(size_t size, const char* file, int line) {
    void* ptr = malloc(size);
    if (ptr && allocation_count < MAX_ALLOCATIONS) {
        allocations[allocation_count].ptr = ptr;
        allocations[allocation_count].size = size;
        allocations[allocation_count].file = file;
        allocations[allocation_count].line = line;
        allocation_count++;
        printf("[MALLOC] %zu bytes at %p (%s:%d)\n", size, ptr, file, line);
    }
    return ptr;
}

static void debug_free(void* ptr, const char* file, int line) {
    for (int i = 0; i < allocation_count; i++) {
        if (allocations[i].ptr == ptr) {
            printf("[FREE] %p (%s:%d) - originally allocated at %s:%d\n",
                   ptr, file, line, allocations[i].file, allocations[i].line);
            free(ptr);
            allocations[i] = allocations[--allocation_count];
            return;
        }
    }
    printf("[FREE] %p (%s:%d) - WARNING: not tracked!\n", ptr, file, line);
    free(ptr);
}

static void print_memory_leaks() {
    if (allocation_count > 0) {
        printf("\n=== MEMORY LEAKS DETECTED ===\n");
        for (int i = 0; i < allocation_count; i++) {
            printf("Leak: %zu bytes at %p (allocated at %s:%d)\n",
                   allocations[i].size, allocations[i].ptr,
                   allocations[i].file, allocations[i].line);
        }
        printf("Total leaks: %d allocations\n", allocation_count);
    } else {
        printf("\n=== NO MEMORY LEAKS ===\n");
    }
}

#define malloc(size) debug_malloc(size, __FILE__, __LINE__)
#define free(ptr) debug_free(ptr, __FILE__, __LINE__)
#define CHECK_LEAKS() print_memory_leaks()

#else

#define CHECK_LEAKS() ((void)0)

#endif // DEBUG_MEMORY

#endif // MEMORY_DEBUG_H

// 사용 예
#define DEBUG_MEMORY
#include "memory_debug.h"

int main() {
    int* array1 = malloc(10 * sizeof(int));
    int* array2 = malloc(20 * sizeof(int));
    
    // array1 사용
    for (int i = 0; i < 10; i++) {
        array1[i] = i;
    }
    
    free(array1);
    // array2는 해제하지 않음 (의도적인 메모리 누수)
    
    CHECK_LEAKS();  // 메모리 누수 보고서 출력
    return 0;
}

// performance.h
#ifndef PERFORMANCE_H
#define PERFORMANCE_H

#include <time.h>
#include <stdio.h>

#ifdef ENABLE_PROFILING

#define PROFILE_START(name) \
    clock_t _profile_start_##name = clock(); \
    printf("[PROFILE] Starting: %s\n", #name)

#define PROFILE_END(name) \
    do { \
        clock_t _profile_end_##name = clock(); \
        double _profile_time_##name = \
            ((double)(_profile_end_##name - _profile_start_##name)) / CLOCKS_PER_SEC; \
        printf("[PROFILE] %s took %.6f seconds\n", #name, _profile_time_##name); \
    } while(0)

#define PROFILE_FUNCTION() \
    clock_t _func_start = clock(); \
    printf("[PROFILE] Entering function: %s\n", __func__); \
    void _profile_cleanup() { \
        clock_t _func_end = clock(); \
        double _func_time = ((double)(_func_end - _func_start)) / CLOCKS_PER_SEC; \
        printf("[PROFILE] %s took %.6f seconds\n", __func__, _func_time); \
    } \
    __attribute__((cleanup(_profile_cleanup))) int _dummy = 0; \
    (void)_dummy

#else

#define PROFILE_START(name) ((void)0)
#define PROFILE_END(name) ((void)0)
#define PROFILE_FUNCTION() ((void)0)

#endif // ENABLE_PROFILING

#endif // PERFORMANCE_H

// 사용 예
#define ENABLE_PROFILING
#include "performance.h"

void slow_function() {
    PROFILE_FUNCTION();
    
    // 시간이 오래 걸리는 작업 시뮬레이션
    for (volatile int i = 0; i < 100000000; i++);
}

int main() {
    PROFILE_START(main_execution);
    
    PROFILE_START(initialization);
    // 초기화 코드
    for (volatile int i = 0; i < 50000000; i++);
    PROFILE_END(initialization);
    
    slow_function();
    
    PROFILE_START(cleanup);
    // 정리 코드
    for (volatile int i = 0; i < 30000000; i++);
    PROFILE_END(cleanup);
    
    PROFILE_END(main_execution);
    return 0;
}

// test_framework.h
#ifndef TEST_FRAMEWORK_H
#define TEST_FRAMEWORK_H

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

static int _test_count = 0;
static int _test_passed = 0;
static int _test_failed = 0;

#define TEST_SUITE(name) \
    printf("\n=== Test Suite: %s ===\n", name)

#define TEST_CASE(name) \
    printf("\nTest: %s\n", name); \
    _test_count++

#define ASSERT_TRUE(condition) \
    do { \
        if (condition) { \
            printf("  ✓ PASS: %s\n", #condition); \
            _test_passed++; \
        } else { \
            printf("  ✗ FAIL: %s (at %s:%d)\n", #condition, __FILE__, __LINE__); \
            _test_failed++; \
        } \
    } while(0)

#define ASSERT_FALSE(condition) ASSERT_TRUE(!(condition))

#define ASSERT_EQUAL(a, b) \
    do { \
        if ((a) == (b)) { \
            printf("  ✓ PASS: %s == %s\n", #a, #b); \
            _test_passed++; \
        } else { \
            printf("  ✗ FAIL: %s != %s (at %s:%d)\n", #a, #b, __FILE__, __LINE__); \
            printf("    Expected: %d, Got: %d\n", (int)(b), (int)(a)); \
            _test_failed++; \
        } \
    } while(0)

#define ASSERT_STRING_EQUAL(a, b) \
    do { \
        if (strcmp(a, b) == 0) { \
            printf("  ✓ PASS: %s == %s\n", #a, #b); \
            _test_passed++; \
        } else { \
            printf("  ✗ FAIL: %s != %s (at %s:%d)\n", #a, #b, __FILE__, __LINE__); \
            printf("    Expected: \"%s\", Got: \"%s\"\n", b, a); \
            _test_failed++; \
        } \
    } while(0)

#define TEST_SUMMARY() \
    do { \
        printf("\n=== Test Summary ===\n"); \
        printf("Total tests: %d\n", _test_count); \
        printf("Assertions: %d\n", _test_passed + _test_failed); \
        printf("Passed: %d\n", _test_passed); \
        printf("Failed: %d\n", _test_failed); \
        if (_test_failed == 0) { \
            printf("Result: ✓ ALL TESTS PASSED\n"); \
        } else { \
            printf("Result: ✗ SOME TESTS FAILED\n"); \
        } \
    } while(0)

#endif // TEST_FRAMEWORK_H

// 사용 예
#include "test_framework.h"

int add(int a, int b) {
    return a + b;
}

int multiply(int a, int b) {
    return a * b;
}

const char* get_greeting() {
    return "Hello, World!";
}

int main() {
    TEST_SUITE("Math Functions");
    
    TEST_CASE("Addition");
    ASSERT_EQUAL(add(2, 3), 5);
    ASSERT_EQUAL(add(-1, 1), 0);
    ASSERT_EQUAL(add(0, 0), 0);
    
    TEST_CASE("Multiplication");
    ASSERT_EQUAL(multiply(2, 3), 6);
    ASSERT_EQUAL(multiply(-2, 3), -6);
    ASSERT_EQUAL(multiply(0, 100), 0);
    
    TEST_SUITE("String Functions");
    
    TEST_CASE("Greeting");
    ASSERT_STRING_EQUAL(get_greeting(), "Hello, World!");
    ASSERT_TRUE(strlen(get_greeting()) > 0);
    
    TEST_SUMMARY();
    
    return _test_failed > 0 ? 1 : 0;
}

// config.h - 프로젝트 전역 설정
#ifndef CONFIG_H
#define CONFIG_H

// 버전 정보
#define VERSION_MAJOR 1
#define VERSION_MINOR 2
#define VERSION_PATCH 3
#define VERSION_STRING "1.2.3"

// 빌드 설정
#ifdef RELEASE_BUILD
    #define DEBUG_MODE 0
    #define OPTIMIZATION_LEVEL 3
    #define ENABLE_LOGGING 0
#else
    #define DEBUG_MODE 1
    #define OPTIMIZATION_LEVEL 0
    #define ENABLE_LOGGING 1
#endif

// 플랫폼 설정
#include "platform.h"

// 기능 플래그
#include "features.h"

// 전역 상수
#define MAX_BUFFER_SIZE 4096
#define MAX_CONNECTIONS 100
#define TIMEOUT_SECONDS 30

#endif // CONFIG_H

// platform.h - 플랫폼별 설정
#ifndef PLATFORM_H
#define PLATFORM_H

// 플랫폼 자동 감지
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS 1
    #define PLATFORM_LINUX 0
    #define PLATFORM_MAC 0
#elif defined(__linux__)
    #define PLATFORM_WINDOWS 0
    #define PLATFORM_LINUX 1
    #define PLATFORM_MAC 0
#elif defined(__APPLE__)
    #define PLATFORM_WINDOWS 0
    #define PLATFORM_LINUX 0
    #define PLATFORM_MAC 1
#endif

// 플랫폼별 헤더
#if PLATFORM_WINDOWS
    #include <windows.h>
    #define EXPORT __declspec(dllexport)
    #define IMPORT __declspec(dllimport)
#else
    #define EXPORT __attribute__((visibility("default")))
    #define IMPORT
#endif

// 플랫폼별 함수
#if PLATFORM_WINDOWS
    #define SLEEP_MS(ms) Sleep(ms)
#else
    #define SLEEP_MS(ms) usleep((ms) * 1000)
#endif

#endif // PLATFORM_H

// features.h - 기능 플래그
#ifndef FEATURES_H
#define FEATURES_H

// 기능 활성화/비활성화
#define FEATURE_NETWORKING 1
#define FEATURE_DATABASE 1
#define FEATURE_ENCRYPTION 1
#define FEATURE_COMPRESSION 0
#define FEATURE_GUI 0

// 기능별 설정
#if FEATURE_NETWORKING
    #define MAX_NETWORK_THREADS 10
    #define NETWORK_BUFFER_SIZE 8192
#endif

#if FEATURE_DATABASE
    #define DB_CONNECTION_POOL_SIZE 20
    #define DB_QUERY_TIMEOUT 5000
#endif

#endif // FEATURES_H

// logger.h - 로깅 시스템
#ifndef LOGGER_H
#define LOGGER_H

#include "config.h"
#include <stdio.h>

#if ENABLE_LOGGING

typedef enum {
    LOG_LEVEL_DEBUG,
    LOG_LEVEL_INFO,
    LOG_LEVEL_WARN,
    LOG_LEVEL_ERROR
} LogLevel;

#define LOG(level, fmt, ...) \
    log_message(level, __FILE__, __LINE__, __func__, fmt, ##__VA_ARGS__)

#define LOG_DEBUG(fmt, ...) LOG(LOG_LEVEL_DEBUG, fmt, ##__VA_ARGS__)
#define LOG_INFO(fmt, ...) LOG(LOG_LEVEL_INFO, fmt, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...) LOG(LOG_LEVEL_WARN, fmt, ##__VA_ARGS__)
#define LOG_ERROR(fmt, ...) LOG(LOG_LEVEL_ERROR, fmt, ##__VA_ARGS__)

void log_message(LogLevel level, const char* file, int line,
                const char* func, const char* fmt, ...);

#else

#define LOG_DEBUG(fmt, ...) ((void)0)
#define LOG_INFO(fmt, ...) ((void)0)
#define LOG_WARN(fmt, ...) ((void)0)
#define LOG_ERROR(fmt, ...) ((void)0)

#endif // ENABLE_LOGGING

#endif // LOGGER_H

// main.c - 메인 프로그램
#include "config.h"
#include "logger.h"

int main() {
    LOG_INFO("Application started");
    LOG_INFO("Version: %s", VERSION_STRING);
    
    #if PLATFORM_WINDOWS
    LOG_INFO("Platform: Windows");
    #elif PLATFORM_LINUX
    LOG_INFO("Platform: Linux");
    #elif PLATFORM_MAC
    LOG_INFO("Platform: macOS");
    #endif
    
    #if DEBUG_MODE
    LOG_DEBUG("Running in DEBUG mode");
    #else
    LOG_INFO("Running in RELEASE mode");
    #endif
    
    LOG_INFO("Enabled features:");
    #if FEATURE_NETWORKING
    LOG_INFO("  - Networking");
    #endif
    #if FEATURE_DATABASE
    LOG_INFO("  - Database");
    #endif
    #if FEATURE_ENCRYPTION
    LOG_INFO("  - Encryption");
    #endif
    
    // 실제 프로그램 로직...
    
    LOG_INFO("Application finished");
    return 0;
}

// 컴파일 예:
// 디버그: gcc -DDEBUG main.c logger.c -o app_debug
// 릴리즈: gcc -DRELEASE_BUILD main.c logger.c -o app_release -O3