/*
 * test_grammar_probe_g.c — Markup / data / config grammar node-creation + edge probe.
 *
 * SCOPE
 * ─────
 * Probes 27 grammars that have little or no code surface:
 *   html, xml, css, scss, markdown, rst, json, json5, yaml, toml, ini,
 *   csv, sql, soql, sosl, dotenv, gitignore, gitattributes, properties,
 *   requirements, diff, po, regex, sshconfig, bibtex, form, linkerscript
 *
 * STRUCTURAL-NODE-BEARING (produce nodes beyond Module):
 *   xml      — Class:2 per fixture  (element nodes)
 *   toml     — Class:1 + Variable:1 (table + key)
 *   ini      — Class:1 + Variable:1 (section + key)
 *   json     — Variable:2           (top-level keys)
 *   yaml     — Variable:2           (top-level keys)
 *   scss     — Variable:1           (one def extracted)
 *   sql      — Variable:1           (table reference node)
 *   markdown — Section:1            (heading node)
 *   form     — Variable:1           (one variable def)
 *
 * PURE-DATA Module-only (only a Module node is created):
 *   html, css, rst, json5, soql, sosl, dotenv, gitignore, gitattributes,
 *   properties, requirements, diff, po, regex, sshconfig, bibtex, linkerscript, csv
 *
 * COLOUR LEGEND
 * ─────────────
 *   GREEN = guard: pipeline already produces the result; failure = regression.
 *   RED   = bug reproduction: pipeline does NOT yet produce the expected
 *           node/edge; the test FAILS until the bug is fixed.  Brief inline
 *           comment documents the root-cause class.
 *
 * CALLS/inheritance dimensions are not applicable to these data/markup grammars.
 * Do NOT register this suite in test_main.c — a sibling agent owns that file.
 *
 * SUITE(grammar_probe_g)
 */

#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>

/* ══════════════════════════════════════════════════════════════════
 * Harness — mirrors test_grammar_probe_a.c exactly.
 * Prefix "gpg_" to avoid symbol collisions with sibling probe files.
 * ══════════════════════════════════════════════════════════════════ */

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

typedef struct {
    const char *name; /* relative filename, may include '/' for subdirs */
    const char *content;
} GpgFile;

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

static cbm_store_t *gpg_open_indexed(GpgProj *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 *gpg_index_files(GpgProj *lp, const GpgFile *files, int nfiles) {
    memset(lp, 0, sizeof(*lp));
    snprintf(lp->tmpdir, sizeof(lp->tmpdir), "/tmp/cbm_gpg_XXXXXX");
    if (!cbm_mkdtemp(lp->tmpdir))
        return NULL;
    gpg_to_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 gpg_open_indexed(lp);
}

static void gpg_cleanup(GpgProj *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);
    unlink(wal);
    snprintf(shm, sizeof(shm), "%s-shm", lp->dbpath);
    unlink(shm);
}

/* ── Node-count helpers ─────────────────────────────────────────── */

static int gpg_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;
}

typedef struct {
    int ok;
    int total_nodes;
    int modules;
    int classes;
    int variables;
    int sections;
    int imports; /* IMPORTS edges */
    int depends; /* DEPENDS_ON edges */
} GpgMetrics;

static GpgMetrics gpg_metrics_files(const GpgFile *files, int nfiles) {
    GpgProj lp;
    cbm_store_t *store = gpg_index_files(&lp, files, nfiles);
    GpgMetrics m = {0};
    if (store) {
        m.ok = 1;
        m.total_nodes = cbm_store_count_nodes(store, lp.project);
        m.modules = gpg_count_label(store, lp.project, "Module");
        m.classes = gpg_count_label(store, lp.project, "Class");
        m.variables = gpg_count_label(store, lp.project, "Variable");
        m.sections = gpg_count_label(store, lp.project, "Section");
        m.imports = cbm_store_count_edges_by_type(store, lp.project, "IMPORTS");
        m.depends = cbm_store_count_edges_by_type(store, lp.project, "DEPENDS_ON");
    }
    gpg_cleanup(&lp, store);
    return m;
}

static GpgMetrics gpg_metrics(const char *filename, const char *content) {
    GpgFile f = {filename, content};
    return gpg_metrics_files(&f, 1);
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 1 — HTML (.html)
 *
 * HTML golden histogram: Module:1 (pure-data — no element nodes extracted).
 * <script src="..."> and <link href="..."> are the only edges the pipeline
 * could model, but no HTML IMPORTS resolver exists in the pipeline today.
 * ══════════════════════════════════════════════════════════════════ */

/* HTML: minimal page → at least 1 Module node, no crash. */
TEST(probe_html_minimal_page) {
    GpgMetrics m = gpg_metrics("index.html", "<!DOCTYPE html>\n"
                                             "<html><head><title>Test</title></head>\n"
                                             "<body><h1>Hello</h1></body></html>\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: HTML always produces at least a Module node. */
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* HTML: file with <script src> and <link rel=stylesheet> → IMPORTS edges.
 * RED: no HTML import resolver; script/link attributes are not walked into
 *      IMPORTS edges by the pipeline. */
TEST(probe_html_script_imports) {
    static const GpgFile files[] = {{"app.js", "function init() { console.log('ready'); }\n"},
                                    {"index.html", "<!DOCTYPE html><html><head>\n"
                                                   "<link rel=\"stylesheet\" href=\"style.css\">\n"
                                                   "<script src=\"app.js\"></script>\n"
                                                   "</head><body></body></html>\n"}};
    GpgMetrics m = gpg_metrics_files(files, 2);
    ASSERT_TRUE(m.ok);
    /* RED: HTML <script src> / <link href> not resolved into IMPORTS edges. */
    ASSERT_TRUE(m.imports >= 1); /* expected RED — no HTML import resolver */
    PASS();
}

/* HTML: pure-data — no Class/Variable/Section nodes expected. */
TEST(probe_html_no_structural_nodes) {
    GpgMetrics m = gpg_metrics("page.html", "<html><body><p>text</p></body></html>\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: HTML produces zero Class/Variable/Section nodes (pure-data). */
    ASSERT_TRUE(m.classes == 0);
    ASSERT_TRUE(m.variables == 0);
    ASSERT_TRUE(m.sections == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 2 — XML (.xml)
 *
 * XML golden histogram: Class:2, Module:1
 * The XML extractor produces Class nodes for element definitions
 * (e.g., root element + nested element type nodes).
 * ══════════════════════════════════════════════════════════════════ */

/* XML: minimal document → Module node + at least 2 Class nodes. */
TEST(probe_xml_element_nodes) {
    GpgMetrics m = gpg_metrics("config.xml", "<?xml version=\"1.0\"?>\n"
                                             "<config>\n"
                                             "  <server host=\"localhost\" port=\"8080\"/>\n"
                                             "  <database name=\"mydb\"/>\n"
                                             "</config>\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: XML extractor produces Class nodes for elements. */
    ASSERT_TRUE(m.classes >= 2);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* XML: more elements → more Class nodes (≥ 2). */
TEST(probe_xml_multiple_elements) {
    GpgMetrics m = gpg_metrics("pom.xml", "<project>\n"
                                          "  <groupId>com.example</groupId>\n"
                                          "  <artifactId>demo</artifactId>\n"
                                          "  <version>1.0</version>\n"
                                          "</project>\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: multiple element types must produce Class nodes. */
    ASSERT_TRUE(m.classes >= 2);
    PASS();
}

/* XML: no-crash guard for empty document. */
TEST(probe_xml_no_crash) {
    GpgMetrics m = gpg_metrics("empty.xml", "<?xml version=\"1.0\"?><root/>\n");
    ASSERT_TRUE(m.ok);
    ASSERT_TRUE(m.total_nodes >= 1);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 3 — CSS (.css)
 *
 * CSS golden histogram: Module:1 (pure-data).
 * CSS selectors/rules are not extracted as graph nodes; only a Module
 * node is emitted per file.
 * ══════════════════════════════════════════════════════════════════ */

/* CSS: rules file → only a Module node. */
TEST(probe_css_module_only) {
    GpgMetrics m = gpg_metrics("styles.css", "body {\n"
                                             "  margin: 0;\n"
                                             "  font-family: sans-serif;\n"
                                             "}\n"
                                             ".container { max-width: 1200px; }\n"
                                             "#header { background: #fff; }\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: CSS produces exactly 1 Module node; no Class/Variable/Section. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.classes == 0);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* CSS: @import in two-file fixture → IMPORTS edge.
 * RED: no CSS import resolver in the pipeline. */
TEST(probe_css_at_import) {
    static const GpgFile files[] = {{"base.css", "* { box-sizing: border-box; }\n"},
                                    {"main.css", "@import \"base.css\";\n"
                                                 "body { margin: 0; }\n"}};
    GpgMetrics m = gpg_metrics_files(files, 2);
    ASSERT_TRUE(m.ok);
    /* RED: CSS @import not resolved into IMPORTS edges. */
    ASSERT_TRUE(m.imports >= 1); /* expected RED — no CSS import resolver */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 4 — SCSS (.scss)
 *
 * SCSS golden histogram: Module:1, Variable:1
 * The extractor pulls at least one Variable node (e.g. a CSS custom property
 * or SCSS variable).  No selector/rule Class nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* SCSS: variables + rules → at least 1 Variable node. */
TEST(probe_scss_variable_node) {
    GpgMetrics m = gpg_metrics("theme.scss", "$primary: #3498db;\n"
                                             "$secondary: #2ecc71;\n"
                                             "\n"
                                             ".button {\n"
                                             "  background: $primary;\n"
                                             "  color: white;\n"
                                             "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: SCSS extracts at least 1 Variable node (histogram: Variable:1). */
    ASSERT_TRUE(m.variables >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* SCSS: @import / @use in two-file fixture → IMPORTS edge.
 * RED: no SCSS import resolver in the pipeline. */
TEST(probe_scss_at_use_imports) {
    static const GpgFile files[] = {{"_vars.scss", "$brand: #e74c3c;\n"},
                                    {"main.scss", "@use 'vars';\n"
                                                  ".hero { color: vars.$brand; }\n"}};
    GpgMetrics m = gpg_metrics_files(files, 2);
    ASSERT_TRUE(m.ok);
    /* RED: SCSS @use / @import not resolved into IMPORTS edges. */
    ASSERT_TRUE(m.imports >= 1); /* expected RED — no SCSS import resolver */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 5 — Markdown (.md)
 *
 * Markdown golden histogram: Module:1, Section:1
 * Headings become Section nodes.  Links are NOT resolved to IMPORTS edges.
 * ══════════════════════════════════════════════════════════════════ */

/* Markdown: document with headings → at least 1 Section node. */
TEST(probe_markdown_section_node) {
    GpgMetrics m = gpg_metrics("README.md", "# Project Title\n"
                                            "\n"
                                            "Description text.\n"
                                            "\n"
                                            "## Getting Started\n"
                                            "\n"
                                            "Install with `npm install`.\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: Markdown headings produce Section nodes. */
    ASSERT_TRUE(m.sections >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* Markdown: multiple headings → at least 1 Section (histogram baseline: Section:1).
 * The histogram fixture has 1 section; additional headings may or may not add more. */
TEST(probe_markdown_multi_heading) {
    GpgMetrics m = gpg_metrics("docs.md", "# Title\n"
                                          "## Setup\n"
                                          "### Install\n"
                                          "## Usage\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: at minimum 1 Section node. */
    ASSERT_TRUE(m.sections >= 1);
    PASS();
}

/* Markdown: no Class/Variable nodes (pure-data beyond Section). */
TEST(probe_markdown_no_class_variable) {
    GpgMetrics m = gpg_metrics("notes.md", "# Notes\n\nSome content.\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: Markdown does not produce Class or Variable nodes. */
    ASSERT_TRUE(m.classes == 0);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 6 — RST (.rst)
 *
 * RST golden histogram: Module:1 (pure-data).
 * reStructuredText headings are NOT extracted as Section nodes (unlike Markdown).
 * ══════════════════════════════════════════════════════════════════ */

/* RST: document with sections → Module:1, no Section nodes. */
TEST(probe_rst_module_only) {
    GpgMetrics m = gpg_metrics("docs.rst", "Project Title\n"
                                           "=============\n"
                                           "\n"
                                           "Description text.\n"
                                           "\n"
                                           "Installation\n"
                                           "------------\n"
                                           "\n"
                                           "Run ``pip install mypackage``.\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: RST produces only a Module node (no Section nodes extracted). */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.sections == 0);
    PASS();
}

/* RST: no-crash guard. */
TEST(probe_rst_no_crash) {
    GpgMetrics m = gpg_metrics("api.rst", ".. automodule:: mypackage.api\n"
                                          "   :members:\n");
    ASSERT_TRUE(m.ok);
    ASSERT_TRUE(m.total_nodes >= 1);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 7 — JSON (.json)
 *
 * JSON golden histogram: Module:1, Variable:2
 * Top-level keys become Variable nodes (2 in the fixture).
 * ══════════════════════════════════════════════════════════════════ */

/* JSON: object with two top-level keys → 2 Variable nodes. */
TEST(probe_json_variable_nodes) {
    GpgMetrics m = gpg_metrics("config.json", "{\n"
                                              "  \"name\": \"myproject\",\n"
                                              "  \"version\": \"1.0.0\"\n"
                                              "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: JSON top-level keys become Variable nodes. */
    ASSERT_TRUE(m.variables >= 2);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* JSON: three top-level keys → ≥ 2 Variable nodes (floor from histogram). */
TEST(probe_json_more_variables) {
    /* Fixture fix: "package.json" is in discover.c IGNORED_JSON_FILES, so
     * detect_file_language() returns CBM_LANG_COUNT and the file is never
     * indexed (0 nodes).  Use a generic .json filename so the JSON grammar
     * actually runs (grammar_labels json=Variable:2). */
    GpgMetrics m = gpg_metrics("data.json", "{\n"
                                            "  \"name\": \"demo\",\n"
                                            "  \"version\": \"0.1.0\",\n"
                                            "  \"description\": \"A demo project\"\n"
                                            "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: at least 2 Variable nodes (histogram baseline). */
    ASSERT_TRUE(m.variables >= 2);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 8 — JSON5 (.json5)
 *
 * JSON5 golden histogram: Module:1 (pure-data).
 * Despite being a superset of JSON, the JSON5 extractor produces only Module.
 * ══════════════════════════════════════════════════════════════════ */

/* JSON5: file with keys → only Module node. */
TEST(probe_json5_module_only) {
    GpgMetrics m = gpg_metrics("config.json5", "{\n"
                                               "  // comments allowed\n"
                                               "  name: 'myproject',\n"
                                               "  version: '1.0',\n"
                                               "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: JSON5 produces only a Module node (no Variable nodes unlike JSON). */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 9 — YAML (.yaml)
 *
 * YAML golden histogram: Module:1, Variable:2
 * Top-level keys become Variable nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* YAML: document with two top-level keys → 2 Variable nodes. */
TEST(probe_yaml_variable_nodes) {
    GpgMetrics m = gpg_metrics("config.yaml", "name: myproject\n"
                                              "version: 1.0.0\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: YAML top-level keys become Variable nodes. */
    ASSERT_TRUE(m.variables >= 2);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* YAML: three top-level keys → still ≥ 2 Variable nodes (baseline). */
TEST(probe_yaml_three_keys) {
    GpgMetrics m = gpg_metrics("app.yaml", "host: localhost\n"
                                           "port: 8080\n"
                                           "debug: true\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: at least 2 Variable nodes. */
    ASSERT_TRUE(m.variables >= 2);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 10 — TOML (.toml)
 *
 * TOML golden histogram: Class:1, Module:1, Variable:1
 * Table headers produce Class nodes; top-level keys produce Variable nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* TOML: file with table + key → Class:1 + Variable:1. */
TEST(probe_toml_table_and_key) {
    GpgMetrics m = gpg_metrics("Cargo.toml", "[package]\n"
                                             "name = \"mylib\"\n"
                                             "version = \"0.1.0\"\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: TOML table [package] becomes a Class node. */
    ASSERT_TRUE(m.classes >= 1);
    /* GREEN: key becomes a Variable node. */
    ASSERT_TRUE(m.variables >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* TOML: multiple tables → ≥ 1 Class node (may be exactly 1 per fixture). */
TEST(probe_toml_multiple_tables) {
    GpgMetrics m = gpg_metrics("pyproject.toml", "[tool.poetry]\n"
                                                 "name = \"demo\"\n"
                                                 "\n"
                                                 "[tool.poetry.dependencies]\n"
                                                 "python = \"^3.9\"\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: at least one Class node for tables. */
    ASSERT_TRUE(m.classes >= 1);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 11 — INI (.ini)
 *
 * INI golden histogram: Class:1, Module:1, Variable:1
 * Sections produce Class nodes; key-value pairs produce Variable nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* INI: file with a section and a key → Class + Variable. */
TEST(probe_ini_section_and_key) {
    GpgMetrics m = gpg_metrics("app.ini", "[database]\n"
                                          "host = localhost\n"
                                          "port = 5432\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: [database] section becomes a Class node. */
    ASSERT_TRUE(m.classes >= 1);
    /* GREEN: key becomes a Variable node. */
    ASSERT_TRUE(m.variables >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* INI: .conf extension also maps to CBM_LANG_INI; must produce same structure. */
TEST(probe_ini_conf_extension) {
    GpgMetrics m = gpg_metrics("server.conf", "[server]\n"
                                              "listen = 0.0.0.0\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: .conf files index as INI and produce Class + Variable nodes. */
    ASSERT_TRUE(m.classes >= 1);
    ASSERT_TRUE(m.variables >= 1);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 12 — CSV (.csv)
 *
 * CSV golden histogram: Module:1 (pure-data).
 * Tabular data — no structural nodes beyond Module.
 * ══════════════════════════════════════════════════════════════════ */

/* CSV: file with header + rows → only Module node. */
TEST(probe_csv_module_only) {
    GpgMetrics m = gpg_metrics("data.csv", "id,name,score\n"
                                           "1,Alice,95\n"
                                           "2,Bob,87\n"
                                           "3,Carol,92\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: CSV produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.classes == 0);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 13 — SQL (.sql)
 *
 * SQL golden histogram: Module:1, Variable:1
 * Table references (e.g. CREATE TABLE / SELECT FROM) produce Variable nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* SQL: CREATE TABLE + SELECT → at least 1 Variable node. */
TEST(probe_sql_variable_node) {
    GpgMetrics m = gpg_metrics("schema.sql", "CREATE TABLE users (\n"
                                             "  id INTEGER PRIMARY KEY,\n"
                                             "  name TEXT NOT NULL\n"
                                             ");\n"
                                             "\n"
                                             "SELECT id, name FROM users WHERE id = 1;\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: SQL table reference produces at least 1 Variable node. */
    ASSERT_TRUE(m.variables >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* SQL: multiple statements → still at least 1 Variable. */
TEST(probe_sql_insert_select) {
    GpgMetrics m = gpg_metrics(
        "queries.sql", "INSERT INTO orders (user_id, total) VALUES (1, 99.99);\n"
                       "SELECT o.id, u.name FROM orders o JOIN users u ON o.user_id = u.id;\n");
    ASSERT_TRUE(m.ok);
    /* GREEN (fixture fix): SQL Variable nodes come ONLY from DDL
     * create_table/create_view (lang_specs.c sql_var_types), NOT from
     * DML table *references* in INSERT/SELECT.  A DML-only file correctly
     * yields 0 Variable nodes; the original `>= 1` asserted a non-feature.
     * Assert the true contract: no table definitions → 0 Variables. */
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 14 — SOQL (.soql)
 *
 * SOQL golden histogram: Module:1 (pure-data).
 * Salesforce Object Query Language — no structural nodes extracted.
 * ══════════════════════════════════════════════════════════════════ */

/* SOQL: SELECT query → only Module node. */
TEST(probe_soql_module_only) {
    GpgMetrics m = gpg_metrics("query.soql", "SELECT Id, Name, Email\n"
                                             "FROM Contact\n"
                                             "WHERE AccountId = :accountId\n"
                                             "ORDER BY Name\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: SOQL produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 15 — SOSL (.sosl)
 *
 * SOSL golden histogram: Module:1 (pure-data).
 * Salesforce Object Search Language — no structural nodes extracted.
 * ══════════════════════════════════════════════════════════════════ */

/* SOSL: FIND query → only Module node. */
TEST(probe_sosl_module_only) {
    GpgMetrics m = gpg_metrics("search.sosl", "FIND {Acme} IN ALL FIELDS\n"
                                              "RETURNING Account(Id, Name), Contact(Id, Name)\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: SOSL produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 16 — DotEnv (.env)
 *
 * DotEnv golden histogram: Module:1 (pure-data).
 * Environment variable files are pure-data; keys are NOT extracted as nodes.
 * Extension: .env suffix detected by pass_envscan; filename ".env" also works.
 * ══════════════════════════════════════════════════════════════════ */

/* DotEnv: .env file → only Module node. */
TEST(probe_dotenv_module_only) {
    GpgMetrics m = gpg_metrics(".env", "DATABASE_URL=postgres://localhost/mydb\n"
                                       "SECRET_KEY=supersecret\n"
                                       "DEBUG=true\n");
    ASSERT_TRUE(m.ok);
    /* REAL BUG (NEW class — file-index routing gap): the DotEnv grammar +
     * histogram (grammar_labels dotenv=Module:1) exist and work via DIRECT
     * extraction, but ".env" has no FILENAME_TABLE / EXT_TABLE entry in
     * language.c, so file-based index_repository's cbm_language_for_filename
     * returns CBM_LANG_COUNT and the file is never indexed → 0 Module nodes.
     * Routing/registration gap, distinct from extraction classes 2/16.  RED. */
    ASSERT_TRUE(m.modules == 1); /* REAL BUG — .env not routed by file index */
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* DotEnv: .env.local suffix variant → indexed as DotEnv. */
TEST(probe_dotenv_local_suffix) {
    GpgMetrics m = gpg_metrics(".env.local", "API_KEY=local-test-key\n"
                                             "PORT=3001\n");
    ASSERT_TRUE(m.ok);
    /* REAL BUG (NEW class — file-index routing gap): ".env.local" has no
     * FILENAME_TABLE/EXT_TABLE entry, so file-based index_repository never
     * routes it to CBM_LANG_DOTENV → 0 Module nodes.  Same routing gap as
     * probe_dotenv_module_only.  RED. */
    ASSERT_TRUE(m.modules >= 1); /* REAL BUG — .env.local not routed by file index */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 17 — gitignore (.gitignore)
 *
 * gitignore golden histogram: Module:1 (pure-data).
 * Pattern files — no structural graph nodes.
 * Extension: cbm_path_ext(".gitignore") → "gitignore" (strips the leading dot).
 * ══════════════════════════════════════════════════════════════════ */

/* gitignore: pattern file → only Module node. */
TEST(probe_gitignore_module_only) {
    GpgMetrics m = gpg_metrics(".gitignore", "*.o\n"
                                             "*.a\n"
                                             "build/\n"
                                             "dist/\n"
                                             ".DS_Store\n");
    ASSERT_TRUE(m.ok);
    /* CONTRACT (corrected): unlike .gitattributes, ".gitignore" is intentionally
     * NOT indexed as a source file — the cbm_discover walker consumes it as
     * ignore-rule input (see test_discover.c discover_with_gitignore /
     * discover_gitignore_dir_excluded_issue234 / discover_cbmignore_stacks,
     * which assert .gitignore is excluded from the discovered file set). The
     * gitignore grammar exists for DIRECT extraction only; via the file walker
     * the ignore-control role wins by design, so it yields 0 nodes. Routing it
     * to CBM_LANG_GITIGNORE would regress those three established tests. */
    ASSERT_TRUE(m.modules == 0); /* .gitignore consumed as ignore-rules, not indexed (by design) */
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 18 — gitattributes (.gitattributes)
 *
 * gitattributes golden histogram: Module:1 (pure-data).
 * ══════════════════════════════════════════════════════════════════ */

/* gitattributes: attribute file → only Module node. */
TEST(probe_gitattributes_module_only) {
    GpgMetrics m = gpg_metrics(".gitattributes", "*.c text eol=lf\n"
                                                 "*.h text eol=lf\n"
                                                 "*.png binary\n"
                                                 "*.jpg binary\n");
    ASSERT_TRUE(m.ok);
    /* REAL BUG (NEW class — file-index routing gap): gitattributes grammar +
     * histogram (Module:1) work via DIRECT extraction, but ".gitattributes"
     * has no FILENAME_TABLE/EXT_TABLE entry → file-based index_repository
     * never routes it → 0 Module nodes.  Same routing gap as .gitignore. */
    ASSERT_TRUE(m.modules == 1); /* REAL BUG — .gitattributes not routed by file index */
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 19 — Properties (.properties)
 *
 * Properties golden histogram: Module:1 (pure-data).
 * Java-style key=value files — keys NOT extracted as Variable nodes
 * (unlike INI which does produce Class/Variable nodes).
 * ══════════════════════════════════════════════════════════════════ */

/* Properties: key=value file → only Module node. */
TEST(probe_properties_module_only) {
    GpgMetrics m = gpg_metrics("app.properties", "server.host=localhost\n"
                                                 "server.port=8080\n"
                                                 "log.level=INFO\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: .properties produces a Module node plus one Variable per `key=value`
     * property line (extract_defs.c CBM_LANG_PROPERTIES → push_var_def). The
     * fixture has 3 property lines (server.host, server.port, log.level). */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 3);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 20 — Requirements (.txt via FILENAME_TABLE)
 *
 * Requirements golden histogram: Module:1 (pure-data).
 * Python dependency specs — deps NOT extracted as DEPENDS_ON edges by
 * the grammar-only pipeline (no requirements resolver).
 * Extension: recognized only for "requirements.txt", "requirements-dev.txt",
 *            "requirements-test.txt" (FILENAME_TABLE exact match).
 * ══════════════════════════════════════════════════════════════════ */

/* Requirements: dep file → only Module node. */
TEST(probe_requirements_module_only) {
    GpgMetrics m = gpg_metrics("requirements.txt", "flask==2.3.0\n"
                                                   "requests>=2.28.0\n"
                                                   "sqlalchemy~=2.0\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: requirements.txt produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    PASS();
}

/* Requirements: DEPENDS_ON edges for package entries.
 * RED: grammar-only requirements has no dependency-edge resolver. */
TEST(probe_requirements_depends_on_edge) {
    GpgMetrics m = gpg_metrics("requirements.txt", "numpy==1.24.0\n"
                                                   "pandas>=1.5.0\n"
                                                   "scipy>=1.10.0\n");
    ASSERT_TRUE(m.ok);
    /* RED: requirements deps not resolved into DEPENDS_ON edges. */
    ASSERT_TRUE(m.depends >= 1); /* expected RED — no requirements edge resolver */
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 21 — Diff (.diff / .patch)
 *
 * Diff golden histogram: Module:1 (pure-data).
 * Patch files are structural metadata, not code.
 * ══════════════════════════════════════════════════════════════════ */

/* Diff: unified diff → only Module node. */
TEST(probe_diff_module_only) {
    GpgMetrics m = gpg_metrics("changes.diff", "--- a/main.c\n"
                                               "+++ b/main.c\n"
                                               "@@ -1,5 +1,6 @@\n"
                                               " #include <stdio.h>\n"
                                               "+#include <stdlib.h>\n"
                                               " \n"
                                               " int main(void) {\n"
                                               "-    printf(\"hello\\n\");\n"
                                               "+    printf(\"hello world\\n\");\n"
                                               "     return 0;\n"
                                               " }\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: diff produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 22 — PO (.po)
 *
 * PO golden histogram: Module:1 (pure-data).
 * GNU gettext translation catalogs — no structural nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* PO: translation file → only Module node. */
TEST(probe_po_module_only) {
    GpgMetrics m = gpg_metrics("messages.po", "# Translation file\n"
                                              "msgid \"\"\n"
                                              "msgstr \"\"\n"
                                              "\"Content-Type: text/plain; charset=UTF-8\\n\"\n"
                                              "\n"
                                              "msgid \"Hello\"\n"
                                              "msgstr \"Bonjour\"\n"
                                              "\n"
                                              "msgid \"Goodbye\"\n"
                                              "msgstr \"Au revoir\"\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: PO produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 23 — Regex (.re)
 *
 * Regex golden histogram: Module:1 (pure-data).
 * Extension: ".re" maps to CBM_LANG_REGEX in grammar_cases.
 * ══════════════════════════════════════════════════════════════════ */

/* Regex: pattern file → only Module node. */
TEST(probe_regex_module_only) {
    GpgMetrics m = gpg_metrics("patterns.re", "(foo|bar)+\n"
                                              "^[a-zA-Z_][a-zA-Z0-9_]*$\n"
                                              "\\d{4}-\\d{2}-\\d{2}\n");
    ASSERT_TRUE(m.ok);
    /* REAL BUG (NEW class — file-index routing gap): the Regex grammar +
     * histogram (grammar_labels regex=Module:1) work via DIRECT extraction
     * (a.re), but the ".re" extension has no EXT_TABLE entry in language.c,
     * so file-based index_repository never routes it → 0 Module nodes.
     * Routing/registration gap, distinct from extraction classes 2/16.  RED. */
    ASSERT_TRUE(m.modules == 1); /* REAL BUG — .re not routed by file index */
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 24 — SSH Config (ssh_config / sshd_config / config)
 *
 * SSH Config golden histogram: Module:1 (pure-data).
 * Special filenames: "ssh_config", "sshd_config", ".ssh/config" (FILENAME_TABLE).
 * Also matches "config" basename in certain contexts (grammar_regression uses "config").
 * ══════════════════════════════════════════════════════════════════ */

/* SSH Config: host file via ssh_config filename → only Module node. */
TEST(probe_sshconfig_module_only) {
    GpgMetrics m = gpg_metrics("ssh_config", "Host bastion\n"
                                             "  HostName 10.0.0.1\n"
                                             "  User ubuntu\n"
                                             "  IdentityFile ~/.ssh/id_rsa\n"
                                             "\n"
                                             "Host dev\n"
                                             "  HostName dev.example.com\n"
                                             "  User deploy\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: SSH config produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 25 — BibTeX (.bib)
 *
 * BibTeX golden histogram: Module:1 (pure-data).
 * Bibliography entries are NOT extracted as structural nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* BibTeX: bibliography file → only Module node. */
TEST(probe_bibtex_module_only) {
    GpgMetrics m = gpg_metrics("refs.bib", "@article{smith2023,\n"
                                           "  author = {Smith, John},\n"
                                           "  title  = {A Study of Something},\n"
                                           "  year   = {2023},\n"
                                           "  journal = {J. Examples}\n"
                                           "}\n"
                                           "\n"
                                           "@book{jones2020,\n"
                                           "  author = {Jones, Alice},\n"
                                           "  title  = {Reference Book},\n"
                                           "  year   = {2020}\n"
                                           "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: BibTeX produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 26 — FORM (.frm)
 *
 * FORM golden histogram: Module:1, Variable:1
 * The FORM language (symbolic algebra) produces a Variable node for
 * one definition.  Extension: .frm (CBM_LANG_FORM in EXT_TABLE).
 * ══════════════════════════════════════════════════════════════════ */

/* FORM: file with a variable declaration → at least 1 Variable node. */
TEST(probe_form_variable_node) {
    GpgMetrics m = gpg_metrics("calc.frm", "Symbol x, y, z;\n"
                                           "Local F = x^2 + y^2 + z^2;\n"
                                           "Print;\n"
                                           ".end\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: FORM produces at least 1 Variable node (histogram: Variable:1). */
    ASSERT_TRUE(m.variables >= 1);
    ASSERT_TRUE(m.modules >= 1);
    PASS();
}

/* FORM: no-crash guard with procedure definition. */
TEST(probe_form_procedure) {
    GpgMetrics m = gpg_metrics("proc.frm", "#procedure Square(x)\n"
                                           "  id `x'^2 = `x'^2;\n"
                                           "#endprocedure\n"
                                           "\n"
                                           "Symbol a;\n"
                                           "Local expr = a^2;\n"
                                           ".end\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: at least 1 node (Module). */
    ASSERT_TRUE(m.total_nodes >= 1);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * GROUP 27 — Linker Script (.ld / .lds)
 *
 * Linker Script golden histogram: Module:1 (pure-data).
 * SECTIONS / MEMORY directives are not extracted as structural nodes.
 * ══════════════════════════════════════════════════════════════════ */

/* Linker script: SECTIONS directive → only Module node. */
TEST(probe_linkerscript_module_only) {
    GpgMetrics m = gpg_metrics("link.ld", "SECTIONS\n"
                                          "{\n"
                                          "  . = 0x10000;\n"
                                          "  .text : { *(.text) }\n"
                                          "  .data : { *(.data) }\n"
                                          "  .bss  : { *(.bss) }\n"
                                          "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: linker script produces only a Module node. */
    ASSERT_TRUE(m.modules == 1);
    ASSERT_TRUE(m.variables == 0);
    PASS();
}

/* Linker script: MEMORY + SECTIONS → still only Module node. */
TEST(probe_linkerscript_memory_sections) {
    GpgMetrics m = gpg_metrics("stm32.ld", "MEMORY\n"
                                           "{\n"
                                           "  FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 512K\n"
                                           "  RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 128K\n"
                                           "}\n"
                                           "SECTIONS\n"
                                           "{\n"
                                           "  .isr_vector : { *(.isr_vector) } > FLASH\n"
                                           "  .text       : { *(.text*)     } > FLASH\n"
                                           "  .bss        : { *(.bss*)      } > RAM\n"
                                           "}\n");
    ASSERT_TRUE(m.ok);
    /* GREEN: linker script produces only a Module node. */
    ASSERT_TRUE(m.modules >= 1);
    ASSERT_TRUE(m.classes == 0);
    PASS();
}

/* ══════════════════════════════════════════════════════════════════
 * SUITE wiring
 * ══════════════════════════════════════════════════════════════════ */

SUITE(grammar_probe_g) {
    /* HTML */
    RUN_TEST(probe_html_minimal_page);
    RUN_TEST(probe_html_script_imports);
    RUN_TEST(probe_html_no_structural_nodes);

    /* XML */
    RUN_TEST(probe_xml_element_nodes);
    RUN_TEST(probe_xml_multiple_elements);
    RUN_TEST(probe_xml_no_crash);

    /* CSS */
    RUN_TEST(probe_css_module_only);
    RUN_TEST(probe_css_at_import);

    /* SCSS */
    RUN_TEST(probe_scss_variable_node);
    RUN_TEST(probe_scss_at_use_imports);

    /* Markdown */
    RUN_TEST(probe_markdown_section_node);
    RUN_TEST(probe_markdown_multi_heading);
    RUN_TEST(probe_markdown_no_class_variable);

    /* RST */
    RUN_TEST(probe_rst_module_only);
    RUN_TEST(probe_rst_no_crash);

    /* JSON */
    RUN_TEST(probe_json_variable_nodes);
    RUN_TEST(probe_json_more_variables);

    /* JSON5 */
    RUN_TEST(probe_json5_module_only);

    /* YAML */
    RUN_TEST(probe_yaml_variable_nodes);
    RUN_TEST(probe_yaml_three_keys);

    /* TOML */
    RUN_TEST(probe_toml_table_and_key);
    RUN_TEST(probe_toml_multiple_tables);

    /* INI */
    RUN_TEST(probe_ini_section_and_key);
    RUN_TEST(probe_ini_conf_extension);

    /* CSV */
    RUN_TEST(probe_csv_module_only);

    /* SQL */
    RUN_TEST(probe_sql_variable_node);
    RUN_TEST(probe_sql_insert_select);

    /* SOQL */
    RUN_TEST(probe_soql_module_only);

    /* SOSL */
    RUN_TEST(probe_sosl_module_only);

    /* DotEnv */
    RUN_TEST(probe_dotenv_module_only);
    RUN_TEST(probe_dotenv_local_suffix);

    /* gitignore */
    RUN_TEST(probe_gitignore_module_only);

    /* gitattributes */
    RUN_TEST(probe_gitattributes_module_only);

    /* Properties */
    RUN_TEST(probe_properties_module_only);

    /* Requirements */
    RUN_TEST(probe_requirements_module_only);
    RUN_TEST(probe_requirements_depends_on_edge);

    /* Diff */
    RUN_TEST(probe_diff_module_only);

    /* PO */
    RUN_TEST(probe_po_module_only);

    /* Regex */
    RUN_TEST(probe_regex_module_only);

    /* SSH Config */
    RUN_TEST(probe_sshconfig_module_only);

    /* BibTeX */
    RUN_TEST(probe_bibtex_module_only);

    /* FORM */
    RUN_TEST(probe_form_variable_node);
    RUN_TEST(probe_form_procedure);

    /* Linker Script */
    RUN_TEST(probe_linkerscript_module_only);
    RUN_TEST(probe_linkerscript_memory_sections);
}