Peacock/components/candle/masteryService.ts

/*
 *     The Peacock Project - a HITMAN server replacement.
 *     Copyright (C) 2021-2024 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 {
    getParentLocationByName,
    getSubLocationByName,
} from "../contracts/dataGen"
import { log, LogLevel } from "../loggingInterop"
import { getVersionedConfig } from "../configSwizzleManager"
import { getUserData } from "../databaseHandler"
import {
    LocationMasteryData,
    MasteryData,
    MasteryDrop,
    MasteryPackage,
    MasteryPackageDrop,
    UnlockableMasteryData,
} from "../types/mastery"
import {
    CompletionData,
    GameVersion,
    ProgressionData,
    Unlockable,
} from "../types/types"
import {
    clampValue,
    DEFAULT_MASTERY_MAXLEVEL,
    isSniperLocation,
    xpRequiredForEvergreenLevel,
    xpRequiredForLevel,
    xpRequiredForSniperLevel,
} from "../utils"

import { getUnlockablesById } from "../inventory"
import assert from "assert"

export class MasteryService {
    /**
     * @Key1 Game version.
     * @Key2 The parent location Id.
     * @Value A `MasteryPackage` object.
     */
    protected masteryPackages: Record<
        GameVersion,
        Map<string, MasteryPackage>
    > = {
        h1: new Map(),
        h2: new Map(),
        h3: new Map(),
        scpc: new Map(),
    }
    /**
     * @Key1 Game version.
     * @Key2 Unlockable Id.
     * @Value A `MasteryPackage` object.
     */
    private unlockableMasteryData: Record<
        GameVersion,
        Map<string, UnlockableMasteryData>
    > = {
        h1: new Map(),
        h2: new Map(),
        h3: new Map(),
        scpc: new Map(),
    }

    registerMasteryData(masteryPackage: MasteryPackage) {
        for (const gv of masteryPackage.GameVersions) {
            this.masteryPackages[gv].set(
                masteryPackage.LocationId,
                masteryPackage,
            )

            /**
             * Generates the same data in a reverse order. It could be considered redundant but this allows for
             * faster access to location and level based on unlockable ID, avoiding big-O operation for `getMasteryForUnlockable`
             */
            if (masteryPackage.SubPackages) {
                for (const subPkg of masteryPackage.SubPackages) {
                    for (const drop of subPkg.Drops) {
                        this.unlockableMasteryData[gv].set(drop.Id, {
                            Location: masteryPackage.LocationId,
                            SubPackageId: subPkg.Id,
                            Level: drop.Level,
                        })
                    }
                }
            } else {
                for (const drop of masteryPackage.Drops) {
                    this.unlockableMasteryData[gv].set(drop.Id, {
                        Location: masteryPackage.LocationId,
                        Level: drop.Level,
                    })
                }
            }
        }
    }

    /**
     * Returns mastery data for unlockable, if there's any
     * @param unlockable
     * @param gameVersion
     */
    getMasteryForUnlockable(
        unlockable: Unlockable,
        gameVersion: GameVersion,
    ): UnlockableMasteryData | undefined {
        return this.unlockableMasteryData[gameVersion].get(unlockable.Id)
    }

    /**
     * Exact same thing as {@link getMasteryData}.
     */
    getMasteryDataForDestination(
        locationParentId: string,
        gameVersion: GameVersion,
        userId: string,
        difficulty?: string,
    ): MasteryData[] {
        return this.getMasteryData(
            locationParentId,
            gameVersion,
            userId,
            difficulty,
        )
    }

    getMasteryDataForSubPackage(
        locationParentId: string,
        subPackageId: string,
        gameVersion: GameVersion,
        userId: string,
    ): MasteryData {
        // Since we're getting a subpackage, we know there will only be one entry in this array.
        // If the array is empty it will return undefined.
        return this.getMasteryData(
            locationParentId,
            gameVersion,
            userId,
            subPackageId,
        )[0]
    }

    getMasteryDataForLocation(
        locationId: string,
        gameVersion: GameVersion,
        userId: string,
    ): LocationMasteryData {
        const location =
            getSubLocationByName(locationId, gameVersion) ??
            getParentLocationByName(locationId, gameVersion)

        assert.ok(location, "cannot get mastery data for unknown location")

        const masteryData = this.getMasteryData(
            location.Properties.ParentLocation ?? location.Id,
            gameVersion,
            userId,
        )

        return {
            Location: location,
            MasteryData: masteryData,
        }
    }

    /**
     * Get generic completion data stored in a user's profile. Called by both `getLocationCompletion` and `getFirearmCompletion`.
     * @param userId The id of the user.
     * @param gameVersion The game version.
     * @param locationParentId The location's parent ID, used for progression storage @since v7.0.0
     * @param maxLevel The max level for this progression.
     * @param levelToXpRequired A function to get the XP required for a level.
     * @param subPackageId The subpackage id you want.
     */
    private getCompletionData(
        userId: string,
        gameVersion: GameVersion,
        locationParentId: string,
        maxLevel: number,
        levelToXpRequired: (level: number) => number,
        subPackageId?: string,
    ) {
        // Get the user profile
        const userProfile = getUserData(userId, gameVersion)

        const parent =
            userProfile.Extensions.progression.Locations[locationParentId]

        const completionData: ProgressionData = subPackageId
            ? (parent[subPackageId as keyof typeof parent] as ProgressionData)
            : (parent as ProgressionData)

        const nextLevel: number = clampValue(
            completionData.Level + 1,
            1,
            maxLevel,
        )

        const nextLevelXp: number = levelToXpRequired(nextLevel)

        const thisLevelXp: number = levelToXpRequired(completionData.Level)

        return {
            Level: completionData.Level,
            MaxLevel: maxLevel,
            XP: completionData.Xp,
            PreviouslySeenXp: completionData.PreviouslySeenXp,
            Completion:
                (completionData.Xp - thisLevelXp) / (nextLevelXp - thisLevelXp),
            XpLeft: nextLevelXp - completionData.Xp,
        }
    }

    /**
     * Get the completion data for a location.
     * @param locationParentId The parent Id of the location.
     * @param subLocationId The id of the sublocation.
     * @param gameVersion The game version.
     * @param userId The id of the user.
     * @param contractType The type of the contract, only used to distinguish evergreen from other types (default).
     * @param subPackageId The id of the subpackage you want.
     * @returns The CompletionData object.
     */
    getLocationCompletion(
        locationParentId: string,
        subLocationId: string,
        gameVersion: GameVersion,
        userId: string,
        contractType = "mission",
        subPackageId?: string,
    ): CompletionData | undefined {
        // Get the mastery data
        const masteryPkg = this.getMasteryPackage(locationParentId, gameVersion)

        // We use the result from this function a bit, so we're just caching it
        const isSniper = isSniperLocation(locationParentId)

        if (!masteryPkg || (masteryPkg.SubPackages && !subPackageId)) {
            return undefined
        }

        const subPackage = masteryPkg.SubPackages
            ? masteryPkg.SubPackages.filter((pkg) => pkg.Id === subPackageId)[0]
            : undefined

        if (!subPackage && subPackageId) {
            return undefined
        }

        // TODO: Refactor this into the new inventory system?
        const name = isSniper
            ? getVersionedConfig<Unlockable[]>(
                  "SniperUnlockables",
                  gameVersion,
                  false,
              ).find((unlockable) => unlockable.Id === subPackageId)?.Properties
                  .Name
            : undefined

        return {
            ...this.getCompletionData(
                userId,
                gameVersion,
                locationParentId,
                (subPackage ? subPackage.MaxLevel : masteryPkg.MaxLevel) ||
                    DEFAULT_MASTERY_MAXLEVEL,
                contractType === "sniper"
                    ? xpRequiredForSniperLevel
                    : contractType === "evergreen"
                    ? xpRequiredForEvergreenLevel
                    : xpRequiredForLevel,
                subPackageId,
            ),
            Id: isSniper ? subPackageId! : masteryPkg.LocationId,
            SubLocationId: isSniper ? "" : subLocationId,
            HideProgression: masteryPkg.HideProgression || false,
            IsLocationProgression: !isSniper,
            Name: name!,
        }
    }

    getMasteryPackage(
        locationParentId: string,
        gameVersion: GameVersion,
    ): MasteryPackage | undefined {
        return this.masteryPackages[gameVersion].get(locationParentId)
    }

    private processDrops(
        curLevel: number,
        drops: MasteryPackageDrop[],
        unlockableMap: Map<string, Unlockable>,
    ): MasteryDrop[] {
        return drops
            .filter((drop) => {
                if (!unlockableMap.has(drop.Id)) {
                    log(LogLevel.DEBUG, `No unlockable found for ${drop.Id}`)

                    return false
                }

                return true
            })
            .map((drop) => {
                const unlockable: Unlockable = unlockableMap.get(drop.Id)!

                return {
                    IsLevelMarker: false,
                    Unlockable: unlockable,
                    Level: drop.Level,
                    IsLocked: drop.Level > curLevel,
                    TypeLocaKey: `UI_MENU_PAGE_MASTERY_UNLOCKABLE_NAME_${unlockable.Type}`,
                }
            })
    }

    private getMasteryData(
        locationParentId: string,
        gameVersion: GameVersion,
        userId: string,
        subPackageId?: string,
    ): MasteryData[] {
        // Get the mastery data
        const masteryPkg: MasteryPackage | undefined = this.getMasteryPackage(
            locationParentId,
            gameVersion,
        )

        if (!masteryPkg || (!masteryPkg.Drops && !masteryPkg.SubPackages)) {
            return []
        }

        // We use the result from this function a lot in here, so we're just "caching" it
        const isSniper = isSniperLocation(locationParentId)

        // Put all Ids into a set for quick lookup
        let dropIdSet: Set<string>

        if (masteryPkg.SubPackages) {
            dropIdSet = new Set(
                masteryPkg.SubPackages.map((pkg) =>
                    subPackageId && pkg.Id !== subPackageId
                        ? []
                        : pkg.Drops.map((drop) => drop.Id),
                ).reduce((a, e) => a.concat(e)),
            )

            // Add the main unlockable to the set to generate the page properly
            if (isSniper) {
                masteryPkg.SubPackages.forEach((pkg) => dropIdSet.add(pkg.Id))
            }

            if (!dropIdSet || dropIdSet.size === 0) {
                log(
                    LogLevel.ERROR,
                    "Unknown subPackageId specified for location",
                )

                return []
            }
        } else {
            dropIdSet = new Set(masteryPkg.Drops.map((drop) => drop.Id))
        }

        // Get all unlockables with matching Ids
        const unlockableData = getUnlockablesById(
            Array.from(dropIdSet),
            gameVersion,
        )

        // Put all unlockabkes in a map for quick lookup
        const mapped: [string, Unlockable][] = unlockableData.map(
            (unlockable) => {
                return [unlockable?.Id, unlockable] as unknown as [
                    string,
                    Unlockable,
                ]
            },
        )

        const unlockableMap: Map<string, Unlockable> = new Map(mapped)

        const masteryData: MasteryData[] = []

        if (masteryPkg.SubPackages) {
            for (const subPkg of masteryPkg.SubPackages) {
                if (subPackageId && subPkg.Id !== subPackageId) continue

                const completionData = this.getLocationCompletion(
                    locationParentId,
                    locationParentId,
                    gameVersion,
                    userId,
                    isSniper
                        ? "sniper"
                        : locationParentId.includes("SNUG")
                        ? "evergreen"
                        : "mission",
                    subPkg.Id,
                )

                if (completionData) {
                    masteryData.push({
                        CompletionData: completionData,
                        Drops: this.processDrops(
                            completionData.Level,
                            subPkg.Drops,
                            unlockableMap,
                        ),
                        Unlockable: isSniper
                            ? unlockableMap.get(subPkg.Id)
                            : undefined,
                    })
                }
            }
        } else {
            // All sniper locations are subpackages, so we don't need to add "sniper"
            // to the contractType expression.
            const completionData = this.getLocationCompletion(
                locationParentId,
                locationParentId,
                gameVersion,
                userId,
                locationParentId.includes("SNUG") ? "evergreen" : "mission",
            )

            if (completionData) {
                masteryData.push({
                    CompletionData: completionData,
                    Drops: this.processDrops(
                        completionData.Level,
                        masteryPkg.Drops || [],
                        unlockableMap,
                    ),
                })
            }
        }

        return masteryData
    }
}