const assert = require("assert");
const fs = require("fs");
const path = require("path");
const vm = require("vm");

const tests = [];
const test = (name, fn) => tests.push({ name, fn });

const helperModulePath = path.join(
    __dirname,
    "..",
    "..",
    "lib",
    "routing",
    "breadcrumbRouteMaps.js"
);

const loadHelpers = () => {
    const source = fs.readFileSync(helperModulePath, "utf8");

    const transformedSource = `
${source
    .replace(/export const /g, "const ")
    .replace(/export function /g, "function ")}

module.exports = {
    buildBreadcrumbRendererMaps,
    resolveMappedRouteRenderer
};
`;

    const sandbox = {
        module: { exports: {} },
        exports: {},
        require,
        __dirname: path.dirname(helperModulePath),
        __filename: helperModulePath,
        console
    };

    vm.runInNewContext(transformedSource, sandbox, {
        filename: helperModulePath
    });

    return sandbox.module.exports;
};

test("buildBreadcrumbRendererMaps returns grouped maps in explicit precedence order", () => {
    const { buildBreadcrumbRendererMaps } = loadHelpers();

    const simpleRouteRenderersByPath = {
        "/alpha": () => "alpha"
    };
    const simpleLinkTextPairRenderersByPath = {
        "/beta": () => "beta"
    };
    const simpleMyPortalRouteRenderersByPath = {
        "/gamma": () => "gamma"
    };
    const newAppealRouteRenderersByPath = {
        "/eta": () => "eta"
    };
    const callbackRouteRenderersByPath = {
        "/theta": () => "theta"
    };
    const stepBackRouteRenderersByPath = {
        "/iota": () => "iota"
    };
    const representationRouteRenderersByPath = {
        "/kappa": () => "kappa"
    };
    const caseDetailRouteRenderersByPath = {
        "/delta": () => "delta"
    };
    const detailAndAccountRouteRenderersByPath = {
        "/epsilon": () => "epsilon"
    };

    const result = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath,
        simpleLinkTextPairRenderersByPath,
        simpleMyPortalRouteRenderersByPath,
        newAppealRouteRenderersByPath,
        callbackRouteRenderersByPath,
        stepBackRouteRenderersByPath,
        representationRouteRenderersByPath,
        caseDetailRouteRenderersByPath,
        detailAndAccountRouteRenderersByPath
    });

    assert.ok(Array.isArray(result), "Expected grouped maps array");
    assert.strictEqual(result.length, 9, "Expected nine grouped route maps");
    assert.strictEqual(
        result[0],
        simpleRouteRenderersByPath,
        "Expected simple route renderers first"
    );
    assert.strictEqual(
        result[1],
        simpleLinkTextPairRenderersByPath,
        "Expected simple link-text pair renderers second"
    );
    assert.strictEqual(
        result[2],
        simpleMyPortalRouteRenderersByPath,
        "Expected my-portal route renderers third"
    );
    assert.strictEqual(
        result[3],
        newAppealRouteRenderersByPath,
        "Expected new-appeal route renderers fourth"
    );
    assert.strictEqual(
        result[4],
        callbackRouteRenderersByPath,
        "Expected callback route renderers fifth"
    );
    assert.strictEqual(
        result[5],
        stepBackRouteRenderersByPath,
        "Expected step-back route renderers sixth"
    );
    assert.strictEqual(
        result[6],
        representationRouteRenderersByPath,
        "Expected representation route renderers seventh"
    );
    assert.strictEqual(
        result[7],
        caseDetailRouteRenderersByPath,
        "Expected case detail route renderers eighth"
    );
    assert.strictEqual(
        result[8],
        detailAndAccountRouteRenderersByPath,
        "Expected detail and account route renderers ninth"
    );
});

test("resolveMappedRouteRenderer returns renderer from first matching grouped map", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const firstRenderer = () => "first";
    const secondRenderer = () => "second";

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {
            "/known": firstRenderer
        },
        simpleLinkTextPairRenderersByPath: {
            "/known": secondRenderer
        },
        simpleMyPortalRouteRenderersByPath: {},
        newAppealRouteRenderersByPath: {},
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: {},
        caseDetailRouteRenderersByPath: {},
        detailAndAccountRouteRenderersByPath: {}
    });

    const result = resolveMappedRouteRenderer("/known", maps);

    assert.strictEqual(
        result,
        firstRenderer,
        "Expected resolver to use first matching map by precedence order"
    );
});

test("resolveMappedRouteRenderer returns renderer from later grouped map when earlier maps do not match", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const detailRenderer = () => "detail";

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {},
        simpleLinkTextPairRenderersByPath: {},
        newAppealRouteRenderersByPath: {
            "/newappeal/selectappeal": () => "newappeal"
        },
        simpleMyPortalRouteRenderersByPath: {},
        caseDetailRouteRenderersByPath: {},
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: {},
        detailAndAccountRouteRenderersByPath: {
            "/account/personaldetails": detailRenderer
        }
    });

    const result = resolveMappedRouteRenderer("/account/personaldetails", maps);

    assert.strictEqual(
        result,
        detailRenderer,
        "Expected resolver to return matching renderer from later grouped map"
    );
});

test("resolveMappedRouteRenderer returns null for unmapped path", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {
            "/known": () => "known"
        },
        simpleLinkTextPairRenderersByPath: {},
        simpleMyPortalRouteRenderersByPath: {},
        newAppealRouteRenderersByPath: {},
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: {},
        caseDetailRouteRenderersByPath: {},
        detailAndAccountRouteRenderersByPath: {}
    });

    const result = resolveMappedRouteRenderer("/unknown", maps);

    assert.strictEqual(
        result,
        null,
        "Expected null when no grouped map contains the path"
    );
});

test("resolveMappedRouteRenderer returns null for empty, whitespace, and non-exact path variants", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const knownRenderer = () => "known";

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {
            "/known": knownRenderer
        },
        simpleLinkTextPairRenderersByPath: {},
        simpleMyPortalRouteRenderersByPath: {},
        newAppealRouteRenderersByPath: {},
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: {},
        caseDetailRouteRenderersByPath: {},
        detailAndAccountRouteRenderersByPath: {}
    });

    assert.strictEqual(
        resolveMappedRouteRenderer("", maps),
        null,
        "Expected null for empty path lookup when no empty key is mapped"
    );

    assert.strictEqual(
        resolveMappedRouteRenderer("   ", maps),
        null,
        "Expected null for whitespace-only path lookup"
    );

    assert.strictEqual(
        resolveMappedRouteRenderer("/known ", maps),
        null,
        "Expected null for non-exact path variant with trailing whitespace"
    );

    assert.strictEqual(
        resolveMappedRouteRenderer(" /known", maps),
        null,
        "Expected null for non-exact path variant with leading whitespace"
    );

    assert.strictEqual(
        resolveMappedRouteRenderer("/KNOWN", maps),
        null,
        "Expected null for non-exact case-variant path lookup"
    );
});

test("resolveMappedRouteRenderer skips invalid map entries and non-function renderer values", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const validRenderer = () => "valid";

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {
            "/known": "not-a-function"
        },
        simpleLinkTextPairRenderersByPath: null,
        simpleMyPortalRouteRenderersByPath: {
            "/known": validRenderer
        },
        newAppealRouteRenderersByPath: undefined,
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: {},
        caseDetailRouteRenderersByPath: {},
        detailAndAccountRouteRenderersByPath: {}
    });

    const result = resolveMappedRouteRenderer("/known", maps);

    assert.strictEqual(
        result,
        validRenderer,
        "Expected resolver to skip invalid/non-function entries and return first valid renderer"
    );
});

test("resolveMappedRouteRenderer tolerates missing representation map entry in grouped map input", () => {
    const { buildBreadcrumbRendererMaps, resolveMappedRouteRenderer } =
        loadHelpers();

    const caseDetailRenderer = () => "case-detail";

    const maps = buildBreadcrumbRendererMaps({
        simpleRouteRenderersByPath: {},
        simpleLinkTextPairRenderersByPath: {},
        simpleMyPortalRouteRenderersByPath: {},
        newAppealRouteRenderersByPath: {},
        callbackRouteRenderersByPath: {},
        stepBackRouteRenderersByPath: {},
        representationRouteRenderersByPath: undefined,
        caseDetailRouteRenderersByPath: {
            "/case/[ticketnumber]": caseDetailRenderer
        },
        detailAndAccountRouteRenderersByPath: {}
    });

    assert.strictEqual(
        resolveMappedRouteRenderer("/myportal/representation", maps),
        null,
        "Expected null when representation renderer map is missing"
    );

    assert.strictEqual(
        resolveMappedRouteRenderer("/case/[ticketnumber]", maps),
        caseDetailRenderer,
        "Expected later grouped map resolution to remain intact when representation map is missing"
    );
});

const run = async () => {
    let passed = 0;

    for (const currentTest of tests) {
        await currentTest.fn();
        passed += 1;
    }

    console.log(
        `Phase 22 breadcrumb-route-maps-helper tests passed (${passed}/${tests.length}).`
    );
};

module.exports = run;

if (require.main === module) {
    run().catch((error) => {
        console.error(error);
        process.exit(1);
    });
}