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",
    "routeState.js"
);

const toPlain = (value) => JSON.parse(JSON.stringify(value));

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

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

module.exports = {
    normalizeRouteStateQuery,
    resolveSearchResultsHref,
    resolveSearchBreadcrumbLabel,
    isDnsRoutePath,
    resolveCaseBreadcrumbState
};
`;

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

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

    return sandbox.module.exports;
};

test("normalizeRouteStateQuery maps known boolean query flags", () => {
    const { normalizeRouteStateQuery } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            normalizeRouteStateQuery({
                va: "true",
                adv: "false",
                ads: "true",
                key: "myCases"
            })
        ),
        {
            viewAll: true,
            advanced: false,
            address: true,
            key: "myCases"
        }
    );
});

test("resolveSearchResultsHref falls back to myportal when no flags and no search query exist for signed-in user", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: {},
                hasSession: true,
                fallbackToMyPortalWhenNoFlags: true
            })
        ),
        {
            pathname: "/myportal"
        }
    );
});

test("resolveSearchResultsHref preserves public searchresults route when search query exists and no flags are set", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { q: "abc" },
                hasSession: false,
                fallbackToMyPortalWhenNoFlags: true
            })
        ),
        {
            pathname: "/searchresults",
            query: { q: "abc" }
        }
    );
});

test("resolveSearchResultsHref preserves myportal searchresults route when search query exists and no flags are set for signed-in user", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { q: "abc" },
                hasSession: true,
                fallbackToMyPortalWhenNoFlags: true
            })
        ),
        {
            pathname: "/myportal/searchresults",
            query: { q: "abc" }
        }
    );
});

test("resolveSearchResultsHref routes view-all requests to myportal viewall with key only", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: {
                    va: "true",
                    key: "mySubmittedReps",
                    q: "ignored"
                },
                hasSession: true,
                includeViewAll: true
            })
        ),
        {
            pathname: "/myportal/viewall",
            query: { key: "mySubmittedReps" }
        }
    );
});

test("resolveSearchResultsHref routes advanced requests to advancedsearchresults and preserves query", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { q: "abc", adv: "true", page: "2" },
                hasSession: false
            })
        ),
        {
            pathname: "/advancedsearchresults",
            query: { q: "abc", adv: "true", page: "2" }
        }
    );
});

test("resolveSearchResultsHref routes address requests to addresssearchresults and preserves query", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { postcode: "CF10", ads: "true" },
                hasSession: true
            })
        ),
        {
            pathname: "/myportal/addresssearchresults",
            query: { postcode: "CF10", ads: "true" }
        }
    );
});

test("resolveSearchResultsHref routes dns requests to dnsapplications", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { anything: "x" },
                hasSession: true,
                isDnsRoute: true
            })
        ),
        {
            pathname: "/myportal/dnsapplications"
        }
    );

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { anything: "x" },
                hasSession: false,
                isDnsRoute: true
            })
        ),
        {
            pathname: "/dnsapplications"
        }
    );
});

test("resolveSearchResultsHref defaults to searchresults and preserves query when no special route applies", () => {
    const { resolveSearchResultsHref } = loadHelpers();

    assert.deepStrictEqual(
        toPlain(
            resolveSearchResultsHref({
                query: { q: "abc", page: "3" },
                hasSession: false
            })
        ),
        {
            pathname: "/searchresults",
            query: { q: "abc", page: "3" }
        }
    );
});

test("resolveSearchBreadcrumbLabel prioritizes view-all label, then keyed label, then advanced/address/default", () => {
    const { resolveSearchBreadcrumbLabel } = loadHelpers();

    const getViewAllLabel = (key) => {
        const labels = {
            myCases: "My cases",
            watchedCases: "Watched cases"
        };
        return labels[key] || null;
    };

    assert.strictEqual(
        resolveSearchBreadcrumbLabel({
            query: { va: "true", key: "myCases" },
            getViewAllLabel,
            advancedLabel: "Advanced search results",
            addressLabel: "Address search results",
            defaultLabel: "Search results"
        }),
        "My cases"
    );

    assert.strictEqual(
        resolveSearchBreadcrumbLabel({
            query: { key: "watchedCases" },
            getViewAllLabel,
            advancedLabel: "Advanced search results",
            addressLabel: "Address search results",
            defaultLabel: "Search results"
        }),
        "Watched cases"
    );

    assert.strictEqual(
        resolveSearchBreadcrumbLabel({
            query: { adv: "true" },
            getViewAllLabel,
            advancedLabel: "Advanced search results",
            addressLabel: "Address search results",
            defaultLabel: "Search results"
        }),
        "Advanced search results"
    );

    assert.strictEqual(
        resolveSearchBreadcrumbLabel({
            query: { ads: "true" },
            getViewAllLabel,
            advancedLabel: "Advanced search results",
            addressLabel: "Address search results",
            defaultLabel: "Search results"
        }),
        "Address search results"
    );

    assert.strictEqual(
        resolveSearchBreadcrumbLabel({
            query: {},
            getViewAllLabel,
            advancedLabel: "Advanced search results",
            addressLabel: "Address search results",
            defaultLabel: "Search results"
        }),
        "Search results"
    );
});

test("isDnsRoutePath correctly identifies dns route families", () => {
    const { isDnsRoutePath } = loadHelpers();

    assert.strictEqual(isDnsRoutePath("/dns"), true);
    assert.strictEqual(isDnsRoutePath("/dns/applications"), true);
    assert.strictEqual(isDnsRoutePath("/myportal/dns"), true);
    assert.strictEqual(isDnsRoutePath("/myportal/dns/example"), true);

    assert.strictEqual(isDnsRoutePath("/searchresults"), false);
    assert.strictEqual(isDnsRoutePath("/myportal"), false);
    assert.strictEqual(isDnsRoutePath("/myportal/case/[ticketnumber]"), false);
});

test("resolveCaseBreadcrumbState returns breadcrumb and case-results hrefs plus breadcrumb label", () => {
    const { resolveCaseBreadcrumbState } = loadHelpers();

    const getViewAllLabel = (key) =>
        key === "mySubmittedReps" ? "Submitted representations" : null;

    assert.deepStrictEqual(
        toPlain(
            resolveCaseBreadcrumbState({
                query: { q: "cas-", adv: "false" },
                hasSession: true,
                getViewAllLabel,
                advancedLabel: "Advanced search results",
                addressLabel: "Address search results",
                defaultLabel: "Search results"
            })
        ),
        {
            breadcrumbHref: {
                pathname: "/myportal/searchresults",
                query: { q: "cas-", adv: "false" }
            },
            caseResultsHref: {
                pathname: "/myportal/searchresults",
                query: { q: "cas-", adv: "false" }
            },
            breadcrumbLabel: "Search results"
        }
    );
});

test("resolveCaseBreadcrumbState distinguishes view-all breadcrumb from case-results href", () => {
    const { resolveCaseBreadcrumbState } = loadHelpers();

    const getViewAllLabel = (key) =>
        key === "mySubmittedReps" ? "Submitted representations" : null;

    assert.deepStrictEqual(
        toPlain(
            resolveCaseBreadcrumbState({
                query: { va: "true", key: "mySubmittedReps" },
                hasSession: true,
                getViewAllLabel,
                advancedLabel: "Advanced search results",
                addressLabel: "Address search results",
                defaultLabel: "Search results"
            })
        ),
        {
            breadcrumbHref: {
                pathname: "/myportal/viewall",
                query: { key: "mySubmittedReps" }
            },
            caseResultsHref: {
                pathname: "/myportal/searchresults",
                query: { va: "true", key: "mySubmittedReps" }
            },
            breadcrumbLabel: "Submitted representations"
        }
    );
});

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

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

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

module.exports = run;

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