/*
 * vlibc — getline/getdelim, stream locking, memory streams test (todo 18).
 *
 * Exercises the todo-18 additions end to end:
 *
 *   1. getline on a 1 MiB line returns 1000001 (delimiter included) with a
 *      NUL terminator, growing a NULL/zero-capacity buffer from scratch;
 *      the next call at end of file returns -1. Reuse keeps the grown
 *      buffer.
 *   2. getdelim with ',' over "a,b,c\n" yields "a,", "b,", then the
 *      partial final field "c\n" at end of file, then -1.
 *   3. Embedded NUL bytes survive: getline on "ab\0cd\n" returns 6 with
 *      the NUL at line[2] intact (length, not strlen).
 *   4. A small preallocated buffer (malloc(4)) grows to fit a long line.
 *   5. flockfile recursion: two nested flockfile calls, ftrylockfile
 *      failing (nonzero) under the recursion and succeeding (0) when the
 *      stream is free again.
 *   6. getc_unlocked/putc_unlocked under a held flockfile move real data;
 *      getchar_unlocked/putchar_unlocked and puts work over freopen'd
 *      stdin/stdout.
 *   7. fmemopen over a fixed buffer: write, rewind, read back
 *      byte-identical; seeking past the size reads EOF (no error);
 *      fmemopen(NULL, ...) grows and is freed by fclose (leak-checked);
 *      "a" starts at the current data length.
 *   8. open_memstream: after fflush/fclose *sizeloc is the length and the
 *      buffer is NUL-terminated; *ptr tracks the (possibly moved) buffer.
 *   9. fclose over many fmemopen/open_memstream cycles leaks nothing.
 *
 * Failure mode (-f): getline on a stream whose underlying descriptor was
 * closed underneath it returns -1 (the read hits EBADF); the return value
 * is asserted, never errno. -f exits via a raw SYS_exit_group before any
 * host-libc cleanup runs (the tests/syscall_test.c discipline).
 *
 * errno is never READ here; the default mode keeps every library errno
 * write out of the exercised paths. All diagnostics go through raw
 * SYS_write and the only headers are vlibc's own.
 *
 * Not part of the library proper; compiled manually for this todo.
 */

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

#include "../src/internal/syscall.h"

/* The allocator's heap-walk consistency probe (hidden; linked in via
 * malloc.c). Returns the live block count, or (size_t)-1 on disagreement. */
extern size_t
__vlibc_malloc_check(void); // NOLINT(bugprone-reserved-identifier)

static int failures;

/* Write a NUL-terminated string to fd via the raw syscall layer. */
static void
say(int fd, const char *s)
{
    long n = 0;

    while (s[n] != '\0')
    {
        n++;
    }
    __syscall3(SYS_write, fd, (long)s, n);
}

/* Write v in decimal to fd. */
static void
say_dec(int fd, unsigned long v) // NOLINT(bugprone-easily-swappable-parameters)
{
    char buf[24];
    int i = (int)sizeof(buf);

    buf[--i] = '\0';
    do
    {
        buf[--i] = (char)('0' + (v % 10));
        v /= 10;
    } while (v != 0);
    __syscall3(SYS_write, fd, (long)(buf + i), (long)(sizeof(buf) - 1 - i));
}

static void
check(int cond, const char *what)
{
    if (cond)
    {
        say(1, "PASS: ");
        say(1, what);
        say(1, "\n");
    }
    else
    {
        say(2, "FAIL: ");
        say(2, what);
        say(2, "\n");
        failures++;
    }
}

/* Byte-compare two buffers. noipa keeps -O2 from folding the check. */
// NOLINTBEGIN(clang-analyzer-unix.Stream)
static __attribute__((noipa)) int
mem_eq(const unsigned char *a, const unsigned char *b, unsigned long n)
{
    unsigned long i;

    for (i = 0; i < n; i++)
    {
        if (a[i] != b[i])
        {
            return 0;
        }
    }
    return 1;
}

/* Byte-compare two NUL-terminated strings. */
static __attribute__((noipa)) int
str_eq(const char *a, const char *b)
{
    while (*a == *b && *a != '\0')
    {
        a++;
        b++;
    }
    return *a == *b;
}

/* Read a whole small file through raw syscalls into buf; returns size. */
static long
raw_read_all(const char *path, char *buf, unsigned long cap)
{
    long fd = __syscall4(SYS_openat, -100, (long)path, 0x0, 0);
    long got = -1;
    long total = 0;

    if (fd < 0)
    {
        return -1;
    }
    while (total < (long)cap)
    {
        got = __syscall3(SYS_read, fd, (long)(buf + total), (long)(cap - (unsigned long)total));
        if (got <= 0)
        {
            break;
        }
        total += got;
    }
    __syscall1(SYS_close, fd);
    return got < 0 ? -1 : total;
}

/* Write path bytes to a fresh file, then reopen it for reading. */
// NOLINTBEGIN(bugprone-easily-swappable-parameters)
static FILE *
write_file(const char *path, const char *data, unsigned long n)
{
    FILE *f = fopen(path, "w");

    if (f == NULL)
    {
        return NULL;
    }
    if (fwrite(data, 1, n, f) != n)
    {
        (void)fclose(f);
        return NULL;
    }
    if (fclose(f) != 0)
    {
        return NULL;
    }
    f = fopen(path, "r");
    if (f == NULL)
    {
        say(2, "FAIL: write_file reopen\n");
        failures++;
    }
    return f;
}
// NOLINTEND(bugprone-easily-swappable-parameters)

static char onemeg[1000001];

/* 1/3/4: getline length, growth, EOF, embedded NUL. */
static void
line_scenario(void)
{
    const char bigpath[] = "/tmp/vlibc-test-t18-bigline.txt";
    const char nulpath[] = "/tmp/vlibc-test-t18-nul.txt";
    const char longpath[] = "/tmp/vlibc-test-t18-long.txt";
    const char longline[] = "this line is way longer than sixteen bytes\n";
    FILE *f;
    char *line;
    size_t n;
    ssize_t got;
    unsigned long i;

    for (i = 0; i < 1000000; i++)
    {
        onemeg[i] = 'x';
    }
    onemeg[1000000] = '\n';
    f = fopen(bigpath, "w");
    check(f != NULL, "bigline fopen w succeeds");
    if (f == NULL)
    {
        return;
    }
    check(fwrite(onemeg, 1, sizeof(onemeg), f) == sizeof(onemeg), "bigline fwrite 1 MiB + newline");
    check(fclose(f) == 0, "bigline fclose writer");

    f = fopen(bigpath, "r");
    check(f != NULL, "bigline fopen r succeeds");
    line = NULL;
    n = 0;
    got = getline(&line, &n, f);
    check(got == 1000001, "getline on the 1 MiB line returns 1000001");
    check(line != NULL && n >= 1000002, "getline grew the buffer past 1 MiB + NUL");
    if (line != NULL)
    {
        int allx = 1;

        for (i = 0; i < 1000000; i++)
        {
            if (line[i] != 'x')
            {
                allx = 0;
                break;
            }
        }
        check(allx != 0, "the 1 MiB line content is intact");
        check(line[1000000] == '\n', "the newline is kept at line[1000000]");
        check(line[1000001] == '\0', "the line is NUL-terminated");
    }
    got = getline(&line, &n, f);
    check(got == -1, "getline at end of file returns -1");
    free(line);
    check(fclose(f) == 0, "bigline fclose reader");
    check(remove(bigpath) == 0, "bigline remove");

    /* Embedded NUL bytes are data, not terminators. */
    f = write_file(nulpath, "ab\0cd\n", 6);
    if (f != NULL)
    {
        line = NULL;
        n = 0;
        got = getline(&line, &n, f);
        check(got == 6, "getline over \"ab\\0cd\\n\" returns 6 bytes");
        check(line != NULL && line[0] == 'a' && line[1] == 'b' && line[2] == '\0' &&
                  line[3] == 'c' && line[4] == 'd' && line[5] == '\n' && line[6] == '\0',
              "embedded NUL survives and the line is still NUL-terminated");
        free(line);
        check(fclose(f) == 0, "nul fclose");
        check(remove(nulpath) == 0, "nul remove");
    }

    /* A small preallocated buffer grows past its initial capacity. */
    f = write_file(longpath, longline, sizeof(longline) - 1);
    if (f != NULL)
    {
        line = malloc(4);
        check(line != NULL, "small-buffer malloc");
        n = 4;
        got = getline(&line, &n, f);
        check(got == (ssize_t)(sizeof(longline) - 1),
              "getline with a 4-byte buffer reads the whole long line");
        check(n > sizeof(longline) - 1, "the capacity grew past the line length");
        check(line != NULL && str_eq(line, longline), "grown small buffer holds the line");
        free(line);
        check(fclose(f) == 0, "long fclose");
        check(remove(longpath) == 0, "long remove");
    }
}

/* 2: getdelim with a custom delimiter. */
static void
delim_scenario(void)
{
    const char path[] = "/tmp/vlibc-test-t18-delim.txt";
    FILE *f;
    char *line;
    size_t n;
    ssize_t got;

    f = write_file(path, "a,b,c\n", 6);
    check(f != NULL, "delim file setup");
    if (f == NULL)
    {
        return;
    }
    line = NULL;
    n = 0;
    got = getdelim(&line, &n, ',', f);
    check(got == 2 && line != NULL && str_eq(line, "a,"), "getdelim first field is \"a,\"");
    got = getdelim(&line, &n, ',', f);
    check(got == 2 && line != NULL && str_eq(line, "b,"), "getdelim second field is \"b,\"");
    got = getdelim(&line, &n, ',', f);
    check(got == 2 && line != NULL && str_eq(line, "c\n"),
          "getdelim returns the partial final field at end of file");
    got = getdelim(&line, &n, ',', f);
    check(got == -1, "getdelim at end of file returns -1");
    free(line);
    check(fclose(f) == 0, "delim fclose");
    check(remove(path) == 0, "delim remove");
}

/* 5/6: stream locking and the four _unlocked forms. */
static void
lock_scenario(void)
{
    const char rpath[] = "/tmp/vlibc-test-t18-lockr.txt";
    const char wpath[] = "/tmp/vlibc-test-t18-lockw.txt";
    char got[8];
    FILE *f;
    int r0;
    int r1;

    f = fopen(rpath, "w+");
    check(f != NULL, "lock fopen w+ succeeds");
    if (f == NULL)
    {
        return;
    }
    r0 = ftrylockfile(f);
    check(r0 == 0, "ftrylockfile on a free stream returns 0");
    flockfile(f); /* recursion depth 2 */
    flockfile(f); /* recursion depth 3 */
    r1 = ftrylockfile(f);
    check(r1 != 0, "ftrylockfile under the recursion returns nonzero");
    funlockfile(f);
    funlockfile(f);
    funlockfile(f);
    r0 = ftrylockfile(f);
    check(r0 == 0, "ftrylockfile succeeds again after all unlocks");
    funlockfile(f);
    check(fclose(f) == 0, "lock fclose");

    f = write_file(rpath, "MNO", 3);
    check(f != NULL, "unlocked-read setup");
    if (f != NULL)
    {
        flockfile(f);
        check(getc_unlocked(f) == 'M', "getc_unlocked reads 'M' under the lock");
        check(getc_unlocked(f) == 'N', "getc_unlocked reads 'N' under the lock");
        funlockfile(f);
        check(fgetc(f) == 'O', "the locked fgetc still reads 'O' after unlock");
        check(fclose(f) == 0, "unlocked-read fclose");
        check(remove(rpath) == 0, "unlocked-read remove");
    }

    f = fopen(wpath, "w");
    check(f != NULL, "unlocked-write setup");
    if (f != NULL)
    {
        flockfile(f);
        check(putc_unlocked('Q', f) == 'Q', "putc_unlocked writes 'Q' under the lock");
        check(putc_unlocked('R', f) == 'R', "putc_unlocked writes 'R' under the lock");
        funlockfile(f);
        check(fclose(f) == 0, "unlocked-write fclose");
        check(raw_read_all(wpath, got, sizeof(got)) == 2 && got[0] == 'Q' && got[1] == 'R',
              "putc_unlocked data reached the file");
        check(remove(wpath) == 0, "unlocked-write remove");
    }
}

/* 7: fmemopen over a fixed buffer, past-size EOF, NULL-buffer growth, 'a'. */
static void
fmemopen_scenario(void)
{
    char buf[64];
    char out[64];
    FILE *f;
    size_t r;
    int c;

    f = fmemopen(buf, sizeof(buf), "w+");
    check(f != NULL, "fmemopen w+ succeeds");
    if (f == NULL)
    {
        return;
    }
    check(fputs("hello fmemopen", f) >= 0, "fputs into the fixed buffer");
    check(ftello(f) == 14, "ftello == 14 after the write");
    check(fseek(f, 0, SEEK_SET) == 0, "rewind via fseek(0, SEEK_SET)");
    r = fread(out, 1, sizeof(out), f);
    check(r == 14 &&
              mem_eq((const unsigned char *)out, (const unsigned char *)"hello fmemopen", 14),
          "fmemopen write/rewind/read is byte-identical");
    c = fgetc(f);
    check(c == EOF && feof(f), "fmemopen read past the data returns EOF");
    check(fclose(f) == 0, "fmemopen w+ fclose");

    /* Seek beyond the buffer size, then read: EOF, not an error. */
    f = fmemopen(buf, sizeof(buf), "w+");
    if (f != NULL)
    {
        check(fputs("xyz", f) >= 0, "fmemopen setup writes xyz");
        check(fseek(f, 100, SEEK_SET) == 0, "fseek past the size succeeds");
        c = fgetc(f);
        check(c == EOF && feof(f) && ferror(f) == 0, "reading past the size is EOF with no error");
        check(ftello(f) == 100, "ftello stays at the seek target");
        check(fclose(f) == 0, "fmemopen past-size fclose");
    }

    /* 'a' positions and appends at the current data length. */
    {
        char abuf[64] = "hello";
        FILE *g = fmemopen(abuf, sizeof(abuf), "a");

        check(g != NULL, "fmemopen a succeeds");
        if (g != NULL)
        {
            check(ftello(g) == 5, "fmemopen a starts at the current length");
            check(fputs("XY", g) >= 0, "fmemopen a appends");
            check(fclose(g) == 0, "fmemopen a fclose flushes");
            check(mem_eq((const unsigned char *)abuf, (const unsigned char *)"helloXY", 7),
                  "the appended data landed in the caller buffer");
            check(abuf[7] == '\0', "string-mode fmemopen NUL-terminates at the length");
        }
    }
}

/* open_memstream: publish on flush, grow, NUL-terminate, free on close. */
static void
memstream_scenario(void)
{
    char *p = NULL;
    size_t z = 0;
    FILE *f;

    f = open_memstream(&p, &z);
    check(f != NULL && p != NULL && z == 0, "open_memstream returns a stream and an empty buffer");
    if (f == NULL)
    {
        return;
    }
    check(fputs("hello", f) >= 0, "open_memstream write 1");
    check(fflush(f) == 0, "open_memstream fflush 1");
    check(z == 5, "*sizeloc is the length after fflush");
    check(p != NULL && p[5] == '\0' &&
              mem_eq((const unsigned char *)p, (const unsigned char *)"hello", 5),
          "the flushed buffer is NUL-terminated at the length");
    check(fputs(" world", f) >= 0, "open_memstream write 2");
    check(fflush(f) == 0, "open_memstream fflush 2");
    check(z == 11 && p != NULL && p[11] == '\0',
          "the grown length and NUL are published after the second fflush");
    check(fclose(f) == 0, "open_memstream fclose");
    check(z == 11 && p != NULL && p[11] == '\0', "fclose keeps the NUL-terminated result");
    check(mem_eq((const unsigned char *)p, (const unsigned char *)"hello world", 11),
          "the open_memstream content is correct");
    free(p);
}

/* 9: no leaks across repeated memory-stream open/close cycles. */
static void
memstream_leak_scenario(void)
{
    const char *data = "0123456789abcdef0123456789abcdef0123456789abcdef";
    size_t before;
    size_t after;
    int i;

    before = __vlibc_malloc_check();
    check(before != (size_t)-1, "allocator heap walk is consistent before the cycles");
    if (before == (size_t)-1)
    {
        return;
    }
    for (i = 0; i < 100; i++)
    {
        FILE *g;
        char *p = NULL;
        size_t z = 0;

        g = fmemopen(NULL, 8, "w");
        if (g == NULL || fputs(data, g) == EOF || fclose(g) != 0)
        {
            say(2, "FAIL: fmemopen cycle failed\n");
            failures++;
            return;
        }
        g = open_memstream(&p, &z);
        if (g == NULL || fputs(data, g) == EOF || fclose(g) != 0)
        {
            say(2, "FAIL: open_memstream cycle failed\n");
            failures++;
            return;
        }
        free(p);
    }
    after = __vlibc_malloc_check();
    check(after == before,
          "fclose releases memory-stream FILEs and owned buffers (no leak over 100 cycles)");
}

/* puts, putchar_unlocked, getchar_unlocked over redirected std streams. */
static void
stream_redirect_scenario(void)
{
    const char outpath[] = "/tmp/vlibc-test-t18-stdout.txt";
    const char inpath[] = "/tmp/vlibc-test-t18-stdin.txt";
    char buf[32];
    long saved_out;
    long saved_in;
    long got;
    int r1;
    int r2;
    int r3;
    int r4;
    int c;

    /* stdout: no check() output on fd 1 while it names the file. */
    saved_out = __syscall1(SYS_dup, 1);
    check(saved_out >= 0, "dup(1) saves the stdout descriptor");
    r1 = (freopen(outpath, "w", stdout) == stdout);
    r2 = (puts("AA") >= 0);
    r3 = (putchar_unlocked('B') == 'B');
    r4 = (fflush(stdout) == 0);
    __syscall2(SYS_dup2, saved_out, 1);
    __syscall1(SYS_close, saved_out);
    check(r1, "freopen stdout to a file");
    check(r2, "puts writes through stdout");
    check(r3, "putchar_unlocked writes through stdout");
    check(r4, "fflush(stdout) after the freopen");
    got = raw_read_all(outpath, buf, sizeof(buf));
    check(got == 4 && buf[0] == 'A' && buf[1] == 'A' && buf[2] == '\n' && buf[3] == 'B',
          "puts + putchar_unlocked content reached the file as \"AA\\nB\"");
    check(remove(outpath) == 0, "remove the stdout file");

    /* stdin: seed a file, rebind stdin, read a char, restore. */
    {
        FILE *seed = write_file(inpath, "K", 1);

        check(seed != NULL, "stdin seed file written");
        if (seed != NULL)
        {
            (void)fclose(seed);
        }
        saved_in = __syscall1(SYS_dup, 0);
        check(saved_in >= 0, "dup(0) saves the stdin descriptor");
        r1 = (freopen(inpath, "r", stdin) == stdin);
        c = getchar_unlocked();
        r2 = (c == 'K');
        __syscall2(SYS_dup2, saved_in, 0);
        __syscall1(SYS_close, saved_in);
        check(r1, "freopen stdin from the seed file");
        check(r2, "getchar_unlocked reads the seed character");
        check(remove(inpath) == 0, "remove the stdin file");
    }
}

/* Failure scenarios (-f). */
static int
failure_scenarios(void)
{
    const char path[] = "/tmp/vlibc-test-t18-fail.txt";
    FILE *f;
    char *line = NULL;
    size_t n = 0;
    ssize_t got;

    f = fopen(path, "w+");
    if (f == NULL)
    {
        say(2, "FAIL: -f setup fopen failed\n");
        failures++;
        return 1;
    }
    check(fputs("data-data-data", f) >= 0, "-f setup fputs");
    check(fflush(f) == 0, "-f setup fflush");
    (void)__syscall1(SYS_close, fileno(f)); /* close the fd underneath */
    got = getline(&line, &n, f);
    check(got == -1, "getline on a closed-underneath stream returns -1");
    free(line);
    (void)fclose(f);
    check(remove(path) == 0, "-f remove");
    return failures > 0 ? 1 : 0;
}
// NOLINTEND(clang-analyzer-unix.Stream)

int
main(int argc, char **argv)
{
    if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
    {
        int rc = failure_scenarios();

        __syscall1(SYS_exit_group, rc);
        return rc; /* not reached */
    }

    line_scenario();
    delim_scenario();
    lock_scenario();
    fmemopen_scenario();
    memstream_scenario();
    memstream_leak_scenario();
    stream_redirect_scenario();

    if (failures > 0)
    {
        say(2, "FAILED (");
        say_dec(2, (unsigned long)failures);
        say(2, " check(s))\n");
        return 1;
    }
    say(1, "all getline/locking/memstream tests passed\n");
    return 0;
}