/* 파일 하나의 한살이 — 열기 모드, 부분 쓰기, 위치, 그리고 안전한 저장.
   바깥 세계와 닿는 자리에서 실패가 어떻게 값으로 오는지 본다. */
#include <proven.h>

/* 읽은 바이트를 글자로 보기 위한 도우미 (매크로 인자에 쉼표를 넣지 않으려고) */
static proven_u8str_view_t as_text(const proven_byte_t *p, proven_size_t n)
{
    return (proven_u8str_view_t){ .ptr = p, .size = n };
}

static const char *codename(proven_err_t e)
{
    switch (e) {
    case PROVEN_OK:               return "OK";
    case PROVEN_ERR_NOT_FOUND:    return "NOT_FOUND";
    case PROVEN_ERR_PERMISSION:   return "PERMISSION";
    case PROVEN_ERR_IO:           return "IO";
    case PROVEN_ERR_EOF:          return "EOF";
    case PROVEN_ERR_INVALID_ARG:  return "INVALID_ARG";
    default:                      return "(other)";
    }
}

int main(void)
{
    proven_allocator_t scratch = proven_heap_allocator();
    proven_u8str_view_t path = PROVEN_LIT("build/ch77-demo.txt");

    /* ── ① 열기 — 모드는 비트 깃발을 엮는다 ──────────────────── */
    proven_result_file_t opened = proven_fs_open(
        scratch, path,
        PROVEN_FS_WRITE | PROVEN_FS_CREATE | PROVEN_FS_TRUNC);
    if (!proven_is_ok(opened.err)) {
        proven_println("failed to open: {}", PROVEN_ARG(codename(opened.err)));
        return 1;
    }
    proven_file_t f = opened.value;
    proven_println("open            -> OK (write, create, truncate)");

    /* ── ② 쓰기의 두 판 ──────────────────────────────────────── */
    proven_u8str_view_t line = PROVEN_LIT("first line\nsecond line\n");

    /* _write 는 "실제로 쓴 양"을 돌려준다 — 부분 쓰기가 있을 수 있다 */
    proven_result_size_t w = proven_fs_write(f, proven_mem_view_from_u8(line));
    proven_println("write           -> err={} bytes written={} (asked for {})",
                   PROVEN_ARG(codename(w.err)), PROVEN_ARG(w.value),
                   PROVEN_ARG(line.size));

    /* _write_all 은 다 쓸 때까지 되풀이한 뒤 성공/실패만 알려 준다 */
    proven_err_t e = proven_fs_write_all(f, proven_mem_view_from_u8(PROVEN_LIT("third\n")));
    proven_println("write_all       -> {} (what most code actually wants)",
                   PROVEN_ARG(codename(e)));

    /* ── ③ 디스크에 못박기 — flush 와 sync 는 다르다 ──────────── */
    e = proven_fs_sync(f);
    proven_println("sync            -> {} (only this far does it survive a power cut)",
                   PROVEN_ARG(codename(e)));

    proven_result_size_t sz = proven_fs_size(f);
    proven_result_u64_t at = proven_fs_tell(f);
    proven_println("size={} tell={}", PROVEN_ARG(sz.value), PROVEN_ARG(at.val));
    (void)proven_fs_close(f);

    /* ── ④ 읽기 — 요청량과 읽은 양은 다르다 ──────────────────── */
    proven_result_file_t ro = proven_fs_open(scratch, path, PROVEN_FS_READ);
    if (proven_is_ok(ro.err)) {
        proven_file_t r = ro.value;
        proven_byte_t buf[16];
        proven_result_size_t got = proven_fs_read(r, (proven_mem_mut_t){ buf, sizeof buf });
        proven_println("read(16)        -> bytes read={} \"{}\"",
                       PROVEN_ARG(got.value),
                       PROVEN_ARG(as_text(buf, got.value)));

        /* 위치를 되돌리고 다시 읽는다 */
        (void)proven_fs_seek(r, 0, PROVEN_FS_SEEK_SET);
        proven_result_size_t again = proven_fs_read(r, (proven_mem_mut_t){ buf, 5 });
        proven_println("seek(0)+read(5) -> {} bytes", PROVEN_ARG(again.value));
        (void)proven_fs_close(r);
    }

    /* ── ⑤ 한 번에 읽기 — 파일 크기를 모를 때 ────────────────── */
    proven_result_u8str_t all = proven_fs_read_all_u8str(scratch, path);
    if (proven_is_ok(all.err)) {
        proven_u8str_t s = all.value;
        proven_println("read_all        -> {} bytes (the whole file at once)",
                       PROVEN_ARG(proven_u8str_as_view(&s).size));
        proven_u8str_destroy(scratch, &s);
    }

    /* ── ⑥ 없는 파일 — 실패는 값으로 온다 ────────────────────── */
    proven_result_file_t missing =
        proven_fs_open(scratch, PROVEN_LIT("build/no-such-file.txt"), PROVEN_FS_READ);
    proven_println("opening a missing file -> {} (check which code the platform layer maps it to)",
                   PROVEN_ARG(codename(missing.err)));

    /* ── ⑦ 원자적 저장 — 임시 파일에 쓰고 바꿔치기 ───────────── */
    e = proven_fs_write_file_atomic(scratch, PROVEN_LIT("build/ch77-atomic.txt"),
                                    proven_mem_view_from_u8(PROVEN_LIT("all or nothing\n")));
    proven_println("write_file_atomic -> {} (no half-written file is left behind)",
                   PROVEN_ARG(codename(e)));

    (void)proven_fs_remove(scratch, path);
    (void)proven_fs_remove(scratch, PROVEN_LIT("build/ch77-atomic.txt"));
    return 0;
}

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

int main(void)
{
    proven_allocator_t alloc = proven_heap_allocator();
    proven_u8str_view_t path = proven_u8str_view_from_cstr("proven_demo.txt");
    const char *text = "one\ntwo\nthree\n";

    /* 쓰기: 없으면 만들고, 있으면 비운다 */
    proven_result_file_t opened = proven_fs_open(
        alloc, path, PROVEN_FS_WRITE | PROVEN_FS_CREATE | PROVEN_FS_TRUNC);
    if (!proven_is_ok(opened.err)) {
        printf("open for write failed (err=%d)\n", (int)opened.err);
        return 1;
    }
    proven_file_t f = opened.value;

    proven_mem_view_t src = {
        .ptr = (const proven_byte_t *)text,
        .size = proven_cstr_len(text)
    };
    proven_err_t e = proven_fs_write_all(f, src);   /* 부분 쓰기를 되풀이해 준다 */
    printf("write_all  : %s (%zu bytes)\n", proven_is_ok(e) ? "ok" : "failed", src.size);
    (void)proven_fs_close(f);

    /* 읽기 */
    opened = proven_fs_open(alloc, path, PROVEN_FS_READ);
    if (!proven_is_ok(opened.err)) return 1;
    f = opened.value;

    proven_result_size_t sz = proven_fs_size(f);
    printf("size       : %zu bytes\n", sz.value);

    proven_byte_t buf[64];
    proven_result_size_t got = proven_fs_read(f, (proven_mem_mut_t){ .ptr = buf, .size = sizeof buf });
    printf("read       : %zu bytes\n", got.value);

    /* 읽은 것은 뷰로 다룬다 — 줄 단위로 자른다 */
    proven_u8str_view_t all = { .ptr = buf, .size = got.value };
    proven_u8str_view_t nl = proven_u8str_view_from_cstr("\n");
    proven_size_t start = 0;
    int line = 0;
    while (start < all.size) {
        proven_size_t hit = proven_u8str_view_find(all, start, nl);
        proven_size_t end = (hit == PROVEN_INDEX_NOT_FOUND) ? all.size : hit;
        proven_u8str_view_t v = proven_u8str_view_slice(all, start, end - start);
        printf("  line %d   : %.*s\n", ++line, (int)v.size, (const char *)v.ptr);
        if (hit == PROVEN_INDEX_NOT_FOUND) break;
        start = hit + 1;
    }
    (void)proven_fs_close(f);

    /* 없는 파일을 열면 실패가 값으로 온다 */
    proven_result_file_t missing = proven_fs_open(
        alloc, proven_u8str_view_from_cstr("no_such_file.txt"), PROVEN_FS_READ);
    printf("missing    : %s\n", proven_is_ok(missing.err) ? "opened" : "refused with an error code");

    (void)proven_fs_remove(alloc, path);
    return 0;
}

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

int main(void)
{
    /* 재현 가능한 난수: 같은 씨앗 = 같은 수열. 시험과 시뮬레이션용이다 */
    proven_xoshiro256ss_t g;
    proven_xoshiro256ss_seed(&g, 12345);
    proven_rng_t rng = proven_xoshiro256ss_rng(&g);

    printf("seeded run 1:");
    for (int i = 0; i < 5; i++) printf(" %llu", (unsigned long long)proven_rng_below(rng, 100));
    printf("\n");

    proven_xoshiro256ss_seed(&g, 12345);          /* 같은 씨앗으로 되감는다 */
    printf("seeded run 2:");
    for (int i = 0; i < 5; i++) printf(" %llu", (unsigned long long)proven_rng_below(rng, 100));
    printf("\n");

    /* 범위 난수: 경계를 포함한다 */
    proven_xoshiro256ss_seed(&g, 7);
    printf("dice        :");
    for (int i = 0; i < 8; i++) printf(" %lld", (long long)proven_rng_range(rng, 1, 6));
    printf("\n");

    /* 비밀에 쓸 난수는 여기서 얻지 않는다 — OS 난수원이 따로 있다 */
    proven_byte_t key[16];
    bool ok = proven_random_bytes(key, sizeof key);
    printf("os entropy  : %s (%zu bytes requested)\n", ok ? "available" : "unavailable", sizeof key);
    return 0;
}