/**
 * F001: with join optimization on, a filter on a foreign collection field reads
 * path arrayness for the base collection's namespace. The base collection's
 * non-multikey index on "x" marks "x" non-array, so the foreign scan skips
 * array traversal and drops foreign docs whose "x" is an array.
 *
 * @tags: [
 *   requires_fcv_90,
 *   requires_sbe
 * ]
 */

const conn = MongoRunner.runMongod({
    setParameter: {
        featureFlagPathArrayness: true,
        // Toggled knobs do not clear cached plans; keep every run a fresh plan.
        internalQueryDisablePlanCache: true,
    },
});
const db = conn.getDB(jsTestName());

const base = db.base;
const foreign = db.foreign;
assert.commandWorked(base.insertMany([
    {_id: 1, k: 1, x: 5},
    {_id: 2, k: 2, x: 6},
]));
assert.commandWorked(foreign.insertMany([
    {_id: 10, k: 1, x: [1, 2]},
    {_id: 11, k: 1, x: 3},
    {_id: 12, k: 2, x: [2]},
]));
// The base index on "x" is what marks "x" as non-array; without it the bug is gone.
assert.commandWorked(base.createIndex({x: 1}));
assert.commandWorked(base.createIndex({k: 1}));
assert.commandWorked(foreign.createIndex({k: 1}));

const pipeline = [
    {$lookup: {from: foreign.getName(), localField: "k", foreignField: "k", as: "f"}},
    {$unwind: "$f"},
    {$match: {"f.x": 2}},
];
const expected = [
    {_id: 1, k: 1, x: 5, f: {_id: 10, k: 1, x: [1, 2]}},
    {_id: 2, k: 2, x: 6, f: {_id: 12, k: 2, x: [2]}},
];

function run(label, joinOpt) {
    // The join optimizer needs path arrayness to prove join keys are not arrays,
    // so internalEnablePathArrayness stays on; turning it off disables joins too.
    assert.commandWorked(db.adminCommand({
        setParameter: 1,
        internalEnableJoinOptimization: joinOpt,
        internalEnablePathArrayness: true,
    }));
    const results = base.aggregate(pipeline).toArray();
    const explain = tojson(base.explain().aggregate(pipeline));
    const usedJoinOpt = /JOIN_EMBEDDING/.test(explain);
    jsTest.log.info("F001 run", {label, joinOpt, usedJoinOpt, n: results.length, results});
    return {results, usedJoinOpt};
}

const joinOff = run("join off", false);
const joinOnWithBaseXIndex = run("join on, base x index", true);
assert.commandWorked(base.dropIndex({x: 1}));
const joinOnNoBaseXIndex = run("join on, no base x index", true);

// The join-on runs must really use the join optimizer, or the comparison proves nothing.
assert(!joinOff.usedJoinOpt, "join optimization should be off");
assert(joinOnWithBaseXIndex.usedJoinOpt, "join optimization did not fire");
assert(joinOnNoBaseXIndex.usedJoinOpt, "join optimization did not fire");

assert.sameMembers(joinOff.results, expected, "join off");
// Same join plan, but no arrayness metadata for "x" on the base collection.
assert.sameMembers(joinOnNoBaseXIndex.results, expected, "join on, no base x index");
// Fails at d4834185d93: returns [] because traverseF is elided for foreign "x".
assert.sameMembers(joinOnWithBaseXIndex.results, expected, "join on, base x index");

MongoRunner.stopMongod(conn);