/* 에러는 값이다 — 그 값이 실제로 어떤 것들인지 눈으로 본다. */
#include <proven.h>

static const char *name_of(proven_err_t e)
{
    switch (e) {
    case PROVEN_OK:                   return "PROVEN_OK";
    case PROVEN_ERR_NOMEM:            return "NOMEM (out of memory)";
    case PROVEN_ERR_OUT_OF_BOUNDS:    return "OUT_OF_BOUNDS (outside the buffer)";
    case PROVEN_ERR_INVALID_ENCODING: return "INVALID_ENCODING (broken encoding)";
    case PROVEN_ERR_INVALID_ARG:      return "INVALID_ARG (argument outside the contract)";
    case PROVEN_ERR_IO:               return "IO (the outside world failed)";
    case PROVEN_ERR_NOT_FOUND:        return "NOT_FOUND (not there)";
    case PROVEN_ERR_INVALID_STATE:    return "INVALID_STATE (cannot do that now)";
    case PROVEN_ERR_NEED_MORE:        return "NEED_MORE (more input needed)";
    case PROVEN_ERR_OVERFLOW:         return "OVERFLOW (the arithmetic overflowed)";
    case PROVEN_ERR_UNSUPPORTED:      return "UNSUPPORTED (not in this environment)";
    case PROVEN_ERR_AGAIN:            return "AGAIN (not now, try again)";
    case PROVEN_ERR_EOF:              return "EOF (reached the end)";
    case PROVEN_ERR_BUSY:             return "BUSY (someone else is using it)";
    case PROVEN_ERR_PERMISSION:       return "PERMISSION (not allowed)";
    case PROVEN_ERR_INVALID_FORMAT:   return "INVALID_FORMAT (wrong format)";
    }
    return "(unknown)";
}

int main(void)
{
    proven_println("-- every error code --");
    for (int i = PROVEN_OK; i <= PROVEN_ERR_INVALID_FORMAT; i++)
        proven_println("{:>2}  {}", PROVEN_ARG(i), PROVEN_ARG(name_of((proven_err_t)i)));

    proven_println("");
    proven_println("-- which codes actually come back --");

    /* ① 그릇이 모자라다 → OUT_OF_BOUNDS */
    proven_byte_t small[8];
    proven_u8str_t s = proven_u8str_borrow(small, sizeof small);
    proven_err_t e1 = proven_u8str_append(&s, PROVEN_LIT("Hello, world"));
    proven_println("append 12 bytes into 8   -> {}", PROVEN_ARG(name_of(e1)));

    /* 실패 원자성: 거부된 뒤에도 원본은 손대지 않은 상태다 */
    proven_println("  after failure, len = {}",
                   PROVEN_ARG(proven_u8str_as_view(&s).size));

    /* ② 계약을 어긴 인자 → INVALID_ARG.
          쓸 수 없는 할당자(전부 0인 값)를 주면 만들기 전에 걸러낸다. */
    proven_allocator_t nothing = (proven_allocator_t){0};
    proven_result_u8str_t bad = proven_u8str_create(nothing, 16);
    proven_println("create with a null allocator -> {}", PROVEN_ARG(name_of(bad.err)));

    /* ③ 범위 밖 자르기 → OUT_OF_BOUNDS (있는 만큼 주지 않는다) */
    proven_u8str_view_t v = PROVEN_LIT("abcdefgh");
    proven_result_mem_view_t sl =
        proven_mem_view_slice_checked(proven_mem_view_from_u8(v), 6, 4);
    proven_println("slice 4 bytes from 6/8   -> {}", PROVEN_ARG(name_of(sl.err)));

    /* ④ 성공은 언제나 0이고, 확인은 언제나 같은 한 줄이다 */
    proven_err_t ok = proven_u8str_append(&s, PROVEN_LIT("hi"));
    proven_println("append 2 bytes into 8    -> {} (is_ok={})",
                   PROVEN_ARG(name_of(ok)), PROVEN_ARG(proven_is_ok(ok)));
    return 0;
}

#include <proven.h>
#include <stdio.h>

/* 실패할 수 있는 일을 한다: 정해진 용량의 문자열에 두 조각을 붙인다.
   에러는 값으로 돌아오고, 호출자는 그것을 그대로 위로 전달한다. */
static proven_err_t make_greeting(proven_allocator_t alloc,
                                  const char *who,
                                  proven_size_t cap,
                                  proven_u8str_t *out)
{
    proven_result_u8str_t made = proven_u8str_create(alloc, cap);
    if (!proven_is_ok(made.err))
        return made.err;                 /* 실패를 위로 넘긴다 */

    proven_u8str_t s = made.value;       /* 확인한 뒤에야 value 를 쓴다 */

    proven_err_t e = proven_u8str_append(&s, proven_u8str_view_from_cstr("Hello, "));
    if (proven_is_ok(e))
        e = proven_u8str_append(&s, proven_u8str_view_from_cstr(who));
    if (!proven_is_ok(e)) {
        proven_u8str_destroy(alloc, &s); /* 실패했으면 뒷정리도 우리 몫 */
        return e;
    }

    *out = s;
    return PROVEN_OK;
}

static void try(proven_allocator_t alloc, const char *who, proven_size_t cap)
{
    proven_u8str_t s;
    proven_err_t e = make_greeting(alloc, who, cap, &s);

    if (!proven_is_ok(e)) {
        printf("cap=%2zu who=%-8s -> failed with error code %d\n",
               cap, who, (int)e);
        return;
    }
    proven_u8str_view_t v = proven_u8str_as_view(&s);
    printf("cap=%2zu who=%-8s -> \"%.*s\"\n",
           cap, who, (int)v.size, (const char *)v.ptr);
    proven_u8str_destroy(alloc, &s);
}

int main(void)
{
    proven_allocator_t alloc = proven_heap_allocator();

    try(alloc, "world", 32);   /* 넉넉하다 */
    try(alloc, "world", 8);    /* 자리가 모자란다 — 자르지 않고 거부한다 */

    printf("PROVEN_OK is %d, and every failure is non-zero\n", (int)PROVEN_OK);
    return 0;
}

/* 실패 경로에서 자원을 흘리지 않는 법 — 한 곳에 모아 역순으로 정리한다.
   75장에서 본 `goto cleanup` 관용구가 proven 의 에러 값과 만나는 자리다. */
#include <proven.h>

/* 실패를 흉내 내기 위한 할당자: n 번째 할당부터는 반드시 실패한다. */
typedef struct {
    proven_allocator_t base;
    int                budget;   /* 남은 성공 횟수 */
} failing_ctx_t;

static proven_result_mem_mut_t failing_alloc(void *ctx, proven_size_t size,
                                             proven_size_t align)
{
    failing_ctx_t *f = (failing_ctx_t *)ctx;
    if (f->budget <= 0)
        return (proven_result_mem_mut_t){ .err = PROVEN_ERR_NOMEM };
    f->budget--;
    return f->base.alloc_fn(f->base.ctx, size, align);
}

static proven_result_mem_mut_t failing_realloc(void *ctx, void *old_ptr,
                                               proven_size_t old_size,
                                               proven_size_t new_size,
                                               proven_size_t align)
{
    failing_ctx_t *f = (failing_ctx_t *)ctx;
    if (f->budget <= 0)
        return (proven_result_mem_mut_t){ .err = PROVEN_ERR_NOMEM };
    f->budget--;
    return f->base.realloc_fn(f->base.ctx, old_ptr, old_size, new_size, align);
}

static void failing_free(void *ctx, void *ptr)
{
    failing_ctx_t *f = (failing_ctx_t *)ctx;
    f->base.free_fn(f->base.ctx, ptr);
}

/* 자원 둘을 잡고 일하는 함수. 어디서 실패하든 잡은 것만 정확히 되돌린다. */
static proven_err_t join_two(proven_allocator_t alloc,
                             proven_u8str_view_t a,
                             proven_u8str_view_t b,
                             proven_u8str_t *out)
{
    proven_err_t   err   = PROVEN_OK;
    bool           has_x = false;
    proven_u8str_t x;                       /* 첫 번째 자원 */
    proven_u8str_t y;                       /* 두 번째 자원 */

    proven_result_u8str_t rx = proven_u8str_create_from_view(alloc, a);
    if (!proven_is_ok(rx.err)) { err = rx.err; goto done; }
    x = rx.value; has_x = true;

    proven_result_u8str_t ry = proven_u8str_create_from_view(alloc, b);
    if (!proven_is_ok(ry.err)) { err = ry.err; goto done; }
    y = ry.value;

    /* 두 조각을 이어 붙인다 — 모자라면 늘린다(할당자가 필요한 이유) */
    err = proven_u8str_append_grow(alloc, &y, proven_u8str_as_view(&x));
    if (!proven_is_ok(err)) { proven_u8str_destroy(alloc, &y); goto done; }

    *out = y;                               /* 성공: y 의 소유권을 넘긴다 */
                                            /* x 는 아래에서 반납된다 */
done:
    if (has_x) proven_u8str_destroy(alloc, &x);   /* 잡았으면 반드시 되돌린다 */
    return err;
}

static void run(int budget)
{
    proven_allocator_t heap = proven_heap_allocator();
    failing_ctx_t      ctx  = { .base = heap, .budget = budget };
    proven_allocator_t alloc = {
        .ctx = &ctx, .alloc_fn = failing_alloc,
        .realloc_fn = failing_realloc, .free_fn = failing_free,
    };

    proven_u8str_t out;
    proven_err_t e = join_two(alloc, PROVEN_LIT("world"), PROVEN_LIT("hello, "), &out);

    if (proven_is_ok(e)) {
        proven_println("budget={} -> ok: \"{}\"  (budget left {})",
                       PROVEN_ARG(budget), PROVEN_ARG(proven_u8str_as_view(&out)),
                       PROVEN_ARG(ctx.budget));
        proven_u8str_destroy(alloc, &out);
    } else {
        proven_println("budget={} -> failed (code {}) - everything taken was given back",
                       PROVEN_ARG(budget), PROVEN_ARG((int)e));
    }
}

int main(void)
{
    run(0);   /* 첫 할당부터 실패 */
    run(1);   /* 첫 자원은 잡고 두 번째에서 실패 → x 를 흘리면 누수다 */
    run(9);   /* 전부 성공 */
    return 0;
}