/*
 * test_grammar_probe_b.c — Grammar-only node/import/inheritance probe for 12 languages.
 *
 * Scope: glsl, hare, hlsl, ispc, julia, luau, matlab, odin, pascal, powershell,
 *        racket, rescript.
 *
 * CALLS coverage for these languages is already handled by P5 (contract_calls_breadth).
 * This suite probes:
 *   - NODE creation: Function/Procedure/Struct/Type nodes reach the graph after
 *     a full index_repository pipeline run (shader entrypoints, shader struct types,
 *     OOP types, module-like constructs).
 *   - IMPORTS edges: where the language has a cross-file import mechanism that the
 *     extractor knows about (julia `using`/`import`, racket `require`,
 *     powershell `using module`, rescript `open`, pascal `uses`, odin `import`,
 *     hare `use`).  MATLAB has no standard inter-file import syntax → skip.
 *     glsl/hlsl/ispc use `#include` / preprocessor — not modeled as IMPORTS → skip.
 *   - INHERITANCE: powershell classes (`: Base`), pascal OOP (`: Base`), julia
 *     abstract-type subtyping (`<:`) where same-file base is resolvable.
 *     Odin, GLSL, HLSL, ISPC, Hare, MATLAB, ReScript, Racket, Luau have no
 *     class inheritance → skip.
 *
 * Convention:
 *   GREEN  = contract that SHOULD hold; a failure here is a real regression.
 *   RED    = known bug reproduced as a failing assertion; kept as a regression
 *            guard until fixed (brief // BUG comment explains root cause).
 *
 * Do NOT register this SUITE in test_main.c — the build system discovers it
 * separately alongside _a and _c.
 */

#include "../src/foundation/compat.h"
#include "test_framework.h"
#include "test_helpers.h"
#include "cbm.h"
#include <mcp/mcp.h>
#include <store/store.h>
#include <pipeline/pipeline.h>
#include <foundation/log.h>

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#if !defined(_WIN32)
#include <sys/wait.h>
#endif

/* ── Harness (mirrors test_lang_contract.c) ────────────────────────────────── */

typedef struct {
    char tmpdir[256];
    char dbpath[512];
    char *project;
    cbm_mcp_server_t *srv;
} ProbeLangProj;

typedef struct {
    const char *name;
    const char *content;
} ProbeLangFile;

static void pb_fwd_slashes(char *p) {
    for (; *p; p++) {
        if (*p == '\\') *p = '/';
    }
}

static cbm_store_t *pb_open_indexed(ProbeLangProj *lp) {
    lp->project = cbm_project_name_from_path(lp->tmpdir);
    if (!lp->project) return NULL;
    const char *home = getenv("HOME");
    if (!home) home = "/tmp";
    char cache_dir[512];
    snprintf(cache_dir, sizeof(cache_dir), "%s/.cache/codebase-memory-mcp", home);
    cbm_mkdir(cache_dir);
    snprintf(lp->dbpath, sizeof(lp->dbpath), "%s/%s.db", cache_dir, lp->project);
    unlink(lp->dbpath);
    lp->srv = cbm_mcp_server_new(NULL);
    if (!lp->srv) return NULL;
    char args[700];
    snprintf(args, sizeof(args), "{\"repo_path\":\"%s\"}", lp->tmpdir);
    char *resp = cbm_mcp_handle_tool(lp->srv, "index_repository", args);
    if (resp) free(resp);
    return cbm_store_open_path(lp->dbpath);
}

static cbm_store_t *pb_index_files(ProbeLangProj *lp, const ProbeLangFile *files, int nfiles) {
    memset(lp, 0, sizeof(*lp));
    snprintf(lp->tmpdir, sizeof(lp->tmpdir), "/tmp/cbm_pb_XXXXXX");
    if (!cbm_mkdtemp(lp->tmpdir)) return NULL;
    pb_fwd_slashes(lp->tmpdir);
    for (int i = 0; i < nfiles; i++) {
        char path[700];
        snprintf(path, sizeof(path), "%s/%s", lp->tmpdir, files[i].name);
        char *slash = strrchr(path, '/');
        if (slash && slash > path + strlen(lp->tmpdir)) {
            *slash = '\0';
            cbm_mkdir_p(path, 0755);
            *slash = '/';
        }
        FILE *f = fopen(path, "wb");
        if (!f) return NULL;
        fputs(files[i].content, f);
        fclose(f);
    }
    return pb_open_indexed(lp);
}

static cbm_store_t *pb_index(ProbeLangProj *lp, const char *filename, const char *content) {
    ProbeLangFile f = {filename, content};
    return pb_index_files(lp, &f, 1);
}

static void pb_cleanup(ProbeLangProj *lp, cbm_store_t *store) {
    if (store) cbm_store_close(store);
    if (lp->srv) { cbm_mcp_server_free(lp->srv); lp->srv = NULL; }
    free(lp->project); lp->project = NULL;
    th_rmtree(lp->tmpdir);
    unlink(lp->dbpath);
    char wal[600], shm[600];
    snprintf(wal, sizeof(wal), "%s-wal", lp->dbpath);
    snprintf(shm, sizeof(shm), "%s-shm", lp->dbpath);
    unlink(wal); unlink(shm);
}

/* Count nodes by label. Returns -1 on store error. */
static int pb_count_label(cbm_store_t *store, const char *project, const char *label) {
    cbm_node_t *nodes = NULL;
    int count = 0;
    if (cbm_store_find_nodes_by_label(store, project, label, &nodes, &count) != CBM_STORE_OK)
        return -1;
    cbm_store_free_nodes(nodes, count);
    return count;
}

/* Sum across the labels different languages use for callables. */
static int pb_callable_nodes(cbm_store_t *store, const char *project) {
    int fn = pb_count_label(store, project, "Function");
    int mt = pb_count_label(store, project, "Method");
    return (fn < 0 ? 0 : fn) + (mt < 0 ? 0 : mt);
}

/* Sum across type-like labels. */
static int pb_type_nodes(cbm_store_t *store, const char *project) {
    static const char *labels[] = {"Class", "Struct", "Interface", "Enum", "Trait", "Type", NULL};
    int total = 0;
    for (int i = 0; labels[i]; i++) {
        int n = pb_count_label(store, project, labels[i]);
        if (n > 0) total += n;
    }
    return total;
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  GLSL — ext: .glsl
 *  Shader language: functions + void main() entrypoint + struct types.
 *  No imports (uses #include which is a preprocessor directive, not modeled).
 *  No inheritance.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* GLSL: helper + main entrypoint must both reach graph as Function nodes. */
TEST(glsl_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "shader.glsl",
        "float luminance(vec3 color) {\n"
        "    return dot(color, vec3(0.299, 0.587, 0.114));\n"
        "}\n\n"
        "void main() {\n"
        "    float lum = luminance(vec3(1.0, 0.5, 0.2));\n"
        "    gl_FragColor = vec4(lum, lum, lum, 1.0);\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* luminance + main */
    PASS();
}

/* GLSL: struct type (e.g. Light) must appear as a type node. */
TEST(glsl_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "light.glsl",
        "struct Light {\n"
        "    vec3 position;\n"
        "    vec3 color;\n"
        "    float intensity;\n"
        "};\n\n"
        "float attenuation(Light l, vec3 pos) {\n"
        "    float d = length(l.position - pos);\n"
        "    return l.intensity / (d * d);\n"
        "}\n\n"
        "void main() {\n"
        "    Light sun;\n"
        "    sun.intensity = 1.0;\n"
        "    gl_FragColor = vec4(attenuation(sun, vec3(0.0)), 1.0);\n"
        "}\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* struct Light */
    PASS();
}

/* GLSL: vertex shader with multiple stage-specific functions. */
TEST(glsl_vertex_shader_functions) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "vert.glsl",
        "vec4 transform(vec4 pos, mat4 mvp) {\n"
        "    return mvp * pos;\n"
        "}\n\n"
        "vec3 compute_normal(vec3 n, mat3 normal_mat) {\n"
        "    return normalize(normal_mat * n);\n"
        "}\n\n"
        "void main() {\n"
        "    gl_Position = transform(vec4(0.0), mat4(1.0));\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* transform, compute_normal, main */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  HARE — ext: .ha
 *  Systems language: fn declarations, type definitions, `use` imports.
 *  No class inheritance.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Hare: function nodes from top-level fn declarations. */
TEST(hare_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "math.ha",
        "fn square(x: i64) i64 = x * x;\n\n"
        "fn cube(x: i64) i64 = x * x * x;\n\n"
        "fn sum_of_squares(a: i64, b: i64) i64 = {\n"
        "    return square(a) + square(b);\n"
        "};\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* square, cube, sum_of_squares */
    PASS();
}

/* Hare: type definition (struct) reaches graph as a type node. */
TEST(hare_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "point.ha",
        "type point = struct {\n"
        "    x: i64,\n"
        "    y: i64,\n"
        "};\n\n"
        "fn distance(a: point, b: point) f64 = {\n"
        "    let dx = (b.x - a.x): f64;\n"
        "    let dy = (b.y - a.y): f64;\n"
        "    return 0.0; // simplified\n"
        "};\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* type point */
    PASS();
}

/* Hare: `use` import statement → IMPORTS edge (extraction-level check).
 * The graph-level IMPORTS edge requires cross-file resolution which a single
 * fixture cannot trigger — so we probe at extraction level via cbm_extract_file. */
TEST(hare_use_import_extracted) {
    static const char *src =
        "use fmt;\n"
        "use strings;\n\n"
        "fn greet(name: str) void = {\n"
        "    fmt::println(name);\n"
        "};\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_HARE, "lc", "greet.ha", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* use fmt; use strings; → BUG if 0: hare `use` not extracted */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  HLSL — ext: .hlsl
 *  DirectX shader language: functions + cbuffer struct-like types.
 *  No imports. No inheritance.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* HLSL: pixel shader functions must reach graph. */
TEST(hlsl_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "pixel.hlsl",
        "float4 tint(float4 color, float factor) {\n"
        "    return color * factor;\n"
        "}\n\n"
        "float luminance(float4 c) {\n"
        "    return dot(c.rgb, float3(0.299, 0.587, 0.114));\n"
        "}\n\n"
        "float4 PSMain(float4 pos : SV_Position) : SV_Target {\n"
        "    float4 c = float4(1.0, 0.5, 0.2, 1.0);\n"
        "    return tint(c, luminance(c));\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* tint, luminance, PSMain */
    PASS();
}

/* HLSL: struct definition reaches graph as type node. */
TEST(hlsl_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "types.hlsl",
        "struct VSInput {\n"
        "    float4 position : POSITION;\n"
        "    float2 texcoord : TEXCOORD0;\n"
        "};\n\n"
        "struct VSOutput {\n"
        "    float4 position : SV_Position;\n"
        "    float2 texcoord : TEXCOORD0;\n"
        "};\n\n"
        "VSOutput VSMain(VSInput input) {\n"
        "    VSOutput output;\n"
        "    output.position = input.position;\n"
        "    output.texcoord = input.texcoord;\n"
        "    return output;\n"
        "}\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* VSInput, VSOutput */
    PASS();
}

/* HLSL: compute shader kernel (another entrypoint style). */
TEST(hlsl_compute_shader_function) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "compute.hlsl",
        "RWBuffer<float> gOutput : register(u0);\n\n"
        "float transform(float x) {\n"
        "    return x * x;\n"
        "}\n\n"
        "[numthreads(64, 1, 1)]\n"
        "void CSMain(uint3 id : SV_DispatchThreadID) {\n"
        "    gOutput[id.x] = transform((float)id.x);\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* transform, CSMain */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  ISPC — ext: .ispc
 *  Intel SPMD language: task/export/uniform functions, struct types.
 *  No imports. No inheritance.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* ISPC: uniform and varying function nodes. */
TEST(ispc_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "kernel.ispc",
        "float square(float x) {\n"
        "    return x * x;\n"
        "}\n\n"
        "export void add_arrays(uniform float output[],\n"
        "                       uniform float a[],\n"
        "                       uniform float b[],\n"
        "                       uniform int count) {\n"
        "    foreach (i = 0 ... count) {\n"
        "        output[i] = a[i] + square(b[i]);\n"
        "    }\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* square, add_arrays */
    PASS();
}

/* ISPC: struct definition reaches graph as type node. */
TEST(ispc_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "types.ispc",
        "struct Vec3 {\n"
        "    float x, y, z;\n"
        "};\n\n"
        "float dot3(Vec3 a, Vec3 b) {\n"
        "    return a.x*b.x + a.y*b.y + a.z*b.z;\n"
        "}\n\n"
        "export void normalize_batch(uniform Vec3 vecs[], uniform int n) {\n"
        "    foreach (i = 0 ... n) {\n"
        "        float len = dot3(vecs[i], vecs[i]);\n"
        "        (void)len;\n"
        "    }\n"
        "}\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* struct Vec3 */
    PASS();
}

/* ISPC: task function (another callable kind). */
TEST(ispc_task_function) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "tasks.ispc",
        "uniform float compute(uniform float x) {\n"
        "    return x * 2.0f;\n"
        "}\n\n"
        "task void render_tile(uniform float buf[], uniform int w, uniform int h) {\n"
        "    foreach (j = 0 ... h, i = 0 ... w) {\n"
        "        buf[j*w + i] = compute((float)i);\n"
        "    }\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* compute, render_tile */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  JULIA — ext: .jl
 *  Dynamic language: function defs, struct types, `using`/`import` imports,
 *  abstract type subtyping with `<:`.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Julia: function and struct nodes. */
TEST(julia_function_and_struct_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "geom.jl",
        "struct Point\n"
        "    x::Float64\n"
        "    y::Float64\n"
        "end\n\n"
        "function distance(a::Point, b::Point)::Float64\n"
        "    return sqrt((b.x - a.x)^2 + (b.y - a.y)^2)\n"
        "end\n\n"
        "function midpoint(a::Point, b::Point)::Point\n"
        "    return Point((a.x + b.x) / 2, (a.y + b.y) / 2)\n"
        "end\n");
    int fns   = store ? pb_callable_nodes(store, lp.project) : -1;
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1);   /* distance, midpoint */
    ASSERT_TRUE(types >= 1); /* struct Point */
    PASS();
}

/* Julia: `using` import statement captured at extraction level. */
TEST(julia_using_import_extracted) {
    static const char *src =
        "using LinearAlgebra\n"
        "using Statistics: mean, std\n\n"
        "function norm_vec(v::Vector{Float64})::Float64\n"
        "    return norm(v)\n"
        "end\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_JULIA, "lc", "vec.jl", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* using LinearAlgebra; using Statistics → BUG if 0 */
    PASS();
}

/* Julia: `import` statement captured at extraction level. */
TEST(julia_import_extracted) {
    static const char *src =
        "import Base: show, length\n"
        "import Random\n\n"
        "struct MyVec\n"
        "    data::Vector{Float64}\n"
        "end\n\n"
        "Base.length(v::MyVec) = length(v.data)\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_JULIA, "lc", "myvec.jl", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* import Base; import Random → BUG if 0 */
    PASS();
}

/* Julia: abstract type subtyping (`<:`) — extraction captures base_classes. */
TEST(julia_abstract_subtype_extracted) {
    static const char *src =
        "abstract type Shape end\n\n"
        "abstract type Polygon <: Shape end\n\n"
        "struct Triangle <: Polygon\n"
        "    a::Float64\n"
        "    b::Float64\n"
        "    c::Float64\n"
        "end\n\n"
        "function area(t::Triangle)::Float64\n"
        "    s = (t.a + t.b + t.c) / 2\n"
        "    return sqrt(s * (s-t.a) * (s-t.b) * (s-t.c))\n"
        "end\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_JULIA, "lc", "shapes.jl", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    /* We expect at least 1 def whose base_classes is non-empty (Polygon<:Shape or
     * Triangle<:Polygon).  Iterate defs to check. */
    int found_base = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].base_classes && r->defs.items[i].base_classes[0] != NULL) {
            found_base = 1;
            break;
        }
    }
    cbm_free_result(r);
    ASSERT_TRUE(found_base); /* BUG if 0: julia `<:` base not extracted */
    PASS();
}

/* Julia: full-pipeline INHERITS edge for same-file abstract subtype chain. */
TEST(julia_inherits_edge) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "animals.jl",
        "abstract type Animal end\n\n"
        "abstract type Pet <: Animal end\n\n"
        "struct Dog <: Pet\n"
        "    name::String\n"
        "end\n\n"
        "function speak(d::Dog)::String\n"
        "    return \"Woof: \" * d.name\n"
        "end\n");
    int inherits = store ? cbm_store_count_edges_by_type(store, lp.project, "INHERITS") : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(inherits >= 1); /* Pet<:Animal, Dog<:Pet → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  LUAU — ext: .luau
 *  Roblox Lua dialect: function nodes.  No class inheritance, no module imports
 *  that map to IMPORTS edges (require() is dynamic, not a static import).
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Luau: function nodes reach the graph. */
TEST(luau_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "utils.luau",
        "local function clamp(value: number, min: number, max: number): number\n"
        "    if value < min then return min end\n"
        "    if value > max then return max end\n"
        "    return value\n"
        "end\n\n"
        "local function lerp(a: number, b: number, t: number): number\n"
        "    return a + (b - a) * clamp(t, 0, 1)\n"
        "end\n\n"
        "return { clamp = clamp, lerp = lerp }\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* clamp, lerp */
    PASS();
}

/* Luau: type alias and interface-like construct (type keyword). */
TEST(luau_type_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "types.luau",
        "type Vector2 = {\n"
        "    x: number,\n"
        "    y: number,\n"
        "}\n\n"
        "type Entity = {\n"
        "    id: number,\n"
        "    name: string,\n"
        "    position: Vector2,\n"
        "}\n\n"
        "local function make_entity(id: number, name: string): Entity\n"
        "    return { id = id, name = name, position = { x = 0, y = 0 } }\n"
        "end\n\n"
        "return { make_entity = make_entity }\n");
    /* Either type nodes or function nodes must be present */
    int nodes = store ? (pb_callable_nodes(store, lp.project) + pb_type_nodes(store, lp.project)) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(nodes >= 1); /* make_entity function at minimum */
    PASS();
}

/* Luau: class-style OOP via metatables (functions only — no native class keyword). */
TEST(luau_class_style_functions) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "player.luau",
        "local Player = {}\n"
        "Player.__index = Player\n\n"
        "function Player.new(name: string): Player\n"
        "    return setmetatable({ name = name, health = 100 }, Player)\n"
        "end\n\n"
        "function Player:takeDamage(amount: number): ()\n"
        "    self.health = self.health - amount\n"
        "end\n\n"
        "function Player:isAlive(): boolean\n"
        "    return self.health > 0\n"
        "end\n\n"
        "return Player\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* Player.new, Player:takeDamage, Player:isAlive */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  MATLAB — ext: .m
 *  Scientific language: function definitions in .m files.
 *  No standard cross-file import syntax modeled as IMPORTS.
 *  No inheritance (classdef exists but rarely used; probe basic functions only).
 * ══════════════════════════════════════════════════════════════════════════════ */

/* MATLAB: top-level function and local subfunctions reach graph. */
TEST(matlab_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "stats.m",
        "function result = compute_mean(data)\n"
        "    result = sum_values(data) / length(data);\n"
        "end\n\n"
        "function s = sum_values(v)\n"
        "    s = 0;\n"
        "    for i = 1:length(v)\n"
        "        s = s + v(i);\n"
        "    end\n"
        "end\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* compute_mean, sum_values */
    PASS();
}

/* MATLAB: multiple function file — all functions are nodes. */
TEST(matlab_multiple_functions) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "linalg.m",
        "function c = dot_product(a, b)\n"
        "    c = sum(a .* b);\n"
        "end\n\n"
        "function n = vec_norm(v)\n"
        "    n = sqrt(dot_product(v, v));\n"
        "end\n\n"
        "function u = normalize(v)\n"
        "    u = v / vec_norm(v);\n"
        "end\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* dot_product, vec_norm, normalize */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  ODIN — ext: .odin
 *  Systems language: proc declarations, struct types, `import` statements.
 *  No class inheritance (Odin is not OOP).
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Odin: proc nodes reach graph. */
TEST(odin_proc_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "math.odin",
        "package math\n\n"
        "square :: proc(x: f64) -> f64 {\n"
        "    return x * x\n"
        "}\n\n"
        "cube :: proc(x: f64) -> f64 {\n"
        "    return x * square(x)\n"
        "}\n\n"
        "clamp :: proc(v, lo, hi: f64) -> f64 {\n"
        "    if v < lo { return lo }\n"
        "    if v > hi { return hi }\n"
        "    return v\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* square, cube, clamp */
    PASS();
}

/* Odin: struct type node. */
TEST(odin_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "point.odin",
        "package point\n\n"
        "Vec2 :: struct {\n"
        "    x, y: f64,\n"
        "}\n\n"
        "Vec3 :: struct {\n"
        "    x, y, z: f64,\n"
        "}\n\n"
        "length2 :: proc(v: Vec2) -> f64 {\n"
        "    return v.x*v.x + v.y*v.y\n"
        "}\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* Vec2, Vec3 */
    PASS();
}

/* Odin: `import` statement captured at extraction level. */
TEST(odin_import_extracted) {
    static const char *src =
        "package main\n\n"
        "import \"core:fmt\"\n"
        "import \"core:os\"\n"
        "import math \"core:math\"\n\n"
        "main :: proc() {\n"
        "    fmt.println(\"hello\")\n"
        "}\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_ODIN, "lc", "main.odin", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* import "core:fmt"; import "core:os" → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  PASCAL — ext: .pas
 *  Classic structured language: procedures/functions, record/class types,
 *  `uses` import clause, OOP inheritance via `: TBase`.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Pascal: procedure and function nodes. */
TEST(pascal_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "arith.pas",
        "unit Arith;\n\n"
        "interface\n\n"
        "function Add(a, b: Integer): Integer;\n"
        "function Multiply(a, b: Integer): Integer;\n"
        "procedure PrintResult(val: Integer);\n\n"
        "implementation\n\n"
        "function Add(a, b: Integer): Integer;\n"
        "begin\n"
        "  Result := a + b;\n"
        "end;\n\n"
        "function Multiply(a, b: Integer): Integer;\n"
        "begin\n"
        "  Result := a * b;\n"
        "end;\n\n"
        "procedure PrintResult(val: Integer);\n"
        "begin\n"
        "  Writeln(val);\n"
        "end;\n\n"
        "end.\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* Add, Multiply, PrintResult */
    PASS();
}

/* Pascal: record type node. */
TEST(pascal_record_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "geom.pas",
        "unit Geom;\n\n"
        "interface\n\n"
        "type\n"
        "  TPoint = record\n"
        "    X, Y: Double;\n"
        "  end;\n\n"
        "  TRect = record\n"
        "    TopLeft: TPoint;\n"
        "    BottomRight: TPoint;\n"
        "  end;\n\n"
        "function Distance(P1, P2: TPoint): Double;\n\n"
        "implementation\n\n"
        "function Distance(P1, P2: TPoint): Double;\n"
        "begin\n"
        "  Result := 0.0;\n"
        "end;\n\n"
        "end.\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* TPoint, TRect */
    PASS();
}

/* Pascal: `uses` clause captured at extraction level. */
TEST(pascal_uses_import_extracted) {
    static const char *src =
        "unit MyUnit;\n\n"
        "interface\n\n"
        "uses\n"
        "  SysUtils, Classes, Math;\n\n"
        "procedure DoWork;\n\n"
        "implementation\n\n"
        "procedure DoWork;\n"
        "begin\n"
        "  Writeln(IntToStr(42));\n"
        "end;\n\n"
        "end.\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_PASCAL, "lc", "myunit.pas", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* uses SysUtils, Classes, Math → BUG if 0 */
    PASS();
}

/* Pascal: OOP class inheritance (`: TAnimal`) — extraction captures base_classes. */
TEST(pascal_class_inheritance_extracted) {
    static const char *src =
        "unit Zoo;\n\n"
        "interface\n\n"
        "type\n"
        "  TAnimal = class\n"
        "    procedure Speak; virtual;\n"
        "  end;\n\n"
        "  TDog = class(TAnimal)\n"
        "    procedure Speak; override;\n"
        "  end;\n\n"
        "  TCat = class(TAnimal)\n"
        "    procedure Speak; override;\n"
        "  end;\n\n"
        "implementation\n\n"
        "procedure TAnimal.Speak; begin end;\n"
        "procedure TDog.Speak; begin Writeln('Woof'); end;\n"
        "procedure TCat.Speak; begin Writeln('Meow'); end;\n\n"
        "end.\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_PASCAL, "lc", "zoo.pas", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int found_base = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].base_classes && r->defs.items[i].base_classes[0] != NULL) {
            found_base = 1;
            break;
        }
    }
    cbm_free_result(r);
    ASSERT_TRUE(found_base); /* TDog(TAnimal), TCat(TAnimal) → BUG if 0 */
    PASS();
}

/* Pascal: full-pipeline INHERITS edge for OOP class hierarchy. */
TEST(pascal_inherits_edge) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "vehicles.pas",
        "unit Vehicles;\n\n"
        "interface\n\n"
        "type\n"
        "  TVehicle = class\n"
        "    function GetSpeed: Integer; virtual;\n"
        "  end;\n\n"
        "  TCar = class(TVehicle)\n"
        "    function GetSpeed: Integer; override;\n"
        "  end;\n\n"
        "  TTruck = class(TVehicle)\n"
        "    function GetSpeed: Integer; override;\n"
        "  end;\n\n"
        "implementation\n\n"
        "function TVehicle.GetSpeed: Integer; begin Result := 0; end;\n"
        "function TCar.GetSpeed: Integer; begin Result := 100; end;\n"
        "function TTruck.GetSpeed: Integer; begin Result := 80; end;\n\n"
        "end.\n");
    int inherits = store ? cbm_store_count_edges_by_type(store, lp.project, "INHERITS") : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(inherits >= 1); /* TCar->TVehicle, TTruck->TVehicle → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  POWERSHELL — ext: .ps1
 *  Scripting language: function + class definitions, `using module` imports.
 *  OOP inheritance via `: Base`.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* PowerShell: function nodes reach graph. */
TEST(powershell_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "utils.ps1",
        "function Get-Square {\n"
        "    param([double]$x)\n"
        "    return $x * $x\n"
        "}\n\n"
        "function Get-Cube {\n"
        "    param([double]$x)\n"
        "    return $x * (Get-Square $x)\n"
        "}\n\n"
        "function Test-Positive {\n"
        "    param([double]$x)\n"
        "    return $x -gt 0\n"
        "}\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* Get-Square, Get-Cube, Test-Positive */
    PASS();
}

/* PowerShell: class definition reaches graph as type node. */
TEST(powershell_class_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "shapes.ps1",
        "class Shape {\n"
        "    [string]$Name\n"
        "    Shape([string]$name) { $this.Name = $name }\n"
        "    [double] Area() { return 0.0 }\n"
        "}\n\n"
        "class Circle : Shape {\n"
        "    [double]$Radius\n"
        "    Circle([double]$r) : base('Circle') { $this.Radius = $r }\n"
        "    [double] Area() { return [Math]::PI * $this.Radius * $this.Radius }\n"
        "}\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* Shape, Circle */
    PASS();
}

/* PowerShell: `using module` / `using namespace` captured at extraction level. */
TEST(powershell_using_import_extracted) {
    static const char *src =
        "using module ./MyModule\n"
        "using namespace System.IO\n"
        "using assembly System.Drawing\n\n"
        "function Invoke-Task {\n"
        "    param([string]$Path)\n"
        "    [System.IO.File]::Exists($Path)\n"
        "}\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_POWERSHELL, "lc", "task.ps1", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* using module / using namespace → BUG if 0 */
    PASS();
}

/* PowerShell: class inheritance (`: Base`) — extraction captures base_classes. */
TEST(powershell_class_inheritance_extracted) {
    static const char *src =
        "class Animal {\n"
        "    [string]$Name\n"
        "    Animal([string]$name) { $this.Name = $name }\n"
        "    [string] Speak() { return 'some sound' }\n"
        "}\n\n"
        "class Dog : Animal {\n"
        "    Dog([string]$name) : base($name) {}\n"
        "    [string] Speak() { return 'Woof' }\n"
        "}\n\n"
        "class Cat : Animal {\n"
        "    Cat([string]$name) : base($name) {}\n"
        "    [string] Speak() { return 'Meow' }\n"
        "}\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_POWERSHELL, "lc", "animals.ps1", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int found_base = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].base_classes && r->defs.items[i].base_classes[0] != NULL) {
            found_base = 1;
            break;
        }
    }
    cbm_free_result(r);
    ASSERT_TRUE(found_base); /* Dog : Animal, Cat : Animal → BUG if 0 */
    PASS();
}

/* PowerShell: full-pipeline INHERITS edge from same-file class hierarchy. */
TEST(powershell_inherits_edge) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "exceptions.ps1",
        "class AppException {\n"
        "    [string]$Message\n"
        "    AppException([string]$msg) { $this.Message = $msg }\n"
        "}\n\n"
        "class DatabaseException : AppException {\n"
        "    DatabaseException([string]$msg) : base($msg) {}\n"
        "}\n\n"
        "class NetworkException : AppException {\n"
        "    NetworkException([string]$msg) : base($msg) {}\n"
        "}\n");
    int inherits = store ? cbm_store_count_edges_by_type(store, lp.project, "INHERITS") : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(inherits >= 1); /* Database->App, Network->App → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  RACKET — ext: .rkt
 *  Lisp dialect: define functions/procedures, `require` imports.
 *  No class-style inheritance (uses `struct` for types, not OOP classes).
 * ══════════════════════════════════════════════════════════════════════════════ */

/* Racket: function (define) nodes reach graph. */
TEST(racket_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "math.rkt",
        "#lang racket\n\n"
        "(define (square x) (* x x))\n\n"
        "(define (cube x) (* x (square x)))\n\n"
        "(define (sum-of-squares a b)\n"
        "  (+ (square a) (square b)))\n\n"
        "(define (hypotenuse a b)\n"
        "  (sqrt (sum-of-squares a b)))\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* square, cube, sum-of-squares, hypotenuse */
    PASS();
}

/* Racket: struct definition reaches graph as type node. */
TEST(racket_struct_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "point.rkt",
        "#lang racket\n\n"
        "(struct point (x y) #:transparent)\n\n"
        "(struct circle (center radius) #:transparent)\n\n"
        "(define (distance p1 p2)\n"
        "  (let ([dx (- (point-x p2) (point-x p1))]\n"
        "        [dy (- (point-y p2) (point-y p1))])\n"
        "    (sqrt (+ (* dx dx) (* dy dy)))))\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* struct point, struct circle → BUG if 0 */
    PASS();
}

/* Racket: `require` import captured at extraction level. */
TEST(racket_require_import_extracted) {
    static const char *src =
        "#lang racket\n\n"
        "(require racket/list)\n"
        "(require racket/string)\n"
        "(require (only-in racket/math pi))\n\n"
        "(define (circle-area r)\n"
        "  (* pi r r))\n\n"
        "(define (join-words words)\n"
        "  (string-join words \" \"))\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_RACKET, "lc", "utils.rkt", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* require racket/list etc. → BUG if 0 */
    PASS();
}

/* Racket: graph-level IMPORTS edge from two-file project with require. */
TEST(racket_imports_edge) {
    static const ProbeLangFile files[] = {
        {"math.rkt",
         "#lang racket\n"
         "(provide square cube)\n"
         "(define (square x) (* x x))\n"
         "(define (cube x) (* x (square x)))\n"},
        {"main.rkt",
         "#lang racket\n"
         "(require \"math.rkt\")\n"
         "(define (run n) (+ (square n) (cube n)))\n"}};
    ProbeLangProj lp;
    cbm_store_t *store = pb_index_files(&lp, files, 2);
    int imports = store ? cbm_store_count_edges_by_type(store, lp.project, "IMPORTS") : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(imports >= 1); /* main.rkt requires math.rkt → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  RESCRIPT — ext: .res
 *  ReasonML-like JS compiler: let-bound functions, type definitions,
 *  `open` module imports.  No class inheritance.
 * ══════════════════════════════════════════════════════════════════════════════ */

/* ReScript: let-bound function nodes reach graph. */
TEST(rescript_function_nodes) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "math.res",
        "let square = (x: float) => x *. x\n\n"
        "let cube = (x: float) => x *. square(x)\n\n"
        "let clamp = (v: float, lo: float, hi: float) =>\n"
        "  if v < lo { lo } else if v > hi { hi } else { v }\n");
    int fns = store ? pb_callable_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(fns >= 1); /* square, cube, clamp */
    PASS();
}

/* ReScript: type definition reaches graph as type node. */
TEST(rescript_type_node) {
    ProbeLangProj lp;
    cbm_store_t *store = pb_index(&lp, "types.res",
        "type color = Red | Green | Blue\n\n"
        "type point = {\n"
        "  x: float,\n"
        "  y: float,\n"
        "}\n\n"
        "let origin: point = {x: 0.0, y: 0.0}\n\n"
        "let to_hex = (c: color) =>\n"
        "  switch c {\n"
        "  | Red => \"#ff0000\"\n"
        "  | Green => \"#00ff00\"\n"
        "  | Blue => \"#0000ff\"\n"
        "  }\n");
    int types = store ? pb_type_nodes(store, lp.project) : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(types >= 1); /* type color, type point → BUG if 0 */
    PASS();
}

/* ReScript: `open` import captured at extraction level. */
TEST(rescript_open_import_extracted) {
    static const char *src =
        "open Belt\n"
        "open Belt.Array\n\n"
        "let sum = (arr: array<int>) =>\n"
        "  Array.reduce(arr, 0, (acc, x) => acc + x)\n\n"
        "let max_val = (arr: array<int>) =>\n"
        "  Array.reduce(arr, Int.min_int, (acc, x) => if x > acc { x } else { acc })\n";
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src),
                                        CBM_LANG_RESCRIPT, "lc", "utils.res", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int n = r->imports.count;
    cbm_free_result(r);
    ASSERT_TRUE(n >= 1); /* open Belt; open Belt.Array → BUG if 0 */
    PASS();
}

/* ReScript: graph-level IMPORTS edge from two-file project. */
TEST(rescript_imports_edge) {
    static const ProbeLangFile files[] = {
        {"Utils.res",
         "let square = (x: float) => x *. x\n"
         "let cube = (x: float) => x *. square(x)\n"},
        {"Main.res",
         "open Utils\n\n"
         "let run = (n: float) => square(n) +. cube(n)\n"}};
    ProbeLangProj lp;
    cbm_store_t *store = pb_index_files(&lp, files, 2);
    int imports = store ? cbm_store_count_edges_by_type(store, lp.project, "IMPORTS") : -1;
    pb_cleanup(&lp, store);
    ASSERT_TRUE(imports >= 1); /* Main opens Utils → BUG if 0 */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════════════════
 *  SUITE REGISTRATION
 * ══════════════════════════════════════════════════════════════════════════════ */

SUITE(grammar_probe_b) {
    /* ── GLSL (3 cases) ── */
    RUN_TEST(glsl_function_nodes);
    RUN_TEST(glsl_struct_node);
    RUN_TEST(glsl_vertex_shader_functions);

    /* ── Hare (3 cases) ── */
    RUN_TEST(hare_function_nodes);
    RUN_TEST(hare_struct_node);
    RUN_TEST(hare_use_import_extracted);

    /* ── HLSL (3 cases) ── */
    RUN_TEST(hlsl_function_nodes);
    RUN_TEST(hlsl_struct_node);
    RUN_TEST(hlsl_compute_shader_function);

    /* ── ISPC (3 cases) ── */
    RUN_TEST(ispc_function_nodes);
    RUN_TEST(ispc_struct_node);
    RUN_TEST(ispc_task_function);

    /* ── Julia (5 cases) ── */
    RUN_TEST(julia_function_and_struct_nodes);
    RUN_TEST(julia_using_import_extracted);
    RUN_TEST(julia_import_extracted);
    RUN_TEST(julia_abstract_subtype_extracted);
    RUN_TEST(julia_inherits_edge);

    /* ── Luau (3 cases) ── */
    RUN_TEST(luau_function_nodes);
    RUN_TEST(luau_type_nodes);
    RUN_TEST(luau_class_style_functions);

    /* ── MATLAB (2 cases) ── */
    RUN_TEST(matlab_function_nodes);
    RUN_TEST(matlab_multiple_functions);

    /* ── Odin (3 cases) ── */
    RUN_TEST(odin_proc_nodes);
    RUN_TEST(odin_struct_node);
    RUN_TEST(odin_import_extracted);

    /* ── Pascal (5 cases) ── */
    RUN_TEST(pascal_function_nodes);
    RUN_TEST(pascal_record_node);
    RUN_TEST(pascal_uses_import_extracted);
    RUN_TEST(pascal_class_inheritance_extracted);
    RUN_TEST(pascal_inherits_edge);

    /* ── PowerShell (5 cases) ── */
    RUN_TEST(powershell_function_nodes);
    RUN_TEST(powershell_class_node);
    RUN_TEST(powershell_using_import_extracted);
    RUN_TEST(powershell_class_inheritance_extracted);
    RUN_TEST(powershell_inherits_edge);

    /* ── Racket (4 cases) ── */
    RUN_TEST(racket_function_nodes);
    RUN_TEST(racket_struct_node);
    RUN_TEST(racket_require_import_extracted);
    RUN_TEST(racket_imports_edge);

    /* ── ReScript (4 cases) ── */
    RUN_TEST(rescript_function_nodes);
    RUN_TEST(rescript_type_node);
    RUN_TEST(rescript_open_import_extracted);
    RUN_TEST(rescript_imports_edge);
}