/* 나쁜 예 - 테스트 불가 */
int g_status = 0;

void process_data(void) {
    if (g_status == 1) {
        /* 뭔가 함 */
    }
}

/* 좋은 예 - 테스트 가능 */
void process_data(int status) {
    if (status == 1) {
        /* 뭔가 함 */
    }
}

/* 나쁜 예 */
void read_config(void) {
    FILE *f = fopen("/etc/myapp.conf", "r");
    /* ... */
}

/* 좋은 예 */
int read_config(FILE *config_file) {
    /* config_file로 읽기 */
    /* 테스트에서 tmpfile()이나 메모리 스트림 사용 가능 */
}

/* 함수 포인터로 의존성 주입 */
typedef int (*send_func_t)(const char *data, int len);

int process_and_send(const char *data, send_func_t send_fn) {
    /* 처리 후 send_fn 호출 */
    return send_fn(data, strlen(data));
}

/* 테스트에서 */
int mock_send(const char *data, int len) {
    /* 실제로 보내지 않고 검증만 */
    return len;
}

void test_process_and_send(void) {
    int result = process_and_send("hello", mock_send);
    TEST_ASSERT_EQUAL_INT(5, result);
}

int proc(int x, int y, int t) {
    int r = 0;
    if (t == 1) r = x + y;
    else if (t == 2) r = x - y;
    else if (t == 3) r = x * y;
    return r;
}

typedef enum {
    OPERATION_ADD = 1,
    OPERATION_SUBTRACT = 2,
    OPERATION_MULTIPLY = 3
} OperationType;

int calculate(int operand_a, int operand_b, OperationType operation) {
    int result = 0;
    if (operation == OPERATION_ADD)      result = operand_a + operand_b;
    else if (operation == OPERATION_SUBTRACT) result = operand_a - operand_b;
    else if (operation == OPERATION_MULTIPLY) result = operand_a * operand_b;
    return result;
}

void process_order(Order *order) {
    /* 주문 유효성 검사 - 50줄 */
    if (order == NULL) return;
    if (order->quantity <= 0) { /* ... */ }
    if (order->price < 0) { /* ... */ }
    /* ... 더 많은 검사들 ... */
    
    /* 재고 확인 - 80줄 */
    int stock = get_stock(order->product_id);
    if (stock < order->quantity) { /* ... */ }
    /* ... */
    
    /* 결제 처리 - 100줄 */
    /* ... */
}

static int validate_order(const Order *order) {
    if (order == NULL) return -1;
    if (order->quantity <= 0) return -2;
    if (order->price < 0) return -3;
    /* ... */
    return 0;
}

static int check_inventory(const Order *order) {
    int stock = get_stock(order->product_id);
    if (stock < order->quantity) return -1;
    /* ... */
    return 0;
}

static int process_payment(const Order *order) {
    /* ... */
    return 0;
}

void process_order(Order *order) {
    if (validate_order(order) != 0) return;
    if (check_inventory(order) != 0) return;
    if (process_payment(order) != 0) return;
}

/* globals.h */
extern int g_connection_count;
extern int g_max_connections;
extern char g_server_ip[64];
extern int g_port;
extern int g_timeout_ms;
extern int g_is_connected;

/* 여러 파일에서 이 변수들을 직접 수정 */

/* server_context.h */
typedef struct {
    int connection_count;
    int max_connections;
    char server_ip[64];
    int port;
    int timeout_ms;
    int is_connected;
} ServerContext;

/* 접근자 함수 제공 */
ServerContext* server_context_get(void);
int server_context_init(const char *ip, int port, int max_conn);
void server_context_destroy(void);

/* server_context.c */
static ServerContext g_ctx = {0};  /* 단 하나의 전역 변수 */

ServerContext* server_context_get(void) {
    return &g_ctx;
}

/* Before - 화살표 코드 (Arrow Code) */
int process(Data *data) {
    int result = -1;
    if (data != NULL) {
        if (data->is_valid) {
            if (data->size > 0) {
                if (data->buffer != NULL) {
                    /* 실제 처리 */
                    result = do_work(data);
                }
            }
        }
    }
    return result;
}

/* After - 조기 반환 패턴 */
int process(Data *data) {
    if (data == NULL)        return -1;
    if (!data->is_valid)     return -2;
    if (data->size <= 0)     return -3;
    if (data->buffer == NULL) return -4;
    
    return do_work(data);
}

/* Before */
void set_mode(int mode) {
    if (mode == 0) init_normal();
    else if (mode == 1) init_debug();
    else if (mode == 2) init_test();
    else if (mode == 99) emergency_shutdown();
}

/* After */
typedef enum {
    MODE_NORMAL    = 0,
    MODE_DEBUG     = 1,
    MODE_TEST      = 2,
    MODE_EMERGENCY = 99
} AppMode;

void set_mode(AppMode mode) {
    switch (mode) {
        case MODE_NORMAL:    init_normal();        break;
        case MODE_DEBUG:     init_debug();         break;
        case MODE_TEST:      init_test();          break;
        case MODE_EMERGENCY: emergency_shutdown(); break;
        default:
            /* 알 수 없는 모드 처리 */
            break;
    }
}

/* 안전한 free 매크로 */
#define SAFE_FREE(ptr) do { \
    if ((ptr) != NULL) {    \
        free(ptr);          \
        (ptr) = NULL;       \
    }                       \
} while(0)

/* 사용 */
char *buffer = malloc(1024);
/* ... 사용 ... */
SAFE_FREE(buffer);  /* 해제 후 NULL로 설정 */
/* 이제 buffer를 실수로 다시 사용해도 NULL 체크로 잡힘 */

/* 소유권 전달 명확히 표시 */
/* 반환된 포인터는 호출자가 free() 해야 함 */
char* create_message(const char *template, int id);

/* 소유권 없음 - 해제하면 안 됨 */
/* 반환된 포인터는 내부 버퍼를 가리킴 */
const char* get_error_string(int error_code);

/* C89: 함수 시작에만 선언 가능 */
void old_style(void) {
    int i, result, temp;
    /* ... 100줄 후에 사용 ... */
    for (i = 0; i < 10; i++) { /* ... */ }
}

/* C99: 사용하는 곳 근처에 선언 */
void new_style(void) {
    for (int i = 0; i < 10; i++) {
        int result = compute(i);
        /* result 바로 사용 */
    }
}

/* C89 */
Config cfg;
cfg.width = 800;
cfg.height = 600;
cfg.depth = 32;

/* C99 - 훨씬 명확! */
Config cfg = {
    .width  = 800,
    .height = 600,
    .depth  = 32
};

/* C99 */
void process(int n) {
    int buffer[n];  /* 스택에 동적 크기 배열 */
    /* 단, 스택 오버플로우 위험 있으니 크기 제한 필요 */
}

#include <stdbool.h>

/* C89 */
int is_valid = 1;  /* 0 or 1 */

/* C99 */
bool is_valid = true;  /* 의도가 명확함 */

#include <stdint.h>

/* C89 - 플랫폼마다 크기가 다를 수 있음 */
unsigned long counter;  /* 32bit? 64bit? */

/* C99 - 명확한 크기 */
uint32_t counter;   /* 항상 32비트 */
uint64_t big_num;   /* 항상 64비트 */
int8_t small_val;   /* 항상 8비트 부호있는 정수 */

#include <assert.h>

/* 구조체 크기가 예상과 다르면 컴파일 에러 */
_Static_assert(sizeof(PacketHeader) == 16,
               "PacketHeader 크기가 16바이트여야 합니다");

/* 플랫폼 가정 검증 */
_Static_assert(sizeof(int) == 4,
               "이 코드는 32비트 int를 가정합니다");

#include <stdnoreturn.h>

noreturn void fatal_error(const char *msg) {
    fprintf(stderr, "치명적 오류: %s\n", msg);
    exit(EXIT_FAILURE);
}

/* C11 */
typedef struct {
    int type;
    union {
        int   int_val;
        float float_val;
        char  str_val[32];
    };  /* 익명 공용체 - 멤버에 직접 접근 가능 */
} Value;

Value v;
v.type = 1;
v.int_val = 42;  /* v.u.int_val 대신 직접 접근 */

/* 위험 → 안전 */
gets(buffer)           → fgets(buffer, sizeof(buffer), stdin)
strcpy(dst, src)       → strncpy(dst, src, sizeof(dst)-1); dst[sizeof(dst)-1] = '\0';
                         또는 strlcpy(dst, src, sizeof(dst))  /* BSD/macOS */
strcat(dst, src)       → strncat(dst, src, sizeof(dst)-strlen(dst)-1)
sprintf(buf, fmt, ...) → snprintf(buf, sizeof(buf), fmt, ...)
scanf("%s", buf)       → scanf("%255s", buf)  /* 크기 제한 */

/* 안전한 문자열 복사 - 항상 NULL 종료 보장 */
static int safe_strcpy(char *dst, size_t dst_size, const char *src) {
    if (dst == NULL || src == NULL || dst_size == 0) return -1;
    
    size_t src_len = strlen(src);
    if (src_len >= dst_size) {
        /* 잘림 발생 - 로그 남기기 */
        src_len = dst_size - 1;
    }
    memcpy(dst, src, src_len);
    dst[src_len] = '\0';
    return (int)src_len;
}

/* sensor.h - 공개 인터페이스만 노출 */
#ifndef SENSOR_H
#define SENSOR_H

#include <stdint.h>
#include <stdbool.h>

/* 불투명 포인터 (Opaque Pointer) - 내부 구현 숨기기 */
typedef struct Sensor Sensor;

/* 생성/소멸 */
Sensor* sensor_create(int device_id);
void    sensor_destroy(Sensor *sensor);

/* 동작 */
bool    sensor_read(Sensor *sensor, float *out_value);
bool    sensor_calibrate(Sensor *sensor);

#endif /* SENSOR_H */

/* sensor.c - 내부 구현 */
#include "sensor.h"
#include <stdlib.h>

struct Sensor {
    int device_id;
    float calibration_offset;
    bool is_initialized;
    /* 내부 상태들 - 외부에서 직접 접근 불가 */
};

Sensor* sensor_create(int device_id) {
    Sensor *s = calloc(1, sizeof(Sensor));
    if (s == NULL) return NULL;
    s->device_id = device_id;
    s->is_initialized = false;
    return s;
}

void sensor_destroy(Sensor *sensor) {
    free(sensor);
}

/* 인터페이스 정의 */
typedef struct {
    int  (*open)(const char *path);
    int  (*read)(int fd, void *buf, size_t len);
    int  (*write)(int fd, const void *buf, size_t len);
    void (*close)(int fd);
} FileOps;

/* 구현체 1: 실제 파일 시스템 */
static const FileOps real_file_ops = {
    .open  = real_open,
    .read  = real_read,
    .write = real_write,
    .close = real_close
};

/* 구현체 2: 테스트용 메모리 파일 시스템 */
static const FileOps mock_file_ops = {
    .open  = mock_open,
    .read  = mock_read,
    .write = mock_write,
    .close = mock_close
};

/* 사용 */
void process_file(const FileOps *ops, const char *path) {
    int fd = ops->open(path);
    /* ... */
    ops->close(fd);
}

/* 프로덕션 */
process_file(&real_file_ops, "/data/input.bin");

/* 테스트 */
process_file(&mock_file_ops, "test_input");

# .clang-format 예시
BasedOnStyle: LLVM
IndentWidth: 4
ColumnLimit: 100
AllowShortFunctionsOnASingleLine: None
BreakBeforeBraces: Linux

# clang-tidy 실행 예시
clang-tidy myfile.c -- -I./include -std=c11

# 자동 수정
clang-tidy --fix myfile.c -- -I./include

#!/bin/sh
# .git/hooks/pre-commit

# 커밋 전 자동 포맷 체크
files=$(git diff --cached --name-only --diff-filter=ACM | grep '\.c$\|\.h$')
if [ -n "$files" ]; then
    clang-format --dry-run --Werror $files
    if [ $? -ne 0 ]; then
        echo "코드 포맷 오류! clang-format을 실행하세요."
        exit 1
    fi
fi

# .github/workflows/ci.yml
name: C 코드 품질 검사

on: [push, pull_request]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: 빌드
        run: |
          cmake -B build -DCMAKE_BUILD_TYPE=Debug
          cmake --build build
      
      - name: 단위 테스트 실행
        run: cmake --build build --target test
      
      - name: 정적 분석 (cppcheck)
        run: |
          cppcheck --error-exitcode=1 \
                   --enable=all \
                   --suppress=missingIncludeSystem \
                   src/
      
      - name: 코드 커버리지
        run: |
          cmake -B build-cov \
                -DCMAKE_BUILD_TYPE=Debug \
                -DCOVERAGE=ON
          cmake --build build-cov
          cd build-cov && ctest
          lcov --capture --directory . --output-file coverage.info
          lcov --remove coverage.info '/usr/*' --output-file coverage.info

/* TODO(담당자, 날짜): 설명
 * 예: TODO(kim, 2024-01): 이 함수를 두 개로 분리해야 함
 */

/* FIXME(담당자): 알려진 버그
 * 예: FIXME(lee): 멀티스레드 환경에서 race condition 가능성
 */

/* HACK: 임시 해결책 - 나중에 제대로 고쳐야 함
 * 예: HACK: 메모리 정렬 문제로 인한 임시 패딩
 */

/* DEPRECATED: 더 이상 사용하지 말 것
 * 대신 new_function()을 사용하세요
 */

gcc -pg -o myapp myapp.c
./myapp
gprof myapp gmon.out | head -30

valgrind --tool=callgrind ./myapp
callgrind_annotate callgrind.out.PID

perf record ./myapp
perf report

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

#define BENCHMARK(name, iterations, code) do { \
    clock_t start = clock();                    \
    for (int _i = 0; _i < (iterations); _i++) { \
        code;                                   \
    }                                           \
    clock_t end = clock();                      \
    double elapsed = (double)(end - start) / CLOCKS_PER_SEC; \
    printf("[%s] %d회 실행: %.4f초 (평균: %.2f ns)\n", \
           name, iterations, elapsed,           \
           elapsed * 1e9 / (iterations));       \
} while(0)

/* 사용 예 */
BENCHMARK("old_function", 1000000, old_function(data));
BENCHMARK("new_function", 1000000, new_function(data));

/* restrict 키워드 - 포인터 앨리어싱 없음을 컴파일러에 알림 */
void vector_add(float * restrict dst,
                const float * restrict a,
                const float * restrict b,
                int n) {
    for (int i = 0; i < n; i++) {
        dst[i] = a[i] + b[i];
    }
}

/* inline 힌트 */
static inline int max(int a, int b) {
    return a > b ? a : b;
}

/* likely/unlikely 힌트 (GCC/Clang 확장) */
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

if (unlikely(ptr == NULL)) {
    /* 에러 처리 - 거의 발생 안 하는 경우 */
    return -1;
}

/* sensor.c - 레거시 버전 (실제로 이런 코드 많음 ㅋㅋ) */
#include <stdio.h>
#include <string.h>

int s = 0;          /* 센서 상태 */
float d[100];       /* 데이터 버퍼 */
int dc = 0;         /* 데이터 카운트 */
int e = 0;          /* 에러 코드 */
char msg[256];      /* 메시지 버퍼 */

void init() {
    s = 0;
    dc = 0;
    e = 0;
    memset(d, 0, sizeof(d));
}

int rd(int id) {
    if (s == 0) {
        e = 1;
        return -1;
    }
    /* 하드웨어 레지스터 직접 접근 */
    float v = *((volatile float*)0x40001000 + id);
    if (v < -100.0 || v > 100.0) {
        e = 2;
        sprintf(msg, "err: val=%f", v);
        return -1;
    }
    if (dc < 100) {
        d[dc++] = v;
    }
    return 0;
}

float avg() {
    if (dc == 0) return 0.0;
    float sum = 0;
    int i;
    for (i = 0; i < dc; i++) sum += d[i];
    return sum / dc;
}

/* sensor.h - 현대화된 버전 */
#ifndef SENSOR_H
#define SENSOR_H

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

/* 상수 정의 */
#define SENSOR_MAX_SAMPLES    100
#define SENSOR_VALUE_MIN    -100.0f
#define SENSOR_VALUE_MAX     100.0f

/* 에러 코드 */
typedef enum {
    SENSOR_OK              = 0,
    SENSOR_ERR_NOT_INIT    = -1,
    SENSOR_ERR_INVALID_VAL = -2,
    SENSOR_ERR_BUFFER_FULL = -3,
    SENSOR_ERR_NO_DATA     = -4
} SensorError;

/* 하드웨어 추상화 - 테스트 가능하게 */
typedef float (*sensor_read_hw_fn)(int sensor_id);

/* 불투명 핸들 */
typedef struct SensorContext SensorContext;

/* API */
SensorContext* sensor_create(sensor_read_hw_fn read_fn);
void           sensor_destroy(SensorContext *ctx);
SensorError    sensor_read(SensorContext *ctx, int sensor_id);
SensorError    sensor_get_average(const SensorContext *ctx, float *out_avg);
const char*    sensor_error_string(SensorError err);

#endif /* SENSOR_H */

/* sensor.c - 현대화된 구현 */
#include "sensor.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct SensorContext {
    sensor_read_hw_fn read_hw;
    float samples[SENSOR_MAX_SAMPLES];
    int   sample_count;
    bool  is_initialized;
};

SensorContext* sensor_create(sensor_read_hw_fn read_fn) {
    if (read_fn == NULL) return NULL;
    
    SensorContext *ctx = calloc(1, sizeof(SensorContext));
    if (ctx == NULL) return NULL;
    
    ctx->read_hw = read_fn;
    ctx->is_initialized = true;
    return ctx;
}

void sensor_destroy(SensorContext *ctx) {
    if (ctx != NULL) {
        memset(ctx, 0, sizeof(*ctx));  /* 민감한 데이터 지우기 */
        free(ctx);
    }
}

static bool is_value_valid(float value) {
    return (value >= SENSOR_VALUE_MIN && value <= SENSOR_VALUE_MAX);
}

SensorError sensor_read(SensorContext *ctx, int sensor_id) {
    if (ctx == NULL || !ctx->is_initialized) return SENSOR_ERR_NOT_INIT;
    if (ctx->sample_count >= SENSOR_MAX_SAMPLES) return SENSOR_ERR_BUFFER_FULL;
    
    float value = ctx->read_hw(sensor_id);
    
    if (!is_value_valid(value)) return SENSOR_ERR_INVALID_VAL;
    
    ctx->samples[ctx->sample_count++] = value;
    return SENSOR_OK;
}

SensorError sensor_get_average(const SensorContext *ctx, float *out_avg) {
    if (ctx == NULL || out_avg == NULL) return SENSOR_ERR_NOT_INIT;
    if (ctx->sample_count == 0) return SENSOR_ERR_NO_DATA;
    
    float sum = 0.0f;
    for (int i = 0; i < ctx->sample_count; i++) {
        sum += ctx->samples[i];
    }
    *out_avg = sum / (float)ctx->sample_count;
    return SENSOR_OK;
}

const char* sensor_error_string(SensorError err) {
    switch (err) {
        case SENSOR_OK:              return "성공";
        case SENSOR_ERR_NOT_INIT:    return "초기화되지 않음";
        case SENSOR_ERR_INVALID_VAL: return "유효하지 않은 값";
        case SENSOR_ERR_BUFFER_FULL: return "버퍼 가득 참";
        case SENSOR_ERR_NO_DATA:     return "데이터 없음";
        default:                     return "알 수 없는 오류";
    }
}

/* test_sensor.c - 테스트 코드 */
#include "unity.h"
#include "sensor.h"

/* 테스트용 하드웨어 시뮬레이터 */
static float mock_hw_value = 25.0f;

static float mock_read_hw(int sensor_id) {
    (void)sensor_id;  /* 미사용 매개변수 경고 억제 */
    return mock_hw_value;
}

static SensorContext *ctx;

void setUp(void) {
    ctx = sensor_create(mock_read_hw);
}

void tearDown(void) {
    sensor_destroy(ctx);
    ctx = NULL;
}

void test_sensor_create_success(void) {
    TEST_ASSERT_NOT_NULL(ctx);
}

void test_sensor_read_normal_value(void) {
    mock_hw_value = 25.0f;
    SensorError err = sensor_read(ctx, 0);
    TEST_ASSERT_EQUAL_INT(SENSOR_OK, err);
}

void test_sensor_read_invalid_value(void) {
    mock_hw_value = 999.0f;  /* 범위 초과 */
    SensorError err = sensor_read(ctx, 0);
    TEST_ASSERT_EQUAL_INT(SENSOR_ERR_INVALID_VAL, err);
}

void test_sensor_get_average(void) {
    mock_hw_value = 10.0f;
    sensor_read(ctx, 0);
    mock_hw_value = 20.0f;
    sensor_read(ctx, 0);
    mock_hw_value = 30.0f;
    sensor_read(ctx, 0);
    
    float avg;
    SensorError err = sensor_get_average(ctx, &avg);
    TEST_ASSERT_EQUAL_INT(SENSOR_OK, err);
    TEST_ASSERT_FLOAT_WITHIN(0.001f, 20.0f, avg);
}

/* 레거시 함수 */
int old_process(char *buf, int len) { /* ... */ }

/* 새 래퍼 - 점진적으로 내부를 교체 */
ProcessResult new_process(const ProcessInput *input) {
    /* 처음에는 레거시 호출 */
    char buf[1024];
    int result = old_process(buf, sizeof(buf));
    
    /* 나중에 이 부분을 새 구현으로 교체 */
    return convert_result(result, buf);
}