/*
 * 989_intoverflow_reject — F14 #53: wwstage parseint dropped the u64
 * overflow guard the C twin carries (cmd/wcc/lex.c:156
 * `if (v > (u64)~0ULL / (u64)base)`), so any integer literal that
 * overflows u64 was silently accepted mod 2^64 by wwstage while cstage
 * loudly rejected with "bad integer literal". The fix ports the
 * pre-multiply guard into lib/ww/lex/lex.ww parseint, aligning wwstage
 * UP to cstage.
 *
 * Each REJECT row is a literal that exceeds u64 and must FAIL to build
 * on BOTH driver twins; each control fits in u64 and must build+run.
 * Edge rows: U64_MAX decimal and hex (the largest accepted), a 65-bit
 * hex (smallest-bit overflow), a 21-digit decimal, and a 2^128-1
 * decimal. The exact-2^64 boundary family is NOT a row here: cstage's
 * own cheap-check leaks it (report-item #54, a separate both-stages
 * item), so both stages accept it identically — outside #53's scope.
 *
 * Rule-10: every row runs on cstage `ww` and wwstage `ww_ww`; both must
 * agree. wwstage rows are gated on out/bin/ww_ww.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>

static int
runwait(const char *cmd)
{
	int rc = system(cmd);
	if (rc == -1) return -1;
	if (WIFEXITED(rc)) return WEXITSTATUS(rc);
	return -1;
}

struct row {
	const char *label;
	const char *src;
	int expect_build;	/* 1 = build+run to want_exit; 0 = must FAIL */
	int want_exit;
	const char *diag;	/* expected reject diagnostic (NULL for build rows) */
};

static const struct row rows[] = {
	/* REJECT — 21-digit decimal, well over u64. */
	{ "dec_overflow",
	  "package main;\n"
	  "export fn main() i32 = {\n"
	  "	let x: u64 = 99999999999999999999u64;\n"
	  "	return x: i32;\n"
	  "};\n",
	  0, 0, "bad integer literal" },

	/* REJECT — 65-bit hex (smallest overflow above U64_MAX). */
	{ "hex_overflow",
	  "package main;\n"
	  "export fn main() i32 = {\n"
	  "	let x: u64 = 0x1ffffffffffffffffu64;\n"
	  "	return x: i32;\n"
	  "};\n",
	  0, 0, "bad integer literal" },

	/* REJECT — 2^128-1 decimal, far over u64. */
	{ "dec_huge",
	  "package main;\n"
	  "export fn main() i32 = {\n"
	  "	let x: u64 = 340282366920938463463374607431768211455u64;\n"
	  "	return x: i32;\n"
	  "};\n",
	  0, 0, "bad integer literal" },

	/* control — U64_MAX decimal is the largest accepted literal. */
	{ "u64max_dec_ok",
	  "package main;\n"
	  "export fn main() i32 = {\n"
	  "	let x: u64 = 18446744073709551615u64;\n"
	  "	if (x == 18446744073709551615u64) { return 7; };\n"
	  "	return 0;\n"
	  "};\n",
	  1, 7 },

	/* control — U64_MAX hex, same value via the base-16 path. */
	{ "u64max_hex_ok",
	  "package main;\n"
	  "export fn main() i32 = {\n"
	  "	let x: u64 = 0xffffffffffffffffu64;\n"
	  "	if (x == 18446744073709551615u64) { return 9; };\n"
	  "	return 0;\n"
	  "};\n",
	  1, 9 },
};

static int
run_build(const char *driver, const struct row *r, int i)
{
	char src[128], tmpdir[64], outbin[128], rmcmd[160], cmd[1024];
	snprintf(tmpdir, sizeof tmpdir, "/tmp/iov_%d_d_%d", getpid(), i);
	mkdir(tmpdir, 0755);
	snprintf(src, sizeof src, "%s/iov_%d_%d.ww", tmpdir, getpid(), i);
	snprintf(outbin, sizeof outbin, "%s/iov_%d_%d", tmpdir, getpid(), i);
	snprintf(rmcmd, sizeof rmcmd, "rm -rf %s", tmpdir);

	FILE *f = fopen(src, "wb");
	if (!f) { runwait(rmcmd); return -2; }
	fputs(r->src, f);
	fclose(f);

	snprintf(cmd, sizeof cmd, "%s build -o %s %s 2>/dev/null",
	    driver, outbin, src);
	int brc = runwait(cmd);

	int got = -1;
	if (brc == 0) got = runwait(outbin);

	runwait(rmcmd);
	return brc == 0 ? got : -1;
}

static int
filehas(const char *path, const char *needle)
{
	char buf[8192];
	FILE *f = fopen(path, "rb");
	if (!f) return 0;
	size_t n = fread(buf, 1, sizeof buf - 1, f);
	fclose(f);
	buf[n] = '\0';
	return strstr(buf, needle) != NULL;
}

/* build_should_fail — the build must FAIL *and* emit `diag`. A crash
 * (segfault) wraps as a nonzero "w6c failed" with no diagnostic, so the
 * substring check distinguishes it from a clean reject (#20). cstage
 * quotes the literal ("bad integer literal '99...'"), wwstage does not;
 * "bad integer literal" is the shared core. */
static int
build_should_fail(const char *driver, const char *src, const char *diag,
    int i)
{
	char s[128], tmpdir[64], outbin[128], errf[128], rmcmd[160], cmd[1024];
	snprintf(tmpdir, sizeof tmpdir, "/tmp/iovn_%d_d_%d", getpid(), i);
	mkdir(tmpdir, 0755);
	snprintf(s, sizeof s, "%s/iovn_%d_%d.ww", tmpdir, getpid(), i);
	snprintf(outbin, sizeof outbin, "%s/iovn_%d_%d", tmpdir, getpid(), i);
	snprintf(errf, sizeof errf, "%s/err", tmpdir);
	snprintf(rmcmd, sizeof rmcmd, "rm -rf %s", tmpdir);

	FILE *f = fopen(s, "wb");
	if (!f) { runwait(rmcmd); return -1; }
	fputs(src, f);
	fclose(f);

	snprintf(cmd, sizeof cmd, "%s build -o %s %s >/dev/null 2>%s",
	    driver, outbin, s, errf);
	int rc = runwait(cmd);
	int hasmsg = filehas(errf, diag);

	runwait(rmcmd);
	/* build must NOT succeed AND must emit its diagnostic. */
	return (rc != 0 && hasmsg) ? 0 : -1;
}

int
main(void)
{
	const char *bin = getenv("BIN");
	if (!bin) bin = "out/bin";
	char absbin[1024];
	if (bin[0] != '/') {
		char cwd[1024];
		if (getcwd(cwd, sizeof cwd) == NULL) return 1;
		snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
		bin = absbin;
	}

	char cdrv[1024], wdrv[1024];
	snprintf(cdrv, sizeof cdrv, "%s/ww", bin);
	snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin);

	struct { const char *name; const char *drv; int gated; }
	drivers[] = {
		{ "cstage",  cdrv, 0 },
		{ "wwstage", wdrv, 1 },
		{ NULL, NULL, 0 },
	};

	int n = (int)(sizeof rows / sizeof rows[0]);
	int total = 0, fail = 0;

	for (int d = 0; drivers[d].name; d++) {
		if (drivers[d].gated && access(drivers[d].drv, X_OK) != 0) {
			fprintf(stderr, "intoverflow_reject: skip %s (no %s)\n",
			    drivers[d].name, drivers[d].drv);
			continue;
		}
		for (int i = 0; i < n; i++) {
			total++;
			if (rows[i].expect_build) {
				int got = run_build(drivers[d].drv, &rows[i], i);
				if (got != rows[i].want_exit) {
					fprintf(stderr, "intoverflow_reject[%s][%s]: "
					    "exit=%d want=%d\n", drivers[d].name,
					    rows[i].label, got, rows[i].want_exit);
					fail++;
				}
			} else {
				if (build_should_fail(drivers[d].drv, rows[i].src,
				    rows[i].diag, 100 + i) != 0) {
					fprintf(stderr, "intoverflow_reject[%s][%s]: "
					    "built ok, expected a loud reject\n",
					    drivers[d].name, rows[i].label);
					fail++;
				}
			}
		}
	}

	if (fail) {
		fprintf(stderr, "intoverflow_reject: %d/%d fixtures failed\n",
		    fail, total);
		return 1;
	}
	printf("intoverflow_reject: %d/%d ok\n", total, total);
	return 0;
}