Peacock/components/controller.ts

/*
 *     The Peacock Project - a HITMAN server replacement.
 *     Copyright (C) 2021-2023 The Peacock Project Team
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU Affero General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU Affero General Public License for more details.
 *
 *     You should have received a copy of the GNU Affero General Public License
 *     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

import { existsSync, readdirSync, readFileSync } from "fs"
import { readdir, readFile, writeFile } from "fs/promises"
import * as atomically from "atomically"
import { join } from "path"
import * as dataGen from "./contracts/dataGen"
import {
    generateUserCentric,
    getSubLocationFromContract,
} from "./contracts/dataGen"
import type {
    Campaign,
    ClientToServerEvent,
    CompiledChallengeRuntimeData,
    ContractSession,
    GameVersion,
    GenSingleMissionFunc,
    GenSingleVideoFunc,
    IHit,
    MissionManifest,
    PeacockLocationsData,
    PlayNextGetCampaignsHookReturn,
    RegistryChallenge,
    RequestWithJwt,
    S2CEventWithTimestamp,
    SMFLastDeploy,
    Unlockable,
    UserCentricContract,
} from "./types/types"
import type * as configManagerType from "./configSwizzleManager"
import {
    configs,
    getConfig,
    getSwizzleable,
    getVersionedConfig,
    swizzle,
} from "./configSwizzleManager"
import * as logging from "./loggingInterop"
import { log, LogLevel } from "./loggingInterop"
import * as axios from "axios"
import * as ini from "js-ini"
import * as statemachineParser from "@peacockproject/statemachine-parser"
import * as utils from "./utils"
import {
    addDashesToPublicId,
    fastClone,
    getRemoteService,
    hitmapsUrl,
} from "./utils"
import * as sessionSerialization from "./sessionSerialization"
import * as databaseHandler from "./databaseHandler"
import * as playnext from "./menus/playnext"
import * as hooksImpl from "./hooksImpl"
import { AsyncSeriesHook, SyncBailHook, SyncHook } from "./hooksImpl"
import * as hitsCategoryServiceMod from "./contracts/hitsCategoryService"
import { MenuSystemDatabase, menuSystemDatabase } from "./menus/menuSystem"
import { escalationMappings } from "./contracts/escalationMappings"
import { parse } from "json5"
import { userAuths } from "./officialServerAuth"
// @ts-expect-error Ignore JSON import
import LASTYARDBIRDSCPC from "../contractdata/SNIPER/THELASTYARDBIRD_SCPC.json"
// @ts-expect-error Ignore JSON import
import LEGACYFF from "../contractdata/COLORADO/FREEDOMFIGHTERSLEGACY.json"
import { missionsInLocations } from "./contracts/missionsInLocation"
import { createContext, Script } from "vm"
import { ChallengeService } from "./candle/challengeService"
import { getFlag } from "./flags"
import { unpack } from "msgpackr"
import { ChallengePackage, SavedChallengeGroup } from "./types/challenges"
import { promisify } from "util"
import { brotliDecompress } from "zlib"
import assert from "assert"
import { Response } from "express"
import { MissionEndRequestQuery } from "./types/gameSchemas"
import { ChallengeFilterType } from "./candle/challengeHelpers"
import { MasteryService } from "./candle/masteryService"
import { MasteryPackage } from "./types/mastery"

/**
 * An array of string arrays that contains the IDs of the featured contracts.
 * Each of the string arrays is one page.
 */
export const featuredContractGroups: string[][] = [
    [
        "6275f476-b90a-4f79-abf3-bf30af020ad8",
        "ee0411d6-b3e7-4320-b56b-25c45d8a9d61",
        "a03285bd-7342-4262-b118-df485b5e99a9",
        "35547610-b036-4025-84f8-18a5db125ea4",
        "2c9b146a-cad6-48e0-a0d2-55eb7e58dbf7",
        "2b61a384-b3f7-42cb-b850-4cac06e2eef1",
        "ecb3e3b9-af4e-40e5-b7d7-9da54715a959",
        "89936bfe-673c-4b35-9404-72d809620f43",
        "1447a96c-73bd-4811-9c2e-5588885e36d7",
    ],
    [
        "ae25aaf1-53c4-4d4d-80b9-609ea09aa8a9",
        "9272bab9-3322-45c3-bb56-695f9923e27e",
        "cdc9e2ac-ae52-4ad8-bc85-929c886e4965",
        "19b1daaf-a472-4cee-9670-304cd62a3307",
        "57c854f1-92c2-4429-90cb-ebc27cd0f912",
        "9582fda8-d4c3-4464-955a-497365740ec2",
    ],
    [
        "7e1e00a0-5e12-4115-bcdb-ddbff1eaa9d1",
        "6ccce0de-7143-4099-af97-cf9838073f6b",
        "0db2289d-9035-4c77-a618-d196c4ca4f5c",
        "7a03a97d-238c-48bd-bda0-e5f279569ccf",
        "e1795c6a-5728-4bc5-bd71-248bc0071b44",
        "608830ec-01f2-4606-a904-8acd95f7e112",
        "4d049c4d-581f-4080-a600-8f1b38937256",
        "2d26476a-aad3-4a75-b2cd-afaf037876b7",
        "3b15b095-c278-4633-bb60-9939ce995a2c",
        "cee4716f-62a5-4290-a5d3-cf7764bf7b4b",
        "1d33dad8-2d70-4cc6-a1d1-e56c6a9c548c",
        "1ffb2af4-97c0-446a-add9-2565a358d862",
        "de89370c-105a-46f7-862f-64c330f28ee9",
        "1564ba59-58a8-4d20-b73d-63aca3254fa2",
        "f9c0cc2c-d779-4641-a011-a39734349058",
    ],
    [
        "5e546c0a-a407-4a17-a226-6cc4674fe987",
        "9b4636e3-2a6f-4bce-80e1-e3a5f79972b3",
        "fd3d8751-6298-4a11-9b29-e1bc01c8e08c",
        "d963e11c-7f49-49c9-a011-8d5d22c0216d",
        "8484edb5-65a2-4c12-9966-16eee599ee63",
    ],
    [
        "400562ab-e093-4d42-adb1-3e6fd5dfe99c",
        "8eed22a6-5bce-4dae-b9ac-5b539acf302e",
        "5b88babb-d565-4bee-95ec-4d434d49333f",
        "411b6f6a-a0ac-4ac8-9f9a-dd2c4c273180",
        "f4a096de-8783-4d97-862e-9db4d032150d",
        "0b37ea64-f9aa-464f-8cfc-252b58b52e41",
        "a6d3dc63-9d95-4030-ae90-5f7efce19473",
        "13d41ab3-4774-4caa-87d1-8d6d31df0423",
        "fb5cd917-0b3a-464b-8489-8e1f4cc824f9",
        "4d3a51a8-9cc0-4081-a53e-d1d21c8dbbe8",
    ],
    [
        "c99273cd-7c1f-4a1c-9b07-e3ceef5ec4cc",
        "ffd1a594-a3ce-4ee2-95bc-a976c3ee8b46",
        "857152eb-29ab-419b-946e-f6124a96b34d",
        "ee0485a3-fead-4a03-8f6a-06d98da31809",
        "028756e3-f911-4e30-bcda-2e3fa12cd427",
        "418be72d-89b7-480f-a1ab-3efa88e51cec",
    ],
    [
        "72d51ef4-3cbd-48ce-9c5a-6502e3313be6",
        "0244490f-df02-4923-85cb-bafbac351842",
        "48404607-6f03-4942-9068-7fab4e164dfe",
        "abc4866f-0837-4708-9ac5-0f5a7a6ca0f6",
        "bdd6b3dc-f8ae-44cd-8c80-44e018362553",
        "15cbf4c7-64ab-4dcb-b00d-afab433fe658",
        "9256f129-4407-4859-8b4d-690026e12b9c",
        "ab65c0b5-c7da-47aa-82a1-5033126ec18c",
        "982e023a-5b97-49af-a2e0-91c640dd874b",
    ],
    [
        "46729d34-489e-4cb1-89f8-30bb1d0df9d1",
        "b475edbd-50ba-46e5-8c73-78a094129bb6",
        "1ead714f-9bce-4736-b9cc-3dd5ce75c491",
    ],
    [
        "f0c1c9e9-f9e1-445b-9611-61546d2aea69",
        "94836810-aa7b-4472-9ed4-73806c2f303d",
        "1b2b32ae-798e-4ccc-b353-c3d1c8475faa",
        "8ba7ffda-7e62-4341-bca3-65b16f2ee6af",
        "55eb16e8-91a2-48f4-a6f6-141229d220d2",
        "f8e2aa93-15ca-4a88-b5b7-02f9a712b057",
        "1878154a-8e23-4fce-908e-cfe26fb67a29",
        "717aed54-8685-4901-b7bf-118b9780fa36",
        "ecbd78f6-bc65-4f19-934f-f2bb5adced6d",
        "001b058d-dea6-42c7-86de-c625a6f87c75",
    ],
]

const peacockRequireTable = {
    "@peacockproject/core/contracts/dataGen": { __esModule: true, ...dataGen },
    "@peacockproject/core/databaseHandler": {
        __esModule: true,
        ...databaseHandler,
    },
    "@peacockproject/core/utils": {
        __esModule: true,
        ...utils,
    },
    "@peacockproject/core/loggingInterop": { __esModule: true, ...logging },
    "@peacockproject/core/sessionSerialization": {
        __esModule: true,
        ...sessionSerialization,
    },
    "@peacockproject/statemachine-parser": statemachineParser,
    "@peacockproject/core/menus/playnext": {
        __esModule: true,
        ...playnext,
    },
    "@peacockproject/core/hooksImpl": {
        __esModule: true,
        ...hooksImpl,
    },
    "@peacockproject/core/contracts/hitsCategoryService": {
        __esModule: true,
        hitsCategoryService: hitsCategoryServiceMod,
    },
    "@peacockproject/core/menus/menuSystem": {
        __esModule: true,
        MenuSystemDatabase,
        menuSystemDatabase,
    },
    axios,
    ini,
    atomically,
}

/**
 * A binding of the virtual require function that displays the problematic plugin's name.
 *
 * @param pluginName The problematic plugin's name.
 */
function createPeacockRequire(pluginName: string): NodeRequire {
    /**
     * A virtual require function for plugins.
     *
     * @param specifier The requested module.
     */
    const peacockRequire: NodeRequire = (specifier: string) => {
        if (
            Object.prototype.hasOwnProperty.call(peacockRequireTable, specifier)
        ) {
            return peacockRequireTable[specifier]
        }

        try {
            return require(specifier)
        } catch (e) {
            log(LogLevel.ERROR, `PRMR: Unable to load ${specifier}.`)
            log(
                LogLevel.ERROR,
                `This is a problem with ${pluginName} - please let the author know.`,
            )
            throw e
        }
    }

    peacockRequire.resolve = require.resolve
    peacockRequire.cache = require.cache
    // Yes, we assert that the literal null keyword is not null here.
    // This is an awful idea in any scenario, except for this one, in which we
    // control module resolution, and don't need plugins to view/modify either
    // of these properties.
    // In short, it's either this, or ts-expect-error. -rdil, Jul 1 2022
    // noinspection JSDeprecatedSymbols
    peacockRequire.extensions = null!
    peacockRequire.main = null!

    return peacockRequire
}

/**
 * Freedom Fighters for Hitman 2016 (objectives are different).
 */
export const _legacyBull: MissionManifest = JSON.parse(LEGACYFF)

export const _theLastYardbirdScpc: MissionManifest =
    JSON.parse(LASTYARDBIRDSCPC)

export const peacockRecentEscalations: readonly string[] = [
    "35f1f534-ae2d-42be-8472-dd55e96625ea",
    "edbacf4b-e402-4548-b723-cd4351571537",
    "218302a3-f682-46f9-9ffd-bb3e82487b7c",
    "9a461f89-86c5-44e4-998e-f2f66b496aa7",
]

/**
 * Ensure a mission has the bare minimum required to work.
 *
 * @param m The mission manifest.
 * @returns If the mission is valid.
 */
export const validateMission = (m: MissionManifest): boolean => {
    if (!m.Metadata || !m.Data) {
        return false
    }

    for (const prop of ["Id", "Title", "Location", "ScenePath"]) {
        if (!Object.prototype.hasOwnProperty.call(m.Metadata, prop)) {
            log(LogLevel.ERROR, `Contract missing property Metadata.${prop}!`)
            return false
        }
    }

    for (const prop of ["Objectives", "Bricks"]) {
        if (!Object.prototype.hasOwnProperty.call(m.Data, prop)) {
            log(LogLevel.ERROR, `Contract missing property Data.${prop}!`)
            return false
        }

        if (!Array.isArray(m.Data[prop])) {
            log(
                LogLevel.ERROR,
                `Contract property Data.${prop} should be an array (found ${typeof prop})`,
            )
            return false
        }
    }

    return true
}

const modFrameworkDataPath: string | false =
    (process.env.LOCALAPPDATA &&
        join(
            process.env.LOCALAPPDATA,
            "Simple Mod Framework",
            "lastDeploy.json",
        )) ||
    false

export class Controller {
    public hooks: {
        serverStart: SyncHook<[]>
        challengesLoaded: SyncHook<[]>
        masteryDataLoaded: SyncHook<[]>
        newEvent: SyncHook<
            [
                /** event */ ClientToServerEvent,
                /** request */ RequestWithJwt,
                /** session */ ContractSession,
            ]
        >
        newMetricsEvent: SyncHook<
            [
                /** event */ S2CEventWithTimestamp,
                /** request */ RequestWithJwt<never, S2CEventWithTimestamp[]>,
            ]
        >
        getContractManifest: SyncBailHook<
            // prettier-ignore
            [
                /** contractId */ string
            ],
            MissionManifest | undefined
        >
        contributeCampaigns: SyncHook<
            [
                /** campaigns */ Campaign[],
                /** genSingleMissionFunc */ GenSingleMissionFunc,
                /** genSingleVideoFunc */ GenSingleVideoFunc,
                /** gameVersion */ GameVersion,
            ]
        >
        // prettier-ignore
        getSearchResults: AsyncSeriesHook<[
            /** query */ string[],
            /** contractIds */ string[]
        ]>
        getNextCampaignMission: SyncBailHook<
            // prettier-ignore
            [
                /** contractId */ string,
                /** gameVersion */ GameVersion
            ],
            PlayNextGetCampaignsHookReturn | undefined
        >
        getMissionEnd: SyncBailHook<
            [
                /** req */ RequestWithJwt<MissionEndRequestQuery>,
                /** res */ Response,
            ],
            boolean
        >
    }
    public escalationMappings = escalationMappings
    public configManager: typeof configManagerType = {
        getConfig,
        configs,
        getSwizzleable,
        getVersionedConfig,
        swizzle,
    }
    public missionsInLocations = missionsInLocations
    /**
     * Note: if you are adding a contract, please use {@link addMission}!
     */
    public contracts: Map<string, MissionManifest> = new Map()

    // Converts a contract's ID to public ID.
    public contractIdToPublicId: Map<string, string> = new Map()

    public challengeService: ChallengeService
    public masteryService: MasteryService
    /**
     * A list of Simple Mod Framework mods installed.
     */
    public readonly installedMods: readonly string[]
    private _pubIdToContractId: Map<string, string> = new Map()
    private _internalContracts: MissionManifest[]
    /** Internal elusive target contracts - only accessible during bootstrap. */
    private _internalElusives: MissionManifest[] | undefined

    /**
     * The constructor.
     */
    public constructor() {
        this.hooks = {
            serverStart: new SyncHook(),
            challengesLoaded: new SyncHook(),
            masteryDataLoaded: new SyncHook(),
            newEvent: new SyncHook(),
            newMetricsEvent: new SyncHook(),
            getContractManifest: new SyncBailHook(),
            contributeCampaigns: new SyncHook(),
            getSearchResults: new AsyncSeriesHook(),
            getNextCampaignMission: new SyncBailHook(),
            getMissionEnd: new SyncBailHook(),
        }

        if (modFrameworkDataPath && existsSync(modFrameworkDataPath)) {
            this.installedMods = (
                parse(
                    readFileSync(modFrameworkDataPath!).toString(),
                ) as SMFLastDeploy
            )?.loadOrder as readonly string[]
            return
        }

        this.installedMods = []
    }

    /**
     * You should use {@link modIsInstalled} instead!
     *
     * Returns whether a mod is UNAVAILABLE.
     *
     * @param modId The mod's ID.
     * @returns If the mod is unavailable. You should probably abort initialization if true is returned. Also returns true if the `overrideFrameworkChecks` flag is set.
     * @deprecated since v5.5.0
     */
    public addClientSideModDependency(modId: string): boolean {
        return (
            !this.installedMods.includes(modId) ||
            getFlag("overrideFrameworkChecks") === true
        )
    }

    /**
     * Returns whether a mod is available and installed.
     *
     * @param modId The mod's ID.
     * @returns If the mod is available (or the `overrideFrameworkChecks` flag is set). You should probably abort initialisation if false is returned.
     */
    public modIsInstalled(modId: string): boolean {
        return (
            this.installedMods.includes(modId) ||
            getFlag("overrideFrameworkChecks") === true
        )
    }

    /**
     * Starts the service and loads in all contracts.
     *
     * @throws {Error} If all hope is lost. (In theory, this should never happen)
     */
    async boot(pluginDevHost: boolean): Promise<void> {
        // this should never actually be hit, but it makes IntelliJ not
        // complain that it's unused, so...
        if (!this.configManager) {
            throw new Error("All hope is lost.")
        }

        log(
            LogLevel.INFO,
            "Booting Peacock internal services - this may take a moment.",
        )

        await this._loadInternalContracts()

        this.challengeService = new ChallengeService(this)
        this.masteryService = new MasteryService()

        this._addElusiveTargets()
        this.index()

        if (modFrameworkDataPath && existsSync(modFrameworkDataPath)) {
            log(
                LogLevel.INFO,
                "Simple Mod Framework installed - using the data it outputs.",
            )

            const lastServerSideData = (
                parse(
                    readFileSync(modFrameworkDataPath!).toString(),
                ) as SMFLastDeploy
            ).lastServerSideStates

            if (lastServerSideData?.unlockables) {
                this.configManager.configs["allunlockables"] =
                    lastServerSideData.unlockables.slice(1)
            }

            if (lastServerSideData?.contracts) {
                for (const [contractId, contractData] of Object.entries(
                    lastServerSideData.contracts,
                )) {
                    this.contracts.set(contractId, contractData)
                }
            }

            if (lastServerSideData?.blobs) {
                menuSystemDatabase.hooks.getConfig.tap(
                    "SMFBlobs",
                    (name, gameVersion) => {
                        if (
                            gameVersion === "h3" &&
                            (lastServerSideData.blobs[name] ||
                                lastServerSideData.blobs[name.slice(1)]) // leading slash is not included in SMF blobs
                        ) {
                            return parse(
                                readFileSync(
                                    join(
                                        process.env.LOCALAPPDATA,
                                        "Simple Mod Framework",
                                        "blobs",
                                        lastServerSideData.blobs[name] ||
                                            lastServerSideData.blobs[
                                                name.slice(1)
                                            ],
                                    ),
                                ).toString(),
                            )
                        }
                    },
                )
            }
        }

        await this._loadPlugins()

        if (pluginDevHost) {
            await this._loadWorkspacePlugins()
        }

        this.hooks.serverStart.call()

        try {
            await this._loadResources()

            this.hooks.challengesLoaded.call()
            this.hooks.masteryDataLoaded.call()
        } catch (e) {
            log(LogLevel.ERROR, `Fatal error with challenge bootstrap: ${e}`)
            log(LogLevel.ERROR, e.stack)
        }
    }

    /**
     * Gets a contract from the registry by its public ID,
     * or downloads it from the official servers if possible.
     *
     * @param pubId The contract's public ID.
     * @param currentUserId The current user's ID.
     * @param gameVersion The current game version.
     * @returns The mission manifest or null if it couldn't be resolved.
     */
    public async contractByPubId(
        pubId: string,
        currentUserId: string,
        gameVersion: GameVersion,
    ): Promise<MissionManifest | undefined> {
        if (!this._pubIdToContractId.has(pubId)) {
            return await this.downloadContract(
                currentUserId,
                pubId,
                gameVersion,
            )
        }

        if (this.contracts.has(this._pubIdToContractId.get(pubId)!)) {
            return (
                this.contracts.get(this._pubIdToContractId.get(pubId)!) ||
                undefined
            )
        }

        return undefined
    }

    /**
     * Saves a new contract to the contracts folder, and makes it resolve properly,
     * without triggering a hot module reload.
     *
     * @param manifest The contract's data (mission manifest, a.k.a. mission JSON).
     * @return The manifest that got passed, in case you want to use chaining.
     */
    public async commitNewContract(
        manifest: MissionManifest,
    ): Promise<MissionManifest> {
        const j = JSON.stringify(manifest, undefined, 4)

        log(
            LogLevel.INFO,
            `Saving generated contract ${manifest.Metadata.Id} to contracts/${manifest.Metadata.PublicId}.json`,
        )

        const name = `contracts/${manifest.Metadata.PublicId}.json`

        await writeFile(name, j)

        this.index()
        return manifest
    }

    /**
     * Get a contract by its ID.
     *
     * Order of precedence:
     * 1. Plugins ({@link addMission} or the `getMissionManifest` hook)
     * 2. Peacock internal contracts storage
     * 3. Files in the `contracts` folder.
     *
     * @param id The contract's ID.
     * @returns The mission manifest object, or undefined if it wasn't found.
     */
    public resolveContract(id: string): MissionManifest | undefined {
        if (!id) {
            return undefined
        }
        const optionalPluginJson = this.hooks.getContractManifest.call(id)

        if (optionalPluginJson) {
            return fastClone(optionalPluginJson)
        }

        const registryJson = this._internalContracts.find(
            (j) => j.Metadata.Id === id,
        )

        if (registryJson) {
            const dereferenced: MissionManifest = fastClone(registryJson)

            if (registryJson.Metadata.Type === "elusive") {
                dereferenced.Metadata.Type = "mission"
                return dereferenced
            }

            return dereferenced
        }

        const openCtJson = this.contracts.has(id)
            ? this.contracts.get(id)
            : undefined

        if (openCtJson) {
            return fastClone(openCtJson)
        }
        return undefined
    }

    /**
     * Adds the specified mission manifest as a mission.
     * It will be prioritized over all internal missions, escalations, and contracts.
     *
     * @param manifest The mission's manifest.
     */
    public addMission(manifest: MissionManifest): void {
        if (!validateMission(manifest)) {
            return
        }

        this.hooks.getContractManifest.tap(
            `RegisterContract: ${manifest.Metadata.Id}`,
            (id) => {
                if (id === manifest.Metadata.Id) {
                    return manifest
                }

                return undefined
            },
        )
    }

    /**
     * Adds an escalation to the game.
     *
     * @param groupId The escalation group ID. All levels must have the `Metadata.InGroup` value set to this!
     * @param locationId The location of the escalation's ID.
     * @param levels The escalation's levels.
     */
    public addEscalation(
        groupId: string,
        locationId: string,
        ...levels: MissionManifest[]
    ): void {
        const fixedLevels = [...levels].filter(Boolean)

        fixedLevels.forEach((level) => this.addMission(level))

        if (!this.missionsInLocations.escalations[locationId]) {
            this.missionsInLocations.escalations[locationId] = []
        }

        this.missionsInLocations.escalations[locationId].push(groupId)

        const escalationGroup = {}

        let i = 0

        while (i + 1 <= fixedLevels.length) {
            escalationGroup[i + 1] = fixedLevels[i].Metadata.Id
            i++
        }

        this.escalationMappings[groupId] = escalationGroup
    }

    /**
     * Downloads a contract from the IOI servers.
     *
     * @param userId The current user's ID.
     * @param pubId The public ID (numeric ID) of the contract.
     * @param gameVersion The game version (IOI's servers are version-dependent).
     */
    public async downloadContract(
        userId: string,
        pubId: string,
        gameVersion: GameVersion,
    ): Promise<MissionManifest | undefined> {
        log(
            LogLevel.DEBUG,
            `User ${userId} is downloading contract ${pubId}...`,
        )

        let contractData: MissionManifest | undefined = undefined

        if (
            gameVersion === "h3" &&
            getFlag("legacyContractDownloader") !== true
        ) {
            const result = await Controller._hitmapsFetchContract(pubId)

            if (result) {
                contractData = result
            } else {
                log(
                    LogLevel.WARN,
                    `Failed to download from HITMAP servers. Trying official servers instead...`,
                )
            }
        }

        if (!contractData) {
            contractData = await Controller._officialFetchContract(
                pubId,
                gameVersion,
                userId,
            )
        }

        if (!contractData) {
            log(LogLevel.ERROR, `No contract data for ${pubId}.`)
            return undefined
        }

        contractData.Metadata.CreatorUserId =
            "fadb923c-e6bb-4283-a537-eb4d1150262e"

        await writeFile(
            `contracts/${pubId}.json`,
            JSON.stringify(contractData, undefined, 4),
        )
        await this.commitNewContract(contractData)

        if (PEACOCK_DEV) {
            log(LogLevel.DEBUG, `Saved contract to contracts/${pubId}.json`)
        }

        return contractData
    }

    /**
     * Index all installed contract files (OCREs).
     *
     * @internal
     */
    index(): void {
        this.contracts.clear()
        this._pubIdToContractId.clear()

        const contracts = readdirSync("contracts")
        contracts.forEach((i) => {
            if (!isContractFile(i)) {
                return
            }

            try {
                const f = parse(
                    readFileSync(join("contracts", i)).toString(),
                ) as MissionManifest

                if (!validateMission(f)) {
                    log(LogLevel.ERROR, `Skipped loading ${i} due to an error!`)
                    return
                }

                this.contracts.set(f.Metadata.Id, f)
                if (f.Metadata.PublicId) {
                    this._pubIdToContractId.set(
                        f.Metadata.PublicId,
                        f.Metadata.Id,
                    )
                }
            } catch (e) {
                log(LogLevel.ERROR, `Failed to load contract ${i}!`)
                log(LogLevel.ERROR, e.stack)
            }
        })
    }

    /**
     * Perform late initialization.
     *
     * @internal
     */
    _addElusiveTargets(): void {
        if (getFlag("elusivesAreShown") === true) {
            this._internalContracts.push(
                ...this._internalElusives!.map((elusive) => {
                    const e = { ...elusive }

                    assert.ok(e.Data.Objectives, "no objectives on ET")

                    e.Data.Objectives = e.Data.Objectives.map(
                        (missionObjective) => {
                            if (
                                missionObjective.SuccessEvent?.EventName ===
                                "Kill"
                            ) {
                                missionObjective.IsHidden = false
                            }

                            return missionObjective
                        },
                    )

                    return e
                }),
            )
            this._internalElusives = undefined
            return
        }

        this._internalContracts.push(...this._internalElusives!)
        this._internalElusives = undefined
    }

    /**
     * Fetch a contract from HITMAPS.
     *
     * @param publicId The contract's public ID.
     * @internal
     */
    static async _hitmapsFetchContract(
        publicId: string,
    ): Promise<MissionManifest | undefined> {
        const id = addDashesToPublicId(publicId)

        type Response = {
            contract?: {
                Contract: MissionManifest
                Location: Unlockable
                UserCentricContract: UserCentricContract
            } | null
            ErrorReason?: string | null
        }

        const resp = await axios.default.get<Response>(hitmapsUrl, {
            params: {
                publicId: id,
            },
        })

        const fetchedData = resp.data
        const hasData = !!fetchedData?.contract?.Contract

        if (!hasData) {
            return undefined
        }

        return fetchedData!.contract!.Contract
    }

    private async _loadResources(): Promise<void> {
        // Load challenge resources
        const challengeDirectory = join(
            PEACOCK_DEV ? process.cwd() : __dirname,
            "resources",
            "challenges",
        )

        await this._handleResources(
            challengeDirectory,
            (data: ChallengePackage) => {
                this._handleChallengeResources(data)
            },
        )

        //Get all global challenges and register a simplified version of them
        {
            const globalChallenges: RegistryChallenge[] = (
                getConfig(
                    "GlobalChallenges",
                    true,
                ) as CompiledChallengeRuntimeData[]
            ).map((e) => {
                const tags = e.Challenge.Tags || []
                tags.push("global")

                //NOTE: Treat all other fields as undefined
                return <RegistryChallenge>{
                    Id: e.Challenge.Id,
                    Tags: tags,
                    Name: e.Challenge.Name,
                    ImageName: e.Challenge.ImageName,
                    Description: e.Challenge.Description,
                    Definition: e.Challenge.Definition,
                    Xp: e.Challenge.Xp,
                    InclusionData: e.Challenge.InclusionData,
                }
            })

            this._handleChallengeResources({
                groups: [
                    <SavedChallengeGroup>{
                        CategoryId: "global",
                        Challenges: globalChallenges,
                    },
                ],
                meta: {
                    Location: "GLOBAL",
                },
            })
        }

        // Load mastery resources
        const masteryDirectory = join(
            PEACOCK_DEV ? process.cwd() : __dirname,
            "resources",
            "mastery",
        )

        await this._handleResources(
            masteryDirectory,
            (data: MasteryPackage) => {
                this._handleMasteryResources(data)
            },
        )
    }

    private async _handleResources<T>(
        directory: string,
        handleDataCallback: (data: T) => void | Promise<void>,
    ): Promise<void> {
        const files = await readdir(directory)

        for (const file of files) {
            try {
                const fileBuffer = await readFile(join(directory, file))
                const data: T = unpack(fileBuffer)

                await handleDataCallback(data)
            } catch (e) {
                log(LogLevel.ERROR, `Aborting resource parsing. ${e}`)
            }
        }
    }

    private _handleChallengeResources(data: ChallengePackage): void {
        for (const group of data.groups) {
            if (
                [
                    "UI_MENU_PAGE_PROFILE_CHALLENGES_CATEGORY_ARCADE",
                    "UI_MENU_PAGE_PROFILE_CHALLENGES_CATEGORY_ESCALATION_HM1",
                    "UI_MENU_PAGE_PROFILE_CHALLENGES_CATEGORY_ESCALATION_HM2",
                ].includes(group.Name)
            ) {
                continue
            }

            this.challengeService.registerGroup(group, data.meta.Location)

            for (const challenge of group.Challenges) {
                this.challengeService.registerChallenge(
                    challenge,
                    group.CategoryId,
                    data.meta.Location,
                )
            }
        }
    }

    private _handleMasteryResources(data: MasteryPackage): void {
        this.masteryService.registerMasteryData(data)
    }

    /**
     * Fetch a contract from the official servers.
     *
     * @param publicId The contract's public ID.
     * @param gameVersion The game's version.
     * @param userId The user's ID.
     * @internal
     * @private
     */
    private static async _officialFetchContract(
        publicId: string,
        gameVersion: GameVersion,
        userId: string,
    ): Promise<MissionManifest | undefined> {
        const remoteService = getRemoteService(gameVersion)

        const user = userAuths.get(userId)

        if (!user) {
            log(LogLevel.WARN, `No authentication for user ${userId}!`)
            return undefined
        }

        const resp = await user._useService<{
            data?: { Contract?: MissionManifest }
        }>(
            `https://${remoteService}.hitman.io/profiles/page/LookupContractPublicId?publicid=${publicId}`,
            true,
        )

        const contractData: MissionManifest | undefined =
            resp.data.data?.Contract

        return contractData || undefined
    }

    /**
     * Loads all normal, pre-built or pure JS plugins either from root or plugins folder.
     *
     * @internal
     */
    private async _loadPlugins(): Promise<void> {
        if (existsSync("plugins")) {
            const entries = (
                await readdir(join(process.cwd(), "plugins"))
            ).filter((n) => isPlugin(n, "js") || isPlugin(n, "cjs"))

            for (const plugin of entries) {
                const sourceFile = join(process.cwd(), "plugins", plugin)
                const src = (await readFile(sourceFile)).toString()

                await this._executePlugin(plugin, src, sourceFile)
            }
        }
        const entries = (await readdir(process.cwd())).filter(
            (n) => isPlugin(n, "js") || isPlugin(n, "cjs"),
        )

        for (const plugin of entries) {
            const src = (await readFile(plugin)).toString()

            await this._executePlugin(plugin, src, join(process.cwd(), plugin))
        }
    }

    private async _loadWorkspacePlugins(): Promise<void> {
        const entries = (await readdir(join(process.cwd(), "plugins"))).filter(
            (n) => isPlugin(n, "ts") || isPlugin(n, "cts"),
        )

        const esbuild = await import("esbuild-wasm")
        const { transform } = esbuild

        for (const plugin of entries) {
            const sourceFile = join(process.cwd(), "plugins", plugin)
            const raw = (await readFile(sourceFile)).toString()

            const builtPlugin = await transform(raw, {
                loader: "ts",
                sourcemap: "inline",
                sourcefile: sourceFile,
                target: "node18",
                format: "cjs",
            })

            await this._executePlugin(plugin, builtPlugin.code, sourceFile)
        }
    }

    private async _executePlugin(
        pluginName: string,
        pluginContents: string,
        pluginPath: string,
    ): Promise<void> {
        const context = createContext({
            module: { exports: {} },
            exports: {},
            process,
            require: createPeacockRequire(pluginName),
        })

        let theExports

        try {
            // eslint-disable-next-line prefer-const
            theExports = new Script(pluginContents, {
                filename: pluginPath,
            }).runInContext(context)
        } catch (e) {
            log(
                LogLevel.ERROR,
                `Error while attempting to queue plugin ${pluginName} for loading!`,
            )
            log(LogLevel.ERROR, e)
            log(LogLevel.ERROR, e.stack)
            return
        }

        try {
            let plugin = theExports

            if (theExports.__esModule) {
                // the plugin thinks it's an ES module (incorrectly, as it's in
                // a CommonJS environment, meaning the plugin was likely written
                // as a module, and then compiled by a tool), so the actual
                // function will likely be on the 'default' property
                plugin = theExports.default ?? theExports
            }

            await (plugin as (controller: Controller) => Promise<void>)(this)
        } catch (e) {
            log(LogLevel.ERROR, `Error while evaluating plugin ${pluginName}!`)
            log(LogLevel.ERROR, e)
            log(LogLevel.ERROR, e.stack)
        }
    }

    private async _loadInternalContracts(): Promise<void> {
        const decompress = promisify(brotliDecompress)

        const buf = await readFile(
            join(
                PEACOCK_DEV ? process.cwd() : __dirname,
                "resources",
                "contracts.br",
            ),
        )

        const decompressed = JSON.parse((await decompress(buf)).toString()) as {
            b: MissionManifest[]
            el: MissionManifest[]
        }

        this._internalContracts = decompressed.b
        this._internalElusives = decompressed.el
    }

    public storeIdToPublicId(contracts: UserCentricContract[]): void {
        contracts.forEach((c) =>
            controller.contractIdToPublicId.set(
                c.Contract.Metadata.Id,
                c.Contract.Metadata.PublicId,
            ),
        )
    }
}

/**
 * Returns if the specified file is a OpenContracts contract file.
 *
 * @param name The file's name.
 * @returns If the specified file is an OCRE.
 */
export function isContractFile(name: string): boolean {
    return name.endsWith(".ocre") || name.endsWith(".json")
}

/**
 * Returns if the specified file is a Peacock plugin file.
 *
 * @param name The file's name.
 * @param extension The target file extension.
 * @returns If the specified file is a plugin.
 */
export function isPlugin(name: string, extension: string): boolean {
    return (
        name.endsWith(`.plugin.${extension}`) ||
        // ends with Plugin.js, but isn't just Plugin.js
        name.endsWith(`Plugin.${extension}`)
    )
}

/**
 * Returns if the specified repository ID is a suit.
 *
 * @param repoId The repository ID.
 * @param gameVersion The game version.
 * @returns If the repository ID points to a suit.
 */
export function isSuit(repoId: string, gameVersion: GameVersion): boolean {
    const suitsToTypeMap = new Map<string, string>()

    ;(getVersionedConfig("allunlockables", gameVersion, false) as Unlockable[])
        .filter((unlockable) => unlockable.Type === "disguise")
        .forEach((u) =>
            suitsToTypeMap.set(u.Properties.RepositoryId, u.Subtype),
        )

    return suitsToTypeMap.has(repoId)
        ? suitsToTypeMap.get(repoId) !== "disguise"
        : false
}

/**
 * Translates a contract ID to a "hit" object.
 *
 * @param contractId The contract's ID.
 * @param gameVersion The game's version.
 * @param userId The current user's ID.
 * @returns The hit object.
 */
export function contractIdToHitObject(
    contractId: string,
    gameVersion: GameVersion,
    userId: string,
): IHit | undefined {
    const contract = controller.resolveContract(contractId)

    if (!contract) {
        throw new Error(
            "Something went terribly wrong. Please investigate this or inform rdil.",
        )
    }

    if (
        gameVersion === "h1" &&
        contract.Metadata.Location.includes("LOCATION_ICA_FACILITY")
    ) {
        contract.Metadata.Location = "LOCATION_ICA_FACILITY"
    }

    const subLocation = getSubLocationFromContract(contract, gameVersion)

    const parentLocation = getVersionedConfig<PeacockLocationsData>(
        "LocationsData",
        gameVersion,
        false,
    ).parents[subLocation?.Properties?.ParentLocation]

    // failed to find the location, must be from a newer game
    if (!subLocation && (gameVersion === "h1" || gameVersion === "h2")) {
        log(
            LogLevel.DEBUG,
            `${contract.Metadata.Location} looks to be from a newer game, skipping (hitObj)!`,
        )
        return undefined
    }

    const userCentric = generateUserCentric(contract, userId, gameVersion)

    if (!userCentric) {
        log(LogLevel.ERROR, "No UC due to previous error?")
        return undefined
    }

    const challenges = controller.challengeService.getGroupedChallengeLists(
        {
            type: ChallengeFilterType.None,
        },
        parentLocation?.Id,
    )

    const challengeCompletion =
        controller.challengeService.countTotalNCompletedChallenges(
            challenges,
            userId,
            gameVersion,
        )

    return {
        Id: contract.Metadata.Id,
        UserCentricContract: userCentric,
        Location: parentLocation,
        SubLocation: subLocation,
        ChallengesCompleted: challengeCompletion.CompletedChallengesCount,
        ChallengesTotal: challengeCompletion.ChallengesCount,
        LocationLevel: userCentric.Data.LocationLevel,
        LocationMaxLevel: userCentric.Data.LocationMaxLevel,
        LocationCompletion: userCentric.Data.LocationCompletion,
        LocationXPLeft: userCentric.Data.LocationXpLeft,
        LocationHideProgression: userCentric.Data.LocationHideProgression,
    }
}

/**
 * Sends an array of publicIds to the contract preservation backend.
 * @param publicIds The contract publicIds to send.
 */
export async function preserveContracts(publicIds: string[]): Promise<void> {
    for (const id of publicIds) {
        await axios.default.get<Response>(hitmapsUrl, {
            params: {
                publicId: addDashesToPublicId(id),
            },
        })
    }
}

export const controller = new Controller()