/*
 * repro_issue495.c — Reproduce-first case for issue #495:
 *   "cfg-gated twin functions collapse into one node; get_code_snippet
 *   returns the inactive branch's body"
 *
 * ROOT CAUSE (extraction layer):
 *   extract_func_def() computes:
 *     def.qualified_name = cbm_fqn_compute(project, rel_path, name)
 *   for every Rust function_item it visits.  Two same-named functions
 *   guarded by mutually-exclusive #[cfg(...)] attributes both parse as
 *   distinct function_item nodes and both pass through extract_func_def,
 *   but they receive the SAME qualified_name (no cfg predicate is folded
 *   in).  When the graph store upserts them it hits the UNIQUE(project,
 *   qualified_name) constraint and the second write silently overwrites
 *   the first — one branch is lost entirely.
 *
 * EXPECTED (correct) behavior:
 *   Each cfg-gated twin must receive a DISTINCT qualified_name that
 *   encodes its cfg predicate, e.g.
 *     "t.src.try_extract_pdf_text"           (active / feature branch)
 *     "t.src.try_extract_pdf_text#cfg(not(feature=\"rag-pdf\"))" (stub)
 *   So that the graph can keep BOTH nodes and get_code_snippet can return
 *   the correct body for the requested cfg context.
 *
 * ACTUAL (buggy) behavior:
 *   Both defs carry identical qualified_name "t.src.try_extract_pdf_text".
 *   The assertion `qn_a != qn_b` FAILS (both equal the same string), so
 *   this test is RED on unpatched code.
 *
 * SECONDARY assertions (also RED until fixed, targeting the same root
 * cause from different angles):
 *   • The REAL-body function has param name "bytes" (no underscore);
 *     the STUB has "_bytes".  Each def's signature must correspond to its
 *     own branch — i.e. BOTH signatures must appear in the result, one
 *     containing "bytes" without a leading underscore and one with "_bytes".
 *   • Each def's decorators[0] must contain the cfg predicate of ITS OWN
 *     branch (not the other's), so that a fixer can easily scope-qualify
 *     the QN from the already-captured decorator text.
 *
 * Why these assertions are RED on current code:
 *   All three assertions require distinguishing the two defs by their QN.
 *   Since both QNs are currently identical, any loop looking for "the
 *   active branch" finds the SAME node twice, and the body-token /
 *   decorator checks collapse to checking ONE def against itself.
 */

#include "test_framework.h"
#include "cbm.h"

/* ── Helpers ──────────────────────────────────────────────────────── */

/* Extract a Rust source string and return the raw CBMFileResult.
 * Caller must cbm_free_result() the returned pointer. */
static CBMFileResult *rx(const char *src, const char *proj, const char *path) {
    return cbm_extract_file(src, (int)strlen(src), CBM_LANG_RUST, proj, path, 0, NULL, NULL);
}

/* Count how many defs in r have exactly this label AND name. */
static int count_defs_named(CBMFileResult *r, const char *label, const char *name) {
    int n = 0;
    for (int i = 0; i < r->defs.count; i++) {
        CBMDefinition *d = &r->defs.items[i];
        if (label && (!d->label || strcmp(d->label, label) != 0))
            continue;
        if (name && (!d->name || strcmp(d->name, name) != 0))
            continue;
        n++;
    }
    return n;
}

/* Return the Nth (0-based) def matching label + name, or NULL. */
static CBMDefinition *nth_def_named(CBMFileResult *r, const char *label, const char *name, int nth) {
    int seen = 0;
    for (int i = 0; i < r->defs.count; i++) {
        CBMDefinition *d = &r->defs.items[i];
        if (label && (!d->label || strcmp(d->label, label) != 0))
            continue;
        if (name && (!d->name || strcmp(d->name, name) != 0))
            continue;
        if (seen == nth)
            return d;
        seen++;
    }
    return NULL;
}

/* ── Test ─────────────────────────────────────────────────────────── */

/*
 * Rust source with two mutually-exclusive cfg-gated definitions of the
 * same function.  Tree-sitter sees both function_item nodes regardless
 * of which cfg is active (it does not preprocess).  The correct fix must
 * emit two DISTINCT graph nodes — one per branch — so that
 * get_code_snippet can return the right body for the right build.
 *
 * The "real" branch (feature = "rag-pdf") has:
 *   - parameter name "bytes"  (no underscore)
 *   - a non-trivial body (returns Some(String::new()))
 *   - starts at line 2
 *
 * The "stub" branch (not(feature = "rag-pdf")) has:
 *   - parameter name "_bytes" (underscore = unused)
 *   - a trivial body (returns None)
 *   - starts at line 7
 */
TEST(repro_issue495_cfg_gated_twins_distinct) {
    static const char *src =
        "#[cfg(feature = \"rag-pdf\")]\n"
        "fn try_extract_pdf_text(bytes: &[u8]) -> Option<String> {\n"
        "    if bytes.is_empty() { return None; }\n"
        "    Some(String::new())\n"
        "}\n"
        "\n"
        "#[cfg(not(feature = \"rag-pdf\"))]\n"
        "fn try_extract_pdf_text(_bytes: &[u8]) -> Option<String> { None }\n";

    CBMFileResult *r = rx(src, "t", "src.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* ── Part 1: both defs must be present in the extraction output ── */

    int twin_count = count_defs_named(r, "Function", "try_extract_pdf_text");

    /* Both function_item nodes are in the tree-sitter parse; both must
     * be emitted.  This should already pass on current code (extraction
     * visits both nodes) and acts as a precondition for Parts 2 & 3. */
    ASSERT_GTE(twin_count, 2);

    /* ── Part 2 (PRIMARY RED): distinct qualified_names per twin ───── */

    /* Retrieve the two defs.  On buggy code both have the same QN, so
     * even picking them by index 0 and 1 is meaningful: the pair MUST
     * carry two DIFFERENT qualified_name strings. */
    CBMDefinition *d0 = nth_def_named(r, "Function", "try_extract_pdf_text", 0);
    CBMDefinition *d1 = nth_def_named(r, "Function", "try_extract_pdf_text", 1);
    ASSERT_NOT_NULL(d0);
    ASSERT_NOT_NULL(d1);
    ASSERT_NOT_NULL(d0->qualified_name);
    ASSERT_NOT_NULL(d1->qualified_name);

    /* ROOT CAUSE ASSERTION: the two cfg-gated twins must have DISTINCT
     * qualified_names so the graph upsert can store them as separate
     * nodes.  On current (buggy) code both equal "t.src.try_extract_pdf_text"
     * and this assertion FAILS → RED. */
    ASSERT_STR_NEQ(d0->qualified_name, d1->qualified_name);

    /* ── Part 3 (SECONDARY RED): each def carries its own cfg predicate */

    /* The decorator text for each function_item is already captured by
     * extract_decorators() into def.decorators[0].  The fix can use this
     * captured text to build the disambiguating QN suffix.  We verify
     * that the right predicate lives on the right def:
     *
     *   - the def whose signature contains "bytes" (no underscore, real
     *     body) must have a decorator containing "feature" but NOT "not("
     *   - the def whose signature contains "_bytes" (stub) must have a
     *     decorator containing "not("
     *
     * On buggy code: d0 and d1 have identical QN so we cannot distinguish
     * which is the real and which is the stub — the pair-identity check
     * in Part 2 already failed.  Parts 2 and 3 together pin the root
     * cause at extract_func_def() failing to fold the cfg predicate into
     * the qualified_name. */
    CBMDefinition *real_def = NULL;  /* #[cfg(feature = "rag-pdf")]     */
    CBMDefinition *stub_def = NULL;  /* #[cfg(not(feature = "rag-pdf"))] */

    for (int i = 0; i < r->defs.count; i++) {
        CBMDefinition *d = &r->defs.items[i];
        if (!d->name || strcmp(d->name, "try_extract_pdf_text") != 0)
            continue;
        if (!d->qualified_name)
            continue;
        /* Identify by the cfg predicate baked into the (fixed) QN.
         * On unpatched code both QNs are identical so neither branch
         * is reachable via a unique QN → real_def / stub_def stay NULL
         * → the ASSERT_NOT_NULLs below fire as a second RED signal. */
        if (strstr(d->qualified_name, "not(") != NULL) {
            stub_def = d;
        } else {
            real_def = d;
        }
    }

    /* On fixed code: two distinct QNs → both pointers set. */
    ASSERT_NOT_NULL(real_def);   /* RED on current code */
    ASSERT_NOT_NULL(stub_def);   /* RED on current code */

    /* Decorator text must survive and identify each branch. */
    ASSERT_NOT_NULL(real_def->decorators);
    ASSERT_NOT_NULL(real_def->decorators[0]);
    ASSERT_TRUE(strstr(real_def->decorators[0], "cfg") != NULL);
    ASSERT_TRUE(strstr(real_def->decorators[0], "not(") == NULL);

    ASSERT_NOT_NULL(stub_def->decorators);
    ASSERT_NOT_NULL(stub_def->decorators[0]);
    ASSERT_TRUE(strstr(stub_def->decorators[0], "not(") != NULL);

    /* Line ranges must not overlap (both trees are in-source). */
    ASSERT_TRUE(real_def->start_line != stub_def->start_line);
    ASSERT_TRUE(real_def->end_line   < stub_def->start_line ||
                stub_def->end_line   < real_def->start_line);

    cbm_free_result(r);
    PASS();
}

/* ── Suite ────────────────────────────────────────────────────────── */
SUITE(repro_issue495) {
    RUN_TEST(repro_issue495_cfg_gated_twins_distinct);
}