/*
 * 994_w6c_ww — phase-10 marker for the ww-side w6c port.
 *
 * w6c_ww is a thin packaging of selfhost/cmd/wcc/cgen.ww: it slurps a
 * .ww file, runs lex+parse+cgen, and writes Plan 9 amd64 asm to the
 * file given by -o. The same cgen is reached through `wwdump_ww -c`,
 * so w6c_ww must produce byte-identical output to wwdump_ww -c on
 * every program — this test pins that.
 *
 * (We do not diff against C-side `w6c` here because the C compiler has
 * features the ww cgen has not yet ported — float compare, fn-address
 * @symbol, indirect call. Test 990 probe 5 covers the C-vs-ww diff on
 * the subset that the ww cgen handles today.)
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <dirent.h>

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

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

static int
slurp(const char *path, char **outbuf, size_t *outlen)
{
	FILE *f = fopen(path, "rb");
	if (!f) return -1;
	fseek(f, 0, SEEK_END);
	long n = ftell(f);
	fseek(f, 0, SEEK_SET);
	if (n < 0) { fclose(f); return -1; }
	char *b = malloc((size_t)n + 1);
	if (!b) { fclose(f); return -1; }
	if (fread(b, 1, (size_t)n, f) != (size_t)n) { free(b); fclose(f); return -1; }
	b[n] = '\0';
	fclose(f);
	*outbuf = b;
	*outlen = (size_t)n;
	return 0;
}

static int
diff_one(const char *bin, const char *label, const char *src)
{
	char ws[64], cs[64], cmd[2048];
	snprintf(ws, sizeof ws, "/tmp/wwc6_%d_w.s", getpid());
	snprintf(cs, sizeof cs, "/tmp/wwc6_%d_c.s", getpid());

	snprintf(cmd, sizeof cmd, "timeout 180 %s/wwdump_ww -c %s > %s 2>/dev/null",
	    bin, src, ws);
	if (runwait(cmd) != 0) {
		fprintf(stderr, "w6c_ww FAIL: wwdump_ww -c errored on %s\n", label);
		unlink(ws);
		return -1;
	}
	snprintf(cmd, sizeof cmd, "timeout 180 %s/w6c_ww -o %s %s 2>/dev/null", bin, cs, src);
	if (runwait(cmd) != 0) {
		fprintf(stderr, "w6c_ww FAIL: w6c_ww errored on %s\n", label);
		unlink(ws); unlink(cs);
		return -1;
	}
	char *bw = NULL, *bc = NULL;
	size_t nw = 0, nc = 0;
	int rc = 0;
	if (slurp(ws, &bw, &nw) < 0 || slurp(cs, &bc, &nc) < 0) {
		fprintf(stderr, "w6c_ww FAIL: cannot read .s for %s\n", label);
		rc = -1;
	} else if (nw != nc || memcmp(bw, bc, nw) != 0) {
		fprintf(stderr, "w6c_ww FAIL: %s — wwdump_ww %zu vs w6c_ww %zu bytes\n",
		    label, nw, nc);
		rc = -1;
	}
	free(bw); free(bc);
	unlink(ws); unlink(cs);
	return rc;
}

static int
write_file(const char *path, const char *content)
{
	FILE *f = fopen(path, "wb");
	if (!f) return -1;
	fputs(content, f);
	fclose(f);
	return 0;
}

static int
files_eq(const char *a, const char *b)
{
	char *ba = NULL, *bb = NULL;
	size_t na = 0, nb = 0;
	if (slurp(a, &ba, &na) < 0 || slurp(b, &bb, &nb) < 0) {
		free(ba); free(bb);
		return -1;
	}
	int eq = (na == nb && memcmp(ba, bb, na) == 0);
	free(ba); free(bb);
	return eq ? 0 : 1;
}

/* cs==ww over a sep-build's per-package artifacts: every .s/.o/.wwi the
 * cstage driver produced in `csdir` must be byte-identical to the wwstage
 * driver's same-named file in `wwdir` (rule 10; the .wwi interface files
 * enter the compare set per rob-c6-spec §2). Returns the mismatch count
 * (≥1 also on an unreadable / empty cs sepwork). */
static int
cmp_sepwork(const char *csdir, const char *wwdir)
{
	DIR *d = opendir(csdir);
	if (!d) {
		fprintf(stderr, "Tier-C FAIL: no cs sepwork %s\n", csdir);
		return 1;
	}
	int bad = 0, seen = 0;
	struct dirent *ent;
	while ((ent = readdir(d)) != NULL) {
		const char *nm = ent->d_name;
		size_t nl = strlen(nm);
		int is_s = (nl > 2 && strcmp(nm + nl - 2, ".s") == 0);
		int is_o = (nl > 2 && strcmp(nm + nl - 2, ".o") == 0);
		int is_wwi = (nl > 4 && strcmp(nm + nl - 4, ".wwi") == 0);
		if (!is_s && !is_o && !is_wwi) continue;
		seen++;
		char a[2048], b[2048];
		snprintf(a, sizeof a, "%s/%s", csdir, nm);
		snprintf(b, sizeof b, "%s/%s", wwdir, nm);
		if (files_eq(a, b) != 0) {
			fprintf(stderr, "Tier-C FAIL: cs!=ww for %s (rule 10)\n", nm);
			bad++;
		}
	}
	closedir(d);
	if (seen == 0) {
		fprintf(stderr, "Tier-C FAIL: no .s/.o/.wwi in %s\n", csdir);
		bad++;
	}
	return bad;
}

int
main(void)
{
	const char *bin = absbin();
	if (!bin) return 1;
	char cwd[1024];
	if (getcwd(cwd, sizeof cwd) == NULL) return 1;

	/* In-source corpus: programs the ww-side cgen handles today.
	 * Mirrors probe 5 in 990_selfhost without the parts that drift
	 * against C w6c. */
	struct { const char *label; const char *src; } progs[] = {
		{ "ret42",
		  "fn main() i32 = { return 42; };" },
		{ "add",
		  "fn add(a: i32, b: i32) i32 = { return a + b; };\n"
		  "fn main() i32 = { return add(7, 35); };" },
		{ "sum_for",
		  "fn sum(n: i32) i32 = {\n"
		  "  let s: i32 = 0;\n"
		  "  let i: i32 = 0;\n"
		  "  for (i < n) { s += i; i += 1; };\n"
		  "  return s;\n"
		  "};\n"
		  "fn main() i32 = { return sum(10); };" },
		{ "if_else",
		  "fn check(x: i32) i32 = {\n"
		  "  if (x > 0) { return 1; };\n"
		  "  if (x < 0) { return 100; };\n"
		  "  return 0;\n"
		  "};\n"
		  "fn main() i32 = { return check(7); };" },
		{ "recursion",
		  "fn fact(n: i32) i32 = {\n"
		  "  if (n <= 1) { return 1; };\n"
		  "  return n * fact(n - 1);\n"
		  "};\n"
		  "fn main() i32 = { return fact(5); };" },
		{ "enum",
		  "type mode = enum u8 { R = 1, W = 2, RW = R | W };\n"
		  "fn main() i32 = {\n"
		  "  let m: mode = mode.RW;\n"
		  "  return m as i32;\n"
		  "};" },
		{ "switch",
		  "fn classify(x: i32) i32 = {\n"
		  "  switch (x) {\n"
		  "    case 1, 2, 3: return 10;\n"
		  "    case 7: return 70;\n"
		  "    case: return 0;\n"
		  "  };\n"
		  "  return -1;\n"
		  "};\n"
		  "fn main() i32 = { return classify(2); };" },
		{ "append",
		  "import os;\n"
		  "fn main() i32 = {\n"
		  "  let s: []u8;\n"
		  "  s.ptr = nil; s.len = 0; s.cap = 0;\n"
		  "  append(s, 65u8, 66u8, 67u8);\n"
		  "  return s.len: i32;\n"
		  "};" },
		{ "append_spread",
		  "import os;\n"
		  "fn main() i32 = {\n"
		  "  let src: []i64;\n"
		  "  src.ptr = nil; src.len = 0; src.cap = 0;\n"
		  "  append(src, 10i64, 20i64);\n"
		  "  let dst: []i64;\n"
		  "  dst.ptr = nil; dst.len = 0; dst.cap = 0;\n"
		  "  append(dst, src...);\n"
		  "  return dst.len: i32;\n"
		  "};" },
		{ "forrange",
		  "import os;\n"
		  "fn main() i32 = {\n"
		  "  let s: []u8;\n"
		  "  s.ptr = nil; s.len = 0; s.cap = 0;\n"
		  "  append(s, 10u8, 20u8, 30u8);\n"
		  "  let total: i32 = 0;\n"
		  "  for (let b .. s) { total += b: i32; };\n"
		  "  return total;\n"
		  "};" },
		{ "forrange_tuple",
		  "fn main() i32 = {\n"
		  "  let buf: [4]i64;\n"
		  "  buf[0] = 1i64; buf[1] = 10i64; buf[2] = 2i64; buf[3] = 20i64;\n"
		  "  let s: [](i64, i64);\n"
		  "  s.ptr = buf.ptr: *(i64, i64);\n"
		  "  s.len = 2; s.cap = 2;\n"
		  "  let total: i64 = 0i64;\n"
		  "  for (let (k, v) .. s) { total += k + v; };\n"
		  "  return total: i32;\n"
		  "};" },
		/* #45: alloc-slice `!` form, []T element ≠ u8. */
		{ "alloc_slice_rune_unw",
		  "package main;\n"
		  "import rt;\n"
		  "fn main() i32 = {\n"
		  "  let s: []rune = alloc([], 8)!;\n"
		  "  return s.cap;\n"
		  "};" },
		/* #45: alloc-slice `?` form propagates nomem via the
		 * enclosing fn's tagged return. */
		{ "alloc_slice_str_prop",
		  "package main;\n"
		  "import rt;\n"
		  "fn doit() (i32 | nomem) = {\n"
		  "  let s: []str = alloc([], 4)?;\n"
		  "  return s.cap: i32;\n"
		  "};\n"
		  "fn main() i32 = { return doit()!; };" },
		{ NULL, NULL },
	};

	int fail = 0, n = 0;

	for (int i = 0; progs[i].label; i++) {
		char src[64];
		snprintf(src, sizeof src, "/tmp/wwc6_%d_%d.ww", getpid(), i);
		if (write_file(src, progs[i].src) != 0) { fail++; n++; continue; }
		if (diff_one(bin, progs[i].label, src) != 0) fail++;
		unlink(src);
		n++;
	}

	/* #50: the check pass is wired into both wwdump_ww -c and
	 * w6c_ww in front of cgen. Pre-#50, a hard type error parsed
	 * cleanly and reached cgen, which would emit asm with a zero
	 * exit (silent miscompile). Pin the rejection by giving each
	 * driver a trivially-broken file and demanding non-zero exit. */
	struct { const char *label; const char *src; } bad[] = {
		{ "let_str_to_i32",
		  "package main;\n"
		  "fn main() i32 = {\n"
		  "  let x: i32 = \"hello\";\n"
		  "  return x;\n"
		  "};\n" },
		{ NULL, NULL },
	};
	for (int i = 0; bad[i].label; i++) {
		char src[64], wcmd[2048], dcmd[2048], s[64];
		snprintf(src, sizeof src, "/tmp/wwc6_bad_%d_%d.ww", getpid(), i);
		snprintf(s, sizeof s, "/tmp/wwc6_bad_%d_%d.s", getpid(), i);
		if (write_file(src, bad[i].src) != 0) { fail++; n++; continue; }
		snprintf(wcmd, sizeof wcmd,
		    "timeout 180 %s/w6c_ww -o %s %s >/dev/null 2>&1", bin, s, src);
		snprintf(dcmd, sizeof dcmd,
		    "timeout 180 %s/wwdump_ww -c %s >%s 2>/dev/null", bin, src, s);
		if (runwait(wcmd) == 0) {
			fprintf(stderr,
			    "w6c_ww FAIL: %s slipped past check (silent miscompile)\n",
			    bad[i].label);
			fail++;
		}
		if (runwait(dcmd) == 0) {
			fprintf(stderr,
			    "wwdump_ww -c FAIL: %s slipped past check (silent miscompile)\n",
			    bad[i].label);
			fail++;
		}
		unlink(src); unlink(s);
		n++;
	}

	/* ---- Tier-C capstone (#46 c6, rob-c6-spec §2 / amendment-B; M4 #89) ---
	 * The load-bearing M4 oracle: build w6c by SEPARATE compilation under
	 * BOTH driver stages and prove they sep-produce byte-identical per-package
	 * .s/.o/.wwi (cs==ww on the real tool's sep artifacts, rule 10). The
	 * combined corpus + the sep-out==combined-out leg are gone — combined-mode
	 * is being retired (E3 flip), so combined.ww is no longer fed as compiler
	 * INPUT; the per-pkg cs==ww comparison is the surviving live oracle. COLD
	 * (pid-keyed scratch, wiped); heavy (≈ one bootstrap leg) → phase-2. */
	{
		char inc[4096], cmd[16384];
		snprintf(inc, sizeof inc,
		    "-I %s/lib -I %s/lib/ww -I %s/selfhost/cmd/wcc", cwd, cwd, cwd);
		char root[2048];
		snprintf(root, sizeof root, "%s/selfhost/cmd/w6c/main.ww", cwd);

		struct { const char *drv, *tag; char prog[2048]; int ok; }
		stg[] = { { "ww", "cs", {0}, 0 }, { "ww_ww", "ww", {0}, 0 } };
		for (int s = 0; s < 2; s++) {
			snprintf(stg[s].prog, sizeof stg[s].prog,
			    "/tmp/wwc6tc_%d_%s", getpid(), stg[s].tag);
			/* Isolated per-(pid,stage) WW_PKGCACHE → COLD + race-free
			 * (rob-c6-spec §4): the default out/.pkgcache is shared with
			 * the other phase-2 gates' `ww build`s and would both perturb
			 * this gate and corrupt under concurrent writes. */
			snprintf(cmd, sizeof cmd,
			    "WW_PKGCACHE='%s.cache' timeout 600 %s/%s build --sep "
			    "%s -o %s %s >/dev/null 2>&1",
			    stg[s].prog, bin, stg[s].drv, inc, stg[s].prog, root);
			if (runwait(cmd) != 0) {
				fprintf(stderr, "Tier-C FAIL: %s build --sep w6c\n",
				    stg[s].drv);
				fail++;
			} else stg[s].ok = 1;
			n++;
		}

		/* cs==ww on the real tool's sep .s/.o/.wwi (rule 10). */
		if (stg[0].ok && stg[1].ok) {
			char csdir[2176], wwdir[2176];
			snprintf(csdir, sizeof csdir, "%s.sepwork", stg[0].prog);
			snprintf(wwdir, sizeof wwdir, "%s.sepwork", stg[1].prog);
			fail += cmp_sepwork(csdir, wwdir);
			n++;
		}

		for (int s = 0; s < 2; s++) {
			snprintf(cmd, sizeof cmd, "rm -rf %s %s.sepwork %s.cache",
			    stg[s].prog, stg[s].prog, stg[s].prog);
			runwait(cmd);
		}
	}

	if (fail) {
		fprintf(stderr, "w6c_ww: %d/%d diff(s) failed\n", fail, n);
		return 1;
	}
	printf("w6c_ww: byte-identical to wwdump_ww -c on %d in-source corpus "
	    "inputs + Tier-C: cs==ww sep .s/.o/.wwi on the real w6c build\n",
	    n);
	return 0;
}