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

const rootDir = path.resolve(__dirname, "..", "..");

const loadMapAppealTypeModule = () => {
    const filePath = path.join(
        rootDir,
        "lib",
        "domain",
        "case-lifecycle",
        "mapAppealType.js"
    );

    let source = fs.readFileSync(filePath, "utf8");
    source = source.replace(/export const\s+/g, "const ");
    source = source.replace(
        /export function\s+mapAppealType/,
        "function mapAppealType"
    );
    source += `
module.exports = {
  caseTypeAliases,
  caseTypeKeyByAppealTypeId,
  normaliseCaseType,
  mapAppealType
};
`;

    const context = {
        module: { exports: {} },
        exports: {},
        require
    };

    vm.runInNewContext(source, context, { filename: filePath });
    return context.module.exports;
};

const loadAppealTypeFamilyModule = () => {
    const filePath = path.join(
        rootDir,
        "lib",
        "domain",
        "appeal-type-policy",
        "getAppealTypeFamily.js"
    );

    let source = fs.readFileSync(filePath, "utf8");
    source = source.replace(
        /import\s+\{\s*mapAppealType\s*\}\s+from\s+"\.\.\/case-lifecycle\/mapAppealType";?/,
        'const { mapAppealType } = require("../case-lifecycle/mapAppealType");'
    );
    source = source.replace(
        /export function\s+getAppealTypeFamily/,
        "function getAppealTypeFamily"
    );
    source += `
module.exports = { getAppealTypeFamily };
`;

    const context = {
        module: { exports: {} },
        exports: {},
        require: (modulePath) => {
            if (modulePath === "../case-lifecycle/mapAppealType") {
                return loadMapAppealTypeModule();
            }
            return require(modulePath);
        }
    };

    vm.runInNewContext(source, context, { filename: filePath });
    return context.module.exports;
};

const loadEsModuleFunctions = (
    relativePath,
    exportNames,
    contextExtras = {}
) => {
    const filePath = path.join(rootDir, ...relativePath.split("/"));
    let source = fs.readFileSync(filePath, "utf8");

    for (const exportName of exportNames) {
        source = source.replace(
            new RegExp(`export function\\s+${exportName}`, "g"),
            `function ${exportName}`
        );
        source = source.replace(
            new RegExp(`export const\\s+${exportName}\\s*=`, "g"),
            `const ${exportName} =`
        );
    }

    source = source.replace(
        /import\s+\{\s*isRepresentationWindowOpen\s*\}\s+from\s+"\.\/resolveRepresentationWindow";/,
        'const { isRepresentationWindowOpen } = require("./resolveRepresentationWindow");'
    );
    source = source.replace(
        /import\s+\{\s*getAppealTypeFamily\s*\}\s+from\s+"\.\.\/appeal-type-policy";?/,
        'const { getAppealTypeFamily } = require("../appeal-type-policy");'
    );

    source += `\nmodule.exports = { ${exportNames.join(", ")} };\n`;

    const context = {
        module: { exports: {} },
        exports: {},
        require: (modulePath) => {
            if (modulePath === "../appeal-type-policy") {
                return loadAppealTypeFamilyModule();
            }
            return require(modulePath);
        },
        Date,
        Number,
        Set,
        ...contextExtras
    };

    vm.runInNewContext(source, context, { filename: filePath });
    return context.module.exports;
};

const gatingHelpers = loadEsModuleFunctions(
    "lib/domain/representation-policy/canShowRepresentationButtonForAppealType.js",
    ["canShowRepresentationButtonForAppealType"]
);

const householderHelpers = loadEsModuleFunctions(
    "lib/domain/representation-policy/canStartHouseholderRepresentation.js",
    ["canStartHouseholderRepresentation"]
);

const windowHelpers = loadEsModuleFunctions(
    "lib/domain/representation-policy/resolveRepresentationWindow.js",
    [
        "isRepresentationWindowOpen",
        "isRepresentationWindowClosed",
        "resolveRepresentationWindow"
    ]
);

const cpoHelpers = loadEsModuleFunctions(
    "lib/domain/representation-policy/canStartCpoRepresentation.js",
    ["canStartCpoRepresentation"],
    {
        require: (modulePath) => {
            if (modulePath === "./resolveRepresentationWindow") {
                return windowHelpers;
            }
            return require(modulePath);
        }
    }
);

const { normalizeSpecialistProcess } = loadEsModuleFunctions(
    "lib/domain/case-lifecycle/normalizeSpecialistProcess.js",
    ["normalizeSpecialistProcess"]
);

const evaluateSummaryAdvertRule = ({ appealType, detailsObj, isLPA }) => {
    if (!gatingHelpers.canShowRepresentationButtonForAppealType(appealType)) {
        return false;
    }

    switch (appealType) {
        case 846040004:
            return householderHelpers.canStartHouseholderRepresentation(
                appealType,
                isLPA
            );

        case 846040015:
            return detailsObj.pinswg_specialistcaseprocess == 846040001
                ? windowHelpers.isRepresentationWindowOpen(
                      detailsObj.pinswg_startdate,
                      detailsObj.pinswg_finalcommentsduedate
                  )
                : true;

        case 846040018:
            return detailsObj.pinswg_speacialistcaseprocess == 846040000 &&
                isLPA
                ? true
                : detailsObj.pinswg_speacialistcaseprocess == 846040001
                  ? true
                  : false;

        case 846040019:
            return cpoHelpers.canStartCpoRepresentation(appealType, detailsObj);

        default:
            return true;
    }
};

const evaluateSearchAdvertRule = ({ appealType, detailsObj, isLPA }) => {
    const specialistProcess = normalizeSpecialistProcess(detailsObj);

    if (!gatingHelpers.canShowRepresentationButtonForAppealType(appealType)) {
        return false;
    }

    switch (appealType) {
        case 846040004:
            return householderHelpers.canStartHouseholderRepresentation(
                appealType,
                isLPA
            );

        case 846040015:
            return specialistProcess == 846040001
                ? windowHelpers.isRepresentationWindowOpen(
                      detailsObj.pinswg_startdate,
                      detailsObj.pinswg_finalcommentsduedate
                  )
                : true;

        case 846040018:
            return specialistProcess == 846040000 && isLPA
                ? true
                : specialistProcess == 846040001
                  ? true
                  : false;

        case 846040019:
            return cpoHelpers.canStartCpoRepresentation(appealType, detailsObj);

        default:
            return true;
    }
};

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

test("Advert written reps is allowed for LPA and blocked for non-LPA in both consumers when misspelled field is used", () => {
    const detailsObj = { pinswg_speacialistcaseprocess: 846040000 };

    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: true
        }),
        true
    );
    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: false
        }),
        false
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: true
        }),
        true
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: false
        }),
        false
    );
});

test("Advert hearing is allowed for both LPA and non-LPA in both consumers when supported field is present", () => {
    const summaryDetails = { pinswg_speacialistcaseprocess: 846040001 };
    const searchDetails = { pinswg_specialistcaseprocess: 846040001 };

    for (const isLPA of [true, false]) {
        assert.strictEqual(
            evaluateSummaryAdvertRule({
                appealType: 846040018,
                detailsObj: summaryDetails,
                isLPA
            }),
            true
        );
        assert.strictEqual(
            evaluateSearchAdvertRule({
                appealType: 846040018,
                detailsObj: searchDetails,
                isLPA
            }),
            true
        );
    }
});

test("Advert other specialist process values are blocked in both consumers when supported field is present", () => {
    for (const specialistValue of [846040002, 846040003]) {
        const summaryDetails = {
            pinswg_speacialistcaseprocess: specialistValue
        };
        const searchDetails = { pinswg_specialistcaseprocess: specialistValue };

        for (const isLPA of [true, false]) {
            assert.strictEqual(
                evaluateSummaryAdvertRule({
                    appealType: 846040018,
                    detailsObj: summaryDetails,
                    isLPA
                }),
                false
            );
            assert.strictEqual(
                evaluateSearchAdvertRule({
                    appealType: 846040018,
                    detailsObj: searchDetails,
                    isLPA
                }),
                false
            );
        }
    }
});

test("Advert summary consumer depends on misspelled specialist process field, while search consumer supports normalized fallback", () => {
    const canonicalOnly = { pinswg_specialistcaseprocess: 846040000 };
    const misspelledOnly = { pinswg_speacialistcaseprocess: 846040000 };

    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj: canonicalOnly,
            isLPA: true
        }),
        false,
        "summary consumer ignores canonical-only field for Advert branch"
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj: canonicalOnly,
            isLPA: true
        }),
        true,
        "search consumer uses canonical field via normalizeSpecialistProcess"
    );

    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj: misspelledOnly,
            isLPA: true
        }),
        true
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj: misspelledOnly,
            isLPA: true
        }),
        true
    );
});

test("Advert canonical specialist process takes precedence in search consumer when both fields exist", () => {
    const detailsObj = {
        pinswg_specialistcaseprocess: 846040002,
        pinswg_speacialistcaseprocess: 846040001
    };

    assert.strictEqual(normalizeSpecialistProcess(detailsObj), 846040002);
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: true
        }),
        false
    );
    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: true
        }),
        true,
        "summary consumer still reads the misspelled field directly"
    );
});

test("Advert entry does not currently depend on date windows in either consumer", () => {
    const detailsObj = {
        pinswg_speacialistcaseprocess: 846040001,
        pinswg_startdate: "2030-01-01T00:00:00.000Z",
        pinswg_finalcommentsduedate: "2030-01-02T00:00:00.000Z"
    };

    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: false
        }),
        true
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: 846040018,
            detailsObj,
            isLPA: false
        }),
        true
    );
});

test("Advert appeal type string form falls through to default allowed behaviour in both consumers", () => {
    const detailsObj = { pinswg_speacialistcaseprocess: 846040002 };

    assert.strictEqual(
        evaluateSummaryAdvertRule({
            appealType: "846040018",
            detailsObj,
            isLPA: false
        }),
        true
    );
    assert.strictEqual(
        evaluateSearchAdvertRule({
            appealType: "846040018",
            detailsObj,
            isLPA: false
        }),
        true
    );
});

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

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

    console.log(
        `Phase 22 representation-advert-entry-rule tests passed (${passed}/${tests.length}).`
    );
};

module.exports = run;

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