// bufiotest — exercises lib/bufio. Run with `out/bin/ww run lib/bufio/bufiotest.ww`.
//
// Each @test enumerates parallel `[N]T` arrays of inputs and
// expectations, then iterates one body across them. Parallel arrays
// (rather than `[N]struct{...}`) match the same cgen workaround
// memiotest leans on.

use bufio;
use bytes;
use io;
use memio;

// Direct exit(2) binding rather than `use os;` — os exports
// read/write/close, which collide with io.read/write/close under
// the driver's flat-scope concat.
@symbol("rt_syscall") fn syscall1ww(num: i64, a: i64) i64;
fn doexit(code: i32) void = {
	syscall1ww(60i64, code: i64);
};

// signalled — bumped by main before each test so a failing exit code
// pinpoints the offending case.
let signalled: i32 = 0;

fn fail() void = { doexit(signalled + 10); };

// putstr — copy the bytes of `s` into `into` starting at `off`,
// returning the new offset.
fn putstr(s: str, into: []u8, off: i32) i32 = {
	let i: i32 = 0;
	for (i < s.len) {
		into[off + i] = s[i];
		i += 1;
	};
	return off + s.len;
};

// ---- A closed-on-read stream for the io.closed surfacing test ---------

fn closedread(s: *io.stream, buf: []u8) (i32 | io.eof | io.closed) = {
	let e: io.closed; return e;
};
fn closedwrite(s: *io.stream, buf: []u8) (i32 | io.closed) = {
	let e: io.closed; return e;
};
fn closedclose(s: *io.stream) (void | io.closed) = { return; };

fn closedstream(s: *io.stream) void = {
	s.ctx = nil;
	s.read = closedread;
	s.write = closedwrite;
	s.close = closedclose;
};

// ---- scanbyte: drain four bytes through a 2-byte window ---------------

// Reading buf is smaller than the stream contents (2 vs 4) — the
// scanner has to refill twice. Row 4 is one past EOF, row 5 stays at
// EOF (idempotent).
@test fn scanbytecases() void = {
	let raw: [4]u8;
	raw[0] = 11u8; raw[1] = 22u8; raw[2] = 33u8; raw[3] = 44u8;

	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, raw[0:4]);
	let buf: [2]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:2]);

	// (wantbyte, weof)
	let want: [6]u8;
	let weof: [6]i32;
	want[0]=11u8; weof[0]=0;
	want[1]=22u8; weof[1]=0;
	want[2]=33u8; weof[2]=0;
	want[3]=44u8; weof[3]=0;
	want[4]=0u8;  weof[4]=1;	// past end → eof
	want[5]=0u8;  weof[5]=1;	// stay at eof

	let i: i32 = 0;
	for (i < 6) {
		let r: (u8 | io.eof | io.closed) = bufio.scanbyte(&sc);
		match (r) {
		case let b: u8 => {
			if (weof[i] != 0) { fail(); };
			if (b != want[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case io.closed => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- scanline: 3 lines + tail fragment + extra calls stay at EOF ------

@test fn scanlinecases() void = {
	let src: [32]u8;
	let n: i32 = putstr("foo\nbar\nbaz\ntrailing", src[0:32], 0);

	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, src[0:n]);
	let buf: [32]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:32]);

	// (wantlen, wantfirst, weof, wovr)
	// Row 0..2: terminated lines.
	// Row 3:   tail "trailing" — EOF_DISCARD drops it, returns eof.
	// Row 4:   subsequent call stays at eof.
	let wl:    [5]i32;
	let wf:    [5]u8;
	let weof:  [5]i32;
	let wovr:  [5]i32;
	wl[0]=3; wf[0]=102u8; weof[0]=0; wovr[0]=0;	// foo
	wl[1]=3; wf[1]=98u8;  weof[1]=0; wovr[1]=0;	// bar
	wl[2]=3; wf[2]=98u8;  weof[2]=0; wovr[2]=0;	// baz
	wl[3]=0; wf[3]=0u8;   weof[3]=1; wovr[3]=0;	// trailing → eof
	wl[4]=0; wf[4]=0u8;   weof[4]=1; wovr[4]=0;	// stay eof

	let i: i32 = 0;
	for (i < 5) {
		let r: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			if (weof[i] != 0) { fail(); };
			if (wovr[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case io.closed => fail();
		case bufio.overflow => { if (wovr[i] == 0) { fail(); }; };
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- scanline: line longer than buffer → overflow --------------------

@test fn scanlineoverflow() void = {
	let src: [32]u8;
	let n: i32 = putstr("ABCDEFGHI\n", src[0:32], 0);

	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, src[0:n]);

	// Buffer too small for the 9-byte payload + delim. Caller
	// owns the budget; overflow signals "raise it".
	let buf: [4]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:4]);

	let r: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc);
	match (r) {
	case let v: str => fail();
	case io.eof => fail();
	case io.closed => fail();
	case bufio.overflow => { };
	};

	bufio.finish(&sc);
};

// ---- scantok: multi-delim hit, delim-at-start, EOF before delim ------

@test fn scantokcases() void = {
	let src: [16]u8;
	// ",a,,b,c"  — leading delim, empty token, multi-hit, trailing fragment.
	let n: i32 = putstr(",a,,b,c", src[0:16], 0);

	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, src[0:n]);
	let buf: [8]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:8]);

	// (wantlen, wantfirst, weof)
	// Row 0: leading "," → empty token.
	// Row 1: "a" before next ",".
	// Row 2: empty token between consecutive ",,".
	// Row 3: "b".
	// Row 4: "c" — no trailing delim → EOF_DISCARD drops + eof.
	let wl:   [5]i32;
	let wf:   [5]u8;
	let weof: [5]i32;
	wl[0]=0; wf[0]=0u8;   weof[0]=0;
	wl[1]=1; wf[1]=97u8;  weof[1]=0;	// 'a'
	wl[2]=0; wf[2]=0u8;   weof[2]=0;
	wl[3]=1; wf[3]=98u8;  weof[3]=0;	// 'b'
	wl[4]=0; wf[4]=0u8;   weof[4]=1;	// 'c' discarded

	let i: i32 = 0;
	for (i < 5) {
		let r: ([]u8 | io.eof | io.closed | bufio.overflow) = bufio.scantok(&sc, 44u8);	// ','
		match (r) {
		case let v: []u8 => {
			if (weof[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case io.closed => fail();
		case bufio.overflow => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

// ---- empty stream: every variant returns eof immediately --------------

@test fn emptystream() void = {
	let raw: [1]u8;
	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, raw[0:0]);
	let buf: [8]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:8]);

	let r1: (u8 | io.eof | io.closed) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => fail();
	case io.eof => { };
	case io.closed => fail();
	};

	let r2: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc);
	match (r2) {
	case let v: str => fail();
	case io.eof => { };
	case io.closed => fail();
	case bufio.overflow => fail();
	};

	let r3: ([]u8 | io.eof | io.closed | bufio.overflow) = bufio.scantok(&sc, 10u8);
	match (r3) {
	case let v: []u8 => fail();
	case io.eof => { };
	case io.closed => fail();
	case bufio.overflow => fail();
	};

	bufio.finish(&sc);
};

// ---- io.closed surfacing on a stream that returns closed --------------

@test fn closedsource() void = {
	let m: io.stream;
	closedstream(&m);
	let buf: [8]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:8]);

	let r1: (u8 | io.eof | io.closed) = bufio.scanbyte(&sc);
	match (r1) {
	case let b: u8 => fail();
	case io.eof => fail();
	case io.closed => { };
	};

	let r2: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc);
	match (r2) {
	case let v: str => fail();
	case io.eof => fail();
	case io.closed => { };
	case bufio.overflow => fail();
	};

	let r3: ([]u8 | io.eof | io.closed | bufio.overflow) = bufio.scantok(&sc, 32u8);
	match (r3) {
	case let v: []u8 => fail();
	case io.eof => fail();
	case io.closed => { };
	case bufio.overflow => fail();
	};

	bufio.finish(&sc);
};

// ---- boundary: empty line + idempotent EOF on scantok ----------------

// scanline on a leading '\n' must return an empty (len=0) view, not
// skip the empty line and pretend it's "the first non-empty line".
// scantok after EOF_DISCARD must keep returning io.eof on every
// subsequent call — same idempotency guaranteed by scanbyte rows 4/5
// and scanline rows 3/4, but the scantok path filled at the bottom
// of `for (true)` is its own state machine. Worth pinning.
@test fn boundarycases() void = {
	// ---- empty line via scanline -----------------------------------
	let s1: [16]u8;
	let n1: i32 = putstr("\nfoo\n", s1[0:16], 0);
	let m1mem: memio.state;
	let m1:    io.stream;
	memio.fixed(&m1mem, &m1, s1[0:n1]);
	let b1: [8]u8;
	let sc1: bufio.scanner;
	bufio.newscanner(&sc1, &m1, b1[0:8]);

	let r1: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc1);
	match (r1) {
	case let v: str => { if (v.len != 0) { fail(); }; };
	case io.eof => fail();
	case io.closed => fail();
	case bufio.overflow => fail();
	};
	let r2: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc1);
	match (r2) {
	case let v: str => {
		if (v.len != 3) { fail(); };
		if (v[0] != 102u8) { fail(); };	// 'f'
	};
	case io.eof => fail();
	case io.closed => fail();
	case bufio.overflow => fail();
	};
	bufio.finish(&sc1);

	// ---- scantok idempotent EOF -----------------------------------
	// "ab" with delim ',' — no delim, EOF_DISCARD drops "ab", first
	// call returns eof. The next call must too (state stays at eof).
	let s2: [8]u8;
	let n2: i32 = putstr("ab", s2[0:8], 0);
	let m2mem: memio.state;
	let m2:    io.stream;
	memio.fixed(&m2mem, &m2, s2[0:n2]);
	let b2: [8]u8;
	let sc2: bufio.scanner;
	bufio.newscanner(&sc2, &m2, b2[0:8]);

	let t1: ([]u8 | io.eof | io.closed | bufio.overflow) = bufio.scantok(&sc2, 44u8);
	match (t1) {
	case let v: []u8 => fail();
	case io.eof => { };
	case io.closed => fail();
	case bufio.overflow => fail();
	};
	let t2: ([]u8 | io.eof | io.closed | bufio.overflow) = bufio.scantok(&sc2, 44u8);
	match (t2) {
	case let v: []u8 => fail();
	case io.eof => { };
	case io.closed => fail();
	case bufio.overflow => fail();
	};
	bufio.finish(&sc2);
};

// ---- multi-fill: window smaller than longest token, shift path --------

// Buffer 4B, line "abcd\nxy\n". After reading "abcd", a delim search
// finds nothing, the buffer is full at start=0 → overflow. So bump
// to 5B (room for "abcd" + '\n'). Reads come in 5-byte chunks; the
// second line "xy" fits trivially and exercises the shift path.
@test fn multifill() void = {
	let src: [32]u8;
	let n: i32 = putstr("abcd\nxy\n", src[0:32], 0);

	let mem: memio.state;
	let m:   io.stream;
	memio.fixed(&mem, &m, src[0:n]);
	let buf: [5]u8;
	let sc:  bufio.scanner;
	bufio.newscanner(&sc, &m, buf[0:5]);

	// (wantlen, wantfirst, weof)
	let wl:   [3]i32;
	let wf:   [3]u8;
	let weof: [3]i32;
	wl[0]=4; wf[0]=97u8;  weof[0]=0;	// abcd
	wl[1]=2; wf[1]=120u8; weof[1]=0;	// xy
	wl[2]=0; wf[2]=0u8;   weof[2]=1;	// eof

	let i: i32 = 0;
	for (i < 3) {
		let r: (str | io.eof | io.closed | bufio.overflow) = bufio.scanline(&sc);
		match (r) {
		case let v: str => {
			if (weof[i] != 0) { fail(); };
			if (v.len != wl[i]) { fail(); };
			if (v.len > 0 && v[0] != wf[i]) { fail(); };
		};
		case io.eof => { if (weof[i] == 0) { fail(); }; };
		case io.closed => fail();
		case bufio.overflow => fail();
		};
		i += 1;
	};

	bufio.finish(&sc);
};

export fn main() i32 = {
	signalled = 1; scanbytecases();
	signalled = 2; scanlinecases();
	signalled = 3; scanlineoverflow();
	signalled = 4; scantokcases();
	signalled = 5; emptystream();
	signalled = 6; closedsource();
	signalled = 7; boundarycases();
	signalled = 8; multifill();
	return 0;
};