/*
 * 989_declns_sep — #23/#30 declaration-namespace + module-fn coexistence
 * under the directory-package model (task #83, M4 E2-C2c).
 *
 * Re-hosts every decl-namespace assertion that today lives ONLY in
 * 910/997 onto a gate that survives the M4 flip (910/997 are deleted at
 * the flip — they feed combined.ww / amalgamation inputs). Three legs:
 *
 *   dup family    — a duplicate top-level fn/type/def/let in one (flat)
 *                   module must build-FAIL on BOTH stages. The fixtures
 *                   are flat single-package (the surviving shape) and feed
 *                   `w6c` / `w6c_ww` DIRECTLY — no driver resolution; the
 *                   dup is an install-pass property, not a build-model one.
 *                   712 covered the cstage let arm; 997 covered the wwstage
 *                   arm — this gate asserts BOTH stages reject every kind,
 *                   closing the ww arm that dies with 997.
 *   builtin_redecl— the carve-out: a user redecl of a pre-seeded builtin
 *                   name (`nomem`) is NOT a duplicate. cstage keeps no
 *                   builtins in scope (lookup_builtin wins first), wwstage
 *                   seeds them into c.top so installtop must DROP the redecl
 *                   rather than error. Both stages accept + run to 7.
 *   modfn coexist — a top-level value-namespace `fn aa` and an imported
 *                   MODULE `aa` coexist: bare `aa()` binds the fn (a module
 *                   is not callable), `aa.helper()` binds through the module.
 *                   RESHAPED from the dying multi-`package`-single-file
 *                   910/997 fixtures to dir-packages (696 precedent), built
 *                   via `ww build --sep` + run. The _vbu twin flips the decl
 *                   order (`fn aa` BEFORE `import aa`): cstage installs every
 *                   SK_USE in an order-independent first pass, wwstage in
 *                   source order, so vbu exercises a DISTINCT promote path —
 *                   its asm must be byte-identical to the use-before-value
 *                   order, the teeth against silent order-dependence.
 *
 * dup_xpkg (same leaf in distinct packages = legal) RIDES on 696/697's
 * dir-package coverage — no port (spec C2c).
 *
 * Light wwstage-driver test (CLAUDE.md rule 14): every modfn intermediate
 * is `-o`-redirected to /tmp, so it is phase-1 parallel-safe; the dup +
 * builtin legs feed w6c directly with `-o /tmp`. Models 989_sepbuild_run +
 * 911_attest_drop conventions; 989 prefix per the sep-gate precedent (the
 * 7xx cgen/check range is exhausted).
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/stat.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
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;
}

/* 0 if `needle` occurs in the file at `path`, else 1 (or -1 on read err). */
static int
file_contains(const char *path, const char *needle)
{
	char *b = NULL;
	size_t n = 0;
	if (slurp(path, &b, &n) < 0) return -1;
	int found = (strstr(b, needle) != NULL);
	free(b);
	return found ? 0 : 1;
}

/*
 * dup family — direct-w6c/w6c_ww. Each fixture is a flat single-package
 * with one duplicate top-level decl; both stages must build-FAIL, and the
 * diagnostic must name the duplicate (non-vacuity: a fixture that failed
 * for an unrelated reason would pass an exit-only check). cstage prefixes
 * line:col, wwstage does not, so the asserted substring is the shared tail.
 */
static const struct {
	const char *fixture;
	const char *diag;	/* shared "duplicate <kind> <name>" substring */
} dup_rows[] = {
	{ "test/wcc/data/dup_fn.ww",   "duplicate fn foo" },
	{ "test/wcc/data/dup_type.ww", "duplicate type t" },
	{ "test/wcc/data/dup_def.ww",  "duplicate def D" },
	{ "test/wcc/data/dup_let.ww",  "duplicate let g" },
};

static int
dup_family(const char *bin)
{
	int pid = getpid();
	char err[256], cmd[4096];
	snprintf(err, sizeof err, "/tmp/declns_dup_%d.err", pid);

	int rc = 0;
	const char *comps[] = { "w6c", "w6c_ww" };
	for (size_t r = 0; r < sizeof dup_rows / sizeof dup_rows[0]; r++) {
		for (size_t c = 0; c < sizeof comps / sizeof comps[0]; c++) {
			snprintf(cmd, sizeof cmd, "%s/%s %s -o /dev/null 2>%s",
			    bin, comps[c], dup_rows[r].fixture, err);
			if (runwait(cmd) == 0) {
				fprintf(stderr, "declns FAIL: %s accepted %s (expected "
				    "build-fail)\n", comps[c], dup_rows[r].fixture);
				rc = 1;
			} else if (file_contains(err, dup_rows[r].diag) != 0) {
				fprintf(stderr, "declns FAIL: %s rejected %s but not on "
				    "`%s` (wrong reason)\n", comps[c], dup_rows[r].fixture,
				    dup_rows[r].diag);
				rc = 1;
			}
		}
	}
	unlink(err);
	return rc;
}

/*
 * builtin_redecl — the carve-out. Import-free + flat, so it feeds the
 * direct w6c→w6a→w6l pipeline (mirrors 911's linkfail staging). The
 * builtin `nomem` (= !void) wins, so g()'s i32 arm returns 7; both stages
 * must accept AND run to that exact code.
 */
static const struct {
	const char *comp;
	const char *asmt;
	const char *linkt;
} stages[] = {
	{ "w6c",    "w6a",    "w6l"    },
	{ "w6c_ww", "w6a_ww", "w6l_ww" },
};

static int
builtin_redecl(const char *bin)
{
	int pid = getpid();
	char rt[1024], asmf[256], obj[256], exe[256], cmd[4096];
	snprintf(rt, sizeof rt, "%s/../lib/libwwrt.a", bin);

	int rc = 0;
	for (size_t i = 0; i < sizeof stages / sizeof stages[0]; i++) {
		snprintf(asmf, sizeof asmf, "/tmp/declns_br_%s_%d.s", stages[i].comp, pid);
		snprintf(obj,  sizeof obj,  "/tmp/declns_br_%s_%d.o", stages[i].comp, pid);
		snprintf(exe,  sizeof exe,  "/tmp/declns_br_%s_%d.exe", stages[i].comp, pid);

		int ok = 1;
		snprintf(cmd, sizeof cmd,
		    "%s/%s test/wcc/data/builtin_redecl_ok.ww -o %s 2>/dev/null",
		    bin, stages[i].comp, asmf);
		if (ok && runwait(cmd) != 0) {
			fprintf(stderr, "declns FAIL: %s rejected builtin_redecl "
			    "(carve-out must accept)\n", stages[i].comp);
			ok = 0; rc = 1;
		}
		snprintf(cmd, sizeof cmd, "%s/%s -o %s %s 2>/dev/null",
		    bin, stages[i].asmt, obj, asmf);
		if (ok && runwait(cmd) != 0) {
			fprintf(stderr, "declns FAIL: %s asm of builtin_redecl\n",
			    stages[i].asmt);
			ok = 0; rc = 1;
		}
		snprintf(cmd, sizeof cmd, "%s/%s -o %s %s %s 2>/dev/null",
		    bin, stages[i].linkt, exe, obj, rt);
		if (ok && runwait(cmd) != 0) {
			fprintf(stderr, "declns FAIL: %s link of builtin_redecl\n",
			    stages[i].linkt);
			ok = 0; rc = 1;
		}
		if (ok) {
			int got = runwait(exe);
			if (got != 7) {
				fprintf(stderr, "declns FAIL: builtin_redecl (%s) "
				    "exit=%d want=7\n", stages[i].comp, got);
				rc = 1;
			}
		}
		unlink(asmf); unlink(obj); unlink(exe);
	}
	return rc;
}

/*
 * modfn coexist — the two dir-package layouts. Build each via `ww build
 * --sep` + run, both driver stages, expect exit 6 (aa()=1 + aa.helper()=5).
 * `ww build` (NOT `ww run`) per spec: run is not sep-wired until the driver
 * flip. Returns 0 on success; leaves <prog>.sepwork in `td` for the byte-id
 * compares below.
 */
struct modfn { const char *lay; const char *fixture; };
static const struct modfn modfn_lays[] = {
	{ "coexist",     "test/wcc/data/modfn_coexist/main.ww" },
	{ "coexist_vbu", "test/wcc/data/modfn_coexist_vbu/main.ww" },
};

/* per-package output the sep driver materializes; the root carries no .wwi
 * (post-#69 it is compiled without -I), so its suffix set omits .wwi. */
static const struct {
	const char *pkg;
	const char *suf;
} parts[] = {
	{ "aa",     ".s" },
	{ "aa",     ".wwi" },
	{ "aa",     ".unit.ww" },
	{ "__root", ".s" },
	{ "__root", ".unit.ww" },
};

static int
modfn_build(const char *bin, const char *td)
{
	char cmd[4096], prog[1024];
	int rc = 0;
	for (size_t l = 0; l < sizeof modfn_lays / sizeof modfn_lays[0]; l++) {
		for (size_t s = 0; s < sizeof stages / sizeof stages[0]; s++) {
			const char *drv = (s == 0) ? "ww" : "ww_ww";
			snprintf(prog, sizeof prog, "%s/%s.%s", td, modfn_lays[l].lay,
			    (s == 0) ? "cs" : "ww");
			snprintf(cmd, sizeof cmd, "%s/%s build --sep -o %s %s 2>/dev/null",
			    bin, drv, prog, modfn_lays[l].fixture);
			if (runwait(cmd) != 0) {
				fprintf(stderr, "declns FAIL: %s build --sep %s\n", drv,
				    modfn_lays[l].lay);
				rc = 1;
				continue;
			}
			int got = runwait(prog);
			if (got != 6) {
				fprintf(stderr, "declns FAIL: modfn %s (%s) exit=%d want=6 "
				    "(coexistence mis-resolved)\n", modfn_lays[l].lay, drv, got);
				rc = 1;
			}
		}
	}
	return rc;
}

/* cs==ww (rule 10): for one layout, every per-package .s/.wwi/.unit.ww the
 * cstage and wwstage sep drivers emitted must be byte-identical. */
static int
modfn_cs_eq_ww(const char *td, const char *lay)
{
	int rc = 0;
	for (size_t p = 0; p < sizeof parts / sizeof parts[0]; p++) {
		char a[1024], b[1024];
		snprintf(a, sizeof a, "%s/%s.cs.sepwork/%s%s", td, lay, parts[p].pkg, parts[p].suf);
		snprintf(b, sizeof b, "%s/%s.ww.sepwork/%s%s", td, lay, parts[p].pkg, parts[p].suf);
		if (files_eq(a, b) != 0) {
			fprintf(stderr, "declns FAIL: %s cs!=ww for %s%s (rule 10)\n",
			    lay, parts[p].pkg, parts[p].suf);
			rc = 1;
		}
	}
	return rc;
}

/* cross-order byte-id: the value-before-use layout must emit asm/interface
 * byte-identical to the use-before-value layout (same stage). Silent
 * order-dependence in the SK_USE/value-sym promote is exactly what regresses;
 * a divergence here is the teeth. */
static int
modfn_order_id(const char *td)
{
	int rc = 0;
	const char *tags[] = { "cs", "ww" };
	for (size_t t = 0; t < sizeof tags / sizeof tags[0]; t++) {
		for (size_t p = 0; p < sizeof parts / sizeof parts[0]; p++) {
			/* `.unit.ww` is the driver's verbatim source-assembly
			 * intermediate — it embeds the two layouts' differently
			 * ORDERED source text, so it differs by construction. The
			 * order-independence claim is about CODEGEN, so it is tested
			 * on the compiled `.s`/`.wwi` only. */
			if (strcmp(parts[p].suf, ".unit.ww") == 0) continue;
			char a[1024], b[1024];
			snprintf(a, sizeof a, "%s/coexist.%s.sepwork/%s%s",
			    td, tags[t], parts[p].pkg, parts[p].suf);
			snprintf(b, sizeof b, "%s/coexist_vbu.%s.sepwork/%s%s",
			    td, tags[t], parts[p].pkg, parts[p].suf);
			if (files_eq(a, b) != 0) {
				fprintf(stderr, "declns FAIL: vbu!=non-vbu for %s%s (%s) — "
				    "silent decl-order dependence\n", parts[p].pkg,
				    parts[p].suf, tags[t]);
				rc = 1;
			}
		}
	}
	return rc;
}

/* non-vacuity: __root.s must carry BOTH calls distinctly — through the
 * module (`aa.helper`) and to the local value fn (`main.aa`) — proving the
 * two namespaces resolved to different symbols rather than collapsing. */
static int
modfn_coexist_present(const char *td)
{
	int rc = 0;
	const char *tags[] = { "cs", "ww" };
	for (size_t t = 0; t < sizeof tags / sizeof tags[0]; t++) {
		char rs[1024];
		snprintf(rs, sizeof rs, "%s/coexist.%s.sepwork/__root.s", td, tags[t]);
		if (file_contains(rs, "CALL\taa.helper(SB)") != 0) {
			fprintf(stderr, "declns FAIL: __root.s (%s) lacks module-qualified "
			    "`CALL aa.helper(SB)`\n", tags[t]);
			rc = 1;
		}
		if (file_contains(rs, "CALL\tmain.aa(SB)") != 0) {
			fprintf(stderr, "declns FAIL: __root.s (%s) lacks local-fn "
			    "`CALL main.aa(SB)`\n", tags[t]);
			rc = 1;
		}
	}
	return rc;
}

int
main(void)
{
	const char *bin = absbin();
	if (!bin) { fprintf(stderr, "declns FAIL: getcwd\n"); return 1; }

	int fail = 0;
	fail += dup_family(bin);
	fail += builtin_redecl(bin);

	char td[64], cmd[256];
	snprintf(td, sizeof td, "/tmp/wwdeclns_%d", getpid());
	snprintf(cmd, sizeof cmd, "rm -rf %s", td);
	runwait(cmd);
	mkdir(td, 0755);

	fail += modfn_build(bin, td);
	fail += modfn_cs_eq_ww(td, "coexist");
	fail += modfn_cs_eq_ww(td, "coexist_vbu");
	fail += modfn_order_id(td);
	fail += modfn_coexist_present(td);

	snprintf(cmd, sizeof cmd, "rm -rf %s", td);
	runwait(cmd);

	if (fail) {
		fprintf(stderr, "declns: %d check(s) failed\n", fail);
		return 1;
	}
	printf("declns: dup fn/type/def/let build-fail (both stages) + "
	    "builtin_redecl accept→7 + modfn dir-pkg coexist→6 (cs==ww, "
	    "vbu byte-id to use-before-value), both stages (#23/#30)\n");
	return 0;
}