Server/project/src/helpers/QuestHelper.ts

import { inject, injectable } from "tsyringe";

import { DialogueHelper } from "@spt-aki/helpers/DialogueHelper";
import { ItemHelper } from "@spt-aki/helpers/ItemHelper";
import { PaymentHelper } from "@spt-aki/helpers/PaymentHelper";
import { PresetHelper } from "@spt-aki/helpers/PresetHelper";
import { ProfileHelper } from "@spt-aki/helpers/ProfileHelper";
import { QuestConditionHelper } from "@spt-aki/helpers/QuestConditionHelper";
import { RagfairServerHelper } from "@spt-aki/helpers/RagfairServerHelper";
import { TraderHelper } from "@spt-aki/helpers/TraderHelper";
import { IPmcData } from "@spt-aki/models/eft/common/IPmcData";
import { Common, IQuestStatus } from "@spt-aki/models/eft/common/tables/IBotBase";
import { Item } from "@spt-aki/models/eft/common/tables/IItem";
import { IQuest, IQuestCondition, IQuestReward } from "@spt-aki/models/eft/common/tables/IQuest";
import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse";
import { IAcceptQuestRequestData } from "@spt-aki/models/eft/quests/IAcceptQuestRequestData";
import { IFailQuestRequestData } from "@spt-aki/models/eft/quests/IFailQuestRequestData";
import { ConfigTypes } from "@spt-aki/models/enums/ConfigTypes";
import { MessageType } from "@spt-aki/models/enums/MessageType";
import { QuestRewardType } from "@spt-aki/models/enums/QuestRewardType";
import { QuestStatus } from "@spt-aki/models/enums/QuestStatus";
import { SkillTypes } from "@spt-aki/models/enums/SkillTypes";
import { IQuestConfig } from "@spt-aki/models/spt/config/IQuestConfig";
import { ILogger } from "@spt-aki/models/spt/utils/ILogger";
import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder";
import { ConfigServer } from "@spt-aki/servers/ConfigServer";
import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
import { LocaleService } from "@spt-aki/services/LocaleService";
import { LocalisationService } from "@spt-aki/services/LocalisationService";
import { MailSendService } from "@spt-aki/services/MailSendService";
import { HashUtil } from "@spt-aki/utils/HashUtil";
import { JsonUtil } from "@spt-aki/utils/JsonUtil";
import { TimeUtil } from "@spt-aki/utils/TimeUtil";

@injectable()
export class QuestHelper
{
    protected questConfig: IQuestConfig;

    constructor(
        @inject("WinstonLogger") protected logger: ILogger,
        @inject("JsonUtil") protected jsonUtil: JsonUtil,
        @inject("TimeUtil") protected timeUtil: TimeUtil,
        @inject("HashUtil") protected hashUtil: HashUtil,
        @inject("ItemHelper") protected itemHelper: ItemHelper,
        @inject("QuestConditionHelper") protected questConditionHelper: QuestConditionHelper,
        @inject("EventOutputHolder") protected eventOutputHolder: EventOutputHolder,
        @inject("DatabaseServer") protected databaseServer: DatabaseServer,
        @inject("LocaleService") protected localeService: LocaleService,
        @inject("RagfairServerHelper") protected ragfairServerHelper: RagfairServerHelper,
        @inject("DialogueHelper") protected dialogueHelper: DialogueHelper,
        @inject("ProfileHelper") protected profileHelper: ProfileHelper,
        @inject("PaymentHelper") protected paymentHelper: PaymentHelper,
        @inject("LocalisationService") protected localisationService: LocalisationService,
        @inject("TraderHelper") protected traderHelper: TraderHelper,
        @inject("PresetHelper") protected presetHelper: PresetHelper,
        @inject("MailSendService") protected mailSendService: MailSendService,
        @inject("ConfigServer") protected configServer: ConfigServer,
    )
    {
        this.questConfig = this.configServer.getConfig(ConfigTypes.QUEST);
    }

    /**
     * Get status of a quest in player profile by its id
     * @param pmcData Profile to search
     * @param questId Quest id to look up
     * @returns QuestStatus enum
     */
    public getQuestStatus(pmcData: IPmcData, questId: string): QuestStatus
    {
        const quest = pmcData.Quests?.find((q) => q.qid === questId);

        return quest ? quest.status : QuestStatus.Locked;
    }

    /**
     * returns true is the level condition is satisfied
     * @param playerLevel Players level
     * @param condition Quest condition
     * @returns true if player level is greater than or equal to quest
     */
    public doesPlayerLevelFulfilCondition(playerLevel: number, condition: IQuestCondition): boolean
    {
        if (condition.conditionType === "Level")
        {
            switch (condition.compareMethod)
            {
                case ">=":
                    return playerLevel >= <number>condition.value;
                case ">":
                    return playerLevel > <number>condition.value;
                case "<":
                    return playerLevel < <number>condition.value;
                case "<=":
                    return playerLevel <= <number>condition.value;
                case "=":
                    return playerLevel === <number>condition.value;
                default:
                    this.logger.error(
                        this.localisationService.getText(
                            "quest-unable_to_find_compare_condition",
                            condition.compareMethod,
                        ),
                    );
                    return false;
            }
        }
    }

    /**
     * Get the quests found in both arrays (inner join)
     * @param before Array of quests #1
     * @param after Array of quests #2
     * @returns Reduction of cartesian product between two quest arrays
     */
    public getDeltaQuests(before: IQuest[], after: IQuest[]): IQuest[]
    {
        const knownQuestsIds = [];
        for (const q of before)
        {
            knownQuestsIds.push(q._id);
        }

        if (knownQuestsIds.length)
        {
            return after.filter((q) =>
            {
                return knownQuestsIds.indexOf(q._id) === -1;
            });
        }

        return after;
    }

    /**
     * Adjust skill experience for low skill levels, mimicing the official client
     * @param profileSkill the skill experience is being added to
     * @param progressAmount the amount of experience being added to the skill
     * @returns the adjusted skill progress gain
     */
    public adjustSkillExpForLowLevels(profileSkill: Common, progressAmount: number): number
    {
        let currentLevel = Math.floor(profileSkill.Progress / 100);

        // Only run this if the current level is under 9
        if (currentLevel >= 9)
        {
            return progressAmount;
        }

        // This calculates how much progress we have in the skill's starting level
        let startingLevelProgress = (profileSkill.Progress % 100) * ((currentLevel + 1) / 10);

        // The code below assumes a 1/10th progress skill amount
        let remainingProgress = progressAmount / 10;

        // We have to do this loop to handle edge cases where the provided XP bumps your level up
        // See "CalculateExpOnFirstLevels" in client for original logic
        let adjustedSkillProgress = 0;
        while (remainingProgress > 0 && currentLevel < 9)
        {
            // Calculate how much progress to add, limiting it to the current level max progress
            const currentLevelRemainingProgress = ((currentLevel + 1) * 10) - startingLevelProgress;
            this.logger.debug(`currentLevelRemainingProgress: ${currentLevelRemainingProgress}`);
            const progressToAdd = Math.min(remainingProgress, currentLevelRemainingProgress);
            const adjustedProgressToAdd = (10 / (currentLevel + 1)) * progressToAdd;
            this.logger.debug(`Progress To Add: ${progressToAdd}  Adjusted for level: ${adjustedProgressToAdd}`);

            // Add the progress amount adjusted by level
            adjustedSkillProgress += adjustedProgressToAdd;
            remainingProgress -= progressToAdd;
            startingLevelProgress = 0;
            currentLevel++;
        }

        // If there's any remaining progress, add it. This handles if you go from level 8 -> 9
        if (remainingProgress > 0)
        {
            adjustedSkillProgress += remainingProgress;
        }

        return adjustedSkillProgress;
    }

    /**
     * Get quest name by quest id
     * @param questId id to get
     * @returns
     */
    public getQuestNameFromLocale(questId: string): string
    {
        const questNameKey = `${questId} name`;
        return this.localeService.getLocaleDb()[questNameKey];
    }

    /**
     * Check if trader has sufficient loyalty to fulfill quest requirement
     * @param questProperties Quest props
     * @param profile Player profile
     * @returns true if loyalty is high enough to fulfill quest requirement
     */
    public traderLoyaltyLevelRequirementCheck(questProperties: IQuestCondition, profile: IPmcData): boolean
    {
        const requiredLoyaltyLevel = Number(questProperties.value);
        const trader = profile.TradersInfo[<string>questProperties.target];
        if (!trader)
        {
            this.logger.error(`Unable to find trader: ${questProperties.target} in profile`);
        }

        return this.compareAvailableForValues(trader.loyaltyLevel, requiredLoyaltyLevel, questProperties.compareMethod);
    }

    /**
     * Check if trader has sufficient standing to fulfill quest requirement
     * @param questProperties Quest props
     * @param profile Player profile
     * @returns true if standing is high enough to fulfill quest requirement
     */
    public traderStandingRequirementCheck(questProperties: IQuestCondition, profile: IPmcData): boolean
    {
        const requiredStanding = Number(questProperties.value);
        const trader = profile.TradersInfo[<string>questProperties.target];
        if (!trader)
        {
            this.logger.error(`Unable to find trader: ${questProperties.target} in profile`);
        }

        return this.compareAvailableForValues(trader.standing, requiredStanding, questProperties.compareMethod);
    }

    protected compareAvailableForValues(current: number, required: number, compareMethod: string): boolean
    {
        switch (compareMethod)
        {
            case ">=":
                return current >= required;
            case ">":
                return current > required;
            case "<=":
                return current <= required;
            case "<":
                return current < required;
            case "!=":
                return current !== required;
            case "==":
                return current === required;

            default:
                this.logger.error(this.localisationService.getText("quest-compare_operator_unhandled", compareMethod));

                return false;
        }
    }

    /**
     * Take reward item from quest and set FiR status + fix stack sizes + fix mod Ids
     * @param questReward Reward item to fix
     * @returns Fixed rewards
     */
    protected processReward(questReward: IQuestReward): Item[]
    {
        /** item with mods to return */
        let rewardItems: Item[] = [];
        let targets: Item[] = [];
        const mods: Item[] = [];
        const rootItem = questReward.items[0];

        // Is armor item that may need inserts / plates
        if (questReward.items.length === 1 && this.itemHelper.armorItemCanHoldMods(rootItem._tpl))
        {
            // Only process items with slots
            if (this.itemHelper.itemHasSlots(rootItem._tpl))
            {
                // Attempt to pull default preset from globals and add child items to reward
                this.generateArmorRewardChildSlots(rootItem, questReward);
            }
        }

        for (const item of questReward.items)
        {
            // reward items are granted Found in Raid status
            if (!item.upd)
            {
                item.upd = {};
            }

            item.upd.SpawnedInSession = true;

            // Separate base item from mods, fix stacks
            if (item._id === questReward.target)
            { // Is base reward item
                if (
                    (item.parentId !== undefined) && (item.parentId === "hideout") // Has parentId of hideout
                    && (item.upd !== undefined) && (item.upd.StackObjectsCount !== undefined) // Has upd with stackobject count
                    && (item.upd.StackObjectsCount > 1) // More than 1 item in stack
                )
                {
                    item.upd.StackObjectsCount = 1;
                }
                targets = this.itemHelper.splitStack(item);
                // splitStack created new ids for the new stacks. This would destroy the relation to possible children.
                // Instead, we reset the id to preserve relations and generate a new id in the downstream loop, where we are also reparenting if required
                for (const target of targets)
                {
                    target._id = item._id;
                }
            }
            else
            {
                // Is child mod
                if (rootItem.upd.SpawnedInSession)
                {
                    // Propigate FiR status into child items
                    item.upd.SpawnedInSession = rootItem.upd.SpawnedInSession;
                }

                mods.push(item);
            }
        }

        // Add mods to the base items, fix ids
        for (const target of targets)
        {
            // This has all the original id relations since we reset the id to the original after the splitStack
            const items = [this.jsonUtil.clone(target)];
            // Here we generate a new id for the root item
            target._id = this.hashUtil.generate();

            for (const mod of mods)
            {
                items.push(this.jsonUtil.clone(mod));
            }

            rewardItems = rewardItems.concat(this.itemHelper.reparentItemAndChildren(target, items));
        }

        return rewardItems;
    }

    /**
     * Add missing mod items to a quest armor reward
     * @param originalRewardRootItem Original armor reward item from IQuestReward.items object
     * @param questReward Armor reward from quest
     */
    protected generateArmorRewardChildSlots(originalRewardRootItem: Item, questReward: IQuestReward): void
    {
        // Look for a default preset from globals for armor
        const defaultPreset = this.presetHelper.getDefaultPreset(originalRewardRootItem._tpl);
        if (defaultPreset)
        {
            // Preset exists, use mods to hydrate reward item
            questReward.items = this.jsonUtil.clone(defaultPreset._items);

            // Remap target id to the new presets id
            questReward.target = questReward.items.find((item) => item._tpl === originalRewardRootItem._tpl)._id;

            return;
        }

        this.logger.warning(
            `Unable to find default preset for armor ${originalRewardRootItem._tpl}, adding mods manually`,
        );
        const itemDbData = this.itemHelper.getItem(originalRewardRootItem._tpl)[1];

        // Hydrate reward with only 'required' mods - necessary for things like helmets otherwise you end up with nvgs/visors etc
        questReward.items = this.itemHelper.addChildSlotItems(questReward.items, itemDbData, null, true);
    }

    /**
     * Gets a flat list of reward items for the given quest at a specific state (e.g. Fail/Success)
     * @param quest quest to get rewards for
     * @param status Quest status that holds the items (Started, Success, Fail)
     * @returns array of items with the correct maxStack
     */
    public getQuestRewardItems(quest: IQuest, status: QuestStatus): Item[]
    {
        // Iterate over all rewards with the desired status, flatten out items that have a type of Item
        const questRewards = quest.rewards[QuestStatus[status]].flatMap((reward: IQuestReward) =>
            reward.type === "Item" ? this.processReward(reward) : []
        );

        return questRewards;
    }

    /**
     * Look up quest in db by accepted quest id and construct a profile-ready object ready to store in profile
     * @param pmcData Player profile
     * @param newState State the new quest should be in when returned
     * @param acceptedQuest Details of accepted quest from client
     */
    public getQuestReadyForProfile(
        pmcData: IPmcData,
        newState: QuestStatus,
        acceptedQuest: IAcceptQuestRequestData,
    ): IQuestStatus
    {
        const currentTimestamp = this.timeUtil.getTimestamp();
        const existingQuest = pmcData.Quests.find((q) => q.qid === acceptedQuest.qid);
        if (existingQuest)
        {
            // Quest exists, update its status
            existingQuest.startTime = currentTimestamp;
            existingQuest.status = newState;
            existingQuest.statusTimers[newState] = currentTimestamp;
            existingQuest.completedConditions = [];

            if (existingQuest.availableAfter)
            {
                delete existingQuest.availableAfter;
            }

            return existingQuest;
        }

        // Quest doesn't exists, add it
        const newQuest: IQuestStatus = {
            qid: acceptedQuest.qid,
            startTime: currentTimestamp,
            status: newState,
            statusTimers: {},
        };

        // Check if quest has a prereq to be placed in a 'pending' state, otherwise set status timers value
        const questDbData = this.getQuestFromDb(acceptedQuest.qid, pmcData);
        if (!questDbData)
        {
            this.logger.error(`Quest: ${acceptedQuest.qid} of type: ${acceptedQuest.type} not found`);
        }

        const waitTime = questDbData?.conditions.AvailableForStart.find((x) => x.availableAfter > 0);
        if (waitTime && acceptedQuest.type !== "repeatable")
        {
            // Quest should be put into 'pending' state
            newQuest.startTime = 0;
            newQuest.status = QuestStatus.AvailableAfter; // 9
            newQuest.availableAfter = currentTimestamp + waitTime.availableAfter;
        }
        else
        {
            newQuest.statusTimers[newState.toString()] = currentTimestamp;
            newQuest.completedConditions = [];
        }

        return newQuest;
    }

    /**
     * Get quests that can be shown to player after starting a quest
     * @param startedQuestId Quest started by player
     * @param sessionID Session id
     * @returns Quests accessible to player incuding newly unlocked quests now quest (startedQuestId) was started
     */
    public getNewlyAccessibleQuestsWhenStartingQuest(startedQuestId: string, sessionID: string): IQuest[]
    {
        // Get quest acceptance data from profile
        const profile: IPmcData = this.profileHelper.getPmcProfile(sessionID);
        const startedQuestInProfile = profile.Quests.find((x) => x.qid === startedQuestId);

        // Get quests that
        const eligibleQuests = this.getQuestsFromDb().filter((quest) =>
        {
            // Quest is accessible to player when the accepted quest passed into param is started
            // e.g. Quest A passed in, quest B is looped over and has requirement of A to be started, include it
            const acceptedQuestCondition = quest.conditions.AvailableForStart.find((x) =>
            {
                return x.conditionType === "Quest"
                    && x.target?.includes(startedQuestId)
                    && x.status?.includes(QuestStatus.Started);
            });

            // Not found, skip quest
            if (!acceptedQuestCondition)
            {
                return false;
            }

            const standingRequirements = this.questConditionHelper.getStandingConditions(
                quest.conditions.AvailableForStart,
            );
            for (const condition of standingRequirements)
            {
                if (!this.traderStandingRequirementCheck(condition, profile))
                {
                    return false;
                }
            }

            const loyaltyRequirements = this.questConditionHelper.getLoyaltyConditions(
                quest.conditions.AvailableForStart,
            );
            for (const condition of loyaltyRequirements)
            {
                if (!this.traderLoyaltyLevelRequirementCheck(condition, profile))
                {
                    return false;
                }
            }

            // Include if quest found in profile and is started or ready to hand in
            return startedQuestInProfile
                && ([QuestStatus.Started, QuestStatus.AvailableForFinish].includes(startedQuestInProfile.status));
        });

        return this.getQuestsWithOnlyLevelRequirementStartCondition(eligibleQuests);
    }

    /**
     * Get quests that can be shown to player after failing a quest
     * @param failedQuestId Id of the quest failed by player
     * @param sessionId Session id
     * @returns IQuest array
     */
    public failedUnlocked(failedQuestId: string, sessionId: string): IQuest[]
    {
        const profile = this.profileHelper.getPmcProfile(sessionId);
        const profileQuest = profile.Quests.find((x) => x.qid === failedQuestId);

        const quests = this.getQuestsFromDb().filter((q) =>
        {
            const acceptedQuestCondition = q.conditions.AvailableForStart.find((c) =>
            {
                return c.conditionType === "Quest"
                    && c.target.includes(failedQuestId)
                    && c.status[0] === QuestStatus.Fail;
            });

            if (!acceptedQuestCondition)
            {
                return false;
            }

            return profileQuest && (profileQuest.status === QuestStatus.Fail);
        });

        if (quests.length === 0)
        {
            return quests;
        }

        return this.getQuestsWithOnlyLevelRequirementStartCondition(quests);
    }

    /**
     * Adjust quest money rewards by passed in multiplier
     * @param quest Quest to multiple money rewards
     * @param multiplier Value to adjust money rewards by
     * @param questStatus Status of quest to apply money boost to rewards of
     * @returns Updated quest
     */
    public applyMoneyBoost(quest: IQuest, multiplier: number, questStatus: QuestStatus): IQuest
    {
        const rewards: IQuestReward[] = quest.rewards?.[QuestStatus[questStatus]] ?? [];
        for (const reward of rewards)
        {
            if (reward.type === "Item")
            {
                if (this.paymentHelper.isMoneyTpl(reward.items[0]._tpl))
                {
                    reward.items[0].upd.StackObjectsCount += Math.round(
                        reward.items[0].upd.StackObjectsCount * multiplier / 100,
                    );
                }
            }
        }

        return quest;
    }

    /**
     * Sets the item stack to new value, or delete the item if value <= 0
     * // TODO maybe merge this function and the one from customization
     * @param pmcData Profile
     * @param itemId id of item to adjust stack size of
     * @param newStackSize Stack size to adjust to
     * @param sessionID Session id
     * @param output ItemEvent router response
     */
    public changeItemStack(
        pmcData: IPmcData,
        itemId: string,
        newStackSize: number,
        sessionID: string,
        output: IItemEventRouterResponse,
    ): void
    {
        const inventoryItemIndex = pmcData.Inventory.items.findIndex((item) => item._id === itemId);
        if (inventoryItemIndex < 0)
        {
            this.logger.error(this.localisationService.getText("quest-item_not_found_in_inventory", itemId));

            return;
        }

        if (newStackSize > 0)
        {
            const item = pmcData.Inventory.items[inventoryItemIndex];
            if (!item.upd)
            {
                item.upd = {};
            }
            item.upd.StackObjectsCount = newStackSize;

            this.addItemStackSizeChangeIntoEventResponse(output, sessionID, item);
        }
        else
        {
            // this case is probably dead Code right now, since the only calling function
            // checks explicitly for Value > 0.
            output.profileChanges[sessionID].items.del.push({ _id: itemId });
            pmcData.Inventory.items.splice(inventoryItemIndex, 1);
        }
    }

    /**
     * Add item stack change object into output route event response
     * @param output Response to add item change event into
     * @param sessionId Session id
     * @param item Item that was adjusted
     */
    protected addItemStackSizeChangeIntoEventResponse(
        output: IItemEventRouterResponse,
        sessionId: string,
        item: Item,
    ): void
    {
        output.profileChanges[sessionId].items.change.push({
            _id: item._id,
            _tpl: item._tpl,
            parentId: item.parentId,
            slotId: item.slotId,
            location: item.location,
            upd: { StackObjectsCount: item.upd.StackObjectsCount },
        });
    }

    /**
     * Get quests, strip all requirement conditions except level
     * @param quests quests to process
     * @returns quest array without conditions
     */
    protected getQuestsWithOnlyLevelRequirementStartCondition(quests: IQuest[]): IQuest[]
    {
        for (const i in quests)
        {
            quests[i] = this.getQuestWithOnlyLevelRequirementStartCondition(quests[i]);
        }

        return quests;
    }

    /**
     * Remove all quest conditions except for level requirement
     * @param quest quest to clean
     * @returns reset IQuest object
     */
    public getQuestWithOnlyLevelRequirementStartCondition(quest: IQuest): IQuest
    {
        quest = this.jsonUtil.clone(quest);
        quest.conditions.AvailableForStart = quest.conditions.AvailableForStart.filter((q) =>
            q.conditionType === "Level"
        );

        return quest;
    }

    /**
     * Fail a quest in a player profile
     * @param pmcData Player profile
     * @param failRequest Fail quest request data
     * @param sessionID Session id
     * @param output Client output
     * @returns Item event router response
     */
    public failQuest(
        pmcData: IPmcData,
        failRequest: IFailQuestRequestData,
        sessionID: string,
        output: IItemEventRouterResponse = null,
    ): IItemEventRouterResponse
    {
        // Prepare response to send back client
        if (!output)
        {
            output = this.eventOutputHolder.getOutput(sessionID);
        }

        this.updateQuestState(pmcData, QuestStatus.Fail, failRequest.qid);
        const questRewards = this.applyQuestReward(pmcData, failRequest.qid, QuestStatus.Fail, sessionID, output);

        // Create a dialog message for completing the quest.
        const quest = this.getQuestFromDb(failRequest.qid, pmcData);

        const questIsRepeatable = pmcData.RepeatableQuests.some((quest) => quest.id === failRequest.qid);
        if (!questIsRepeatable)
        {
            this.mailSendService.sendLocalisedNpcMessageToPlayer(
                sessionID,
                this.traderHelper.getTraderById(quest.traderId),
                MessageType.QUEST_FAIL,
                quest.failMessageText,
                questRewards,
                this.timeUtil.getHoursAsSeconds(this.questConfig.redeemTime),
            );
        }

        output.profileChanges[sessionID].quests.push(...this.failedUnlocked(failRequest.qid, sessionID));

        return output;
    }

    /**
     * Get List of All Quests from db
     * NOT CLONED
     * @returns Array of IQuest objects
     */
    public getQuestsFromDb(): IQuest[]
    {
        return Object.values(this.databaseServer.getTables().templates.quests);
    }

    /**
     * Get quest by id from database (repeatables are stored in profile, check there if questId not found)
     * @param questId Id of quest to find
     * @param pmcData Player profile
     * @returns IQuest object
     */
    public getQuestFromDb(questId: string, pmcData: IPmcData): IQuest
    {
        let quest = this.databaseServer.getTables().templates.quests[questId];

        // May be a repeatable quest
        if (!quest)
        {
            // Check daily/weekly objects
            for (const repeatableType of pmcData.RepeatableQuests)
            {
                quest = <IQuest><unknown>repeatableType.activeQuests.find((x) => x._id === questId);
                if (quest)
                {
                    break;
                }
            }
        }

        return quest;
    }

    /**
     * Get a quests startedMessageText key from db, if no startedMessageText key found, use description key instead
     * @param startedMessageTextId startedMessageText property from IQuest
     * @param questDescriptionId description property from IQuest
     * @returns message id
     */
    public getMessageIdForQuestStart(startedMessageTextId: string, questDescriptionId: string): string
    {
        // blank or is a guid, use description instead
        const startedMessageText = this.getQuestLocaleIdFromDb(startedMessageTextId);
        if (
            !startedMessageText || startedMessageText.trim() === "" || startedMessageText.toLowerCase() === "test"
            || startedMessageText.length === 24
        )
        {
            return questDescriptionId;
        }

        return startedMessageTextId;
    }

    /**
     * Get the locale Id from locale db for a quest message
     * @param questMessageId Quest message id to look up
     * @returns Locale Id from locale db
     */
    public getQuestLocaleIdFromDb(questMessageId: string): string
    {
        const locale = this.localeService.getLocaleDb();
        return locale[questMessageId];
    }

    /**
     * Alter a quests state + Add a record to its status timers object
     * @param pmcData Profile to update
     * @param newQuestState New state the quest should be in
     * @param questId Id of the quest to alter the status of
     */
    public updateQuestState(pmcData: IPmcData, newQuestState: QuestStatus, questId: string): void
    {
        // Find quest in profile, update status to desired status
        const questToUpdate = pmcData.Quests.find((quest) => quest.qid === questId);
        if (questToUpdate)
        {
            questToUpdate.status = newQuestState;
            questToUpdate.statusTimers[newQuestState] = this.timeUtil.getTimestamp();
        }
    }

    /**
     * Resets a quests values back to its chosen state
     * @param pmcData Profile to update
     * @param newQuestState New state the quest should be in
     * @param questId Id of the quest to alter the status of
     */
    public resetQuestState(pmcData: IPmcData, newQuestState: QuestStatus, questId: string): void
    {
        const questToUpdate = pmcData.Quests.find((quest) => quest.qid === questId);
        if (questToUpdate)
        {
            const currentTimestamp = this.timeUtil.getTimestamp();

            questToUpdate.status = newQuestState;

            // Only set start time when quest is being started
            if (newQuestState === QuestStatus.Started)
            {
                questToUpdate.startTime = currentTimestamp;
            }

            questToUpdate.statusTimers[newQuestState] = currentTimestamp;

            // Delete all status timers after applying new status
            for (const statusKey in questToUpdate.statusTimers)
            {
                if (Number.parseInt(statusKey) > newQuestState)
                {
                    delete questToUpdate.statusTimers[statusKey];
                }
            }

            // Remove all completed conditions
            questToUpdate.completedConditions = [];
        }
    }

    /**
     * Give player quest rewards - Skills/exp/trader standing/items/assort unlocks - Returns reward items player earned
     * @param profileData Player profile (scav or pmc)
     * @param questId questId of quest to get rewards for
     * @param state State of the quest to get rewards for
     * @param sessionId Session id
     * @param questResponse Response to send back to client
     * @returns Array of reward objects
     */
    public applyQuestReward(
        profileData: IPmcData,
        questId: string,
        state: QuestStatus,
        sessionId: string,
        questResponse: IItemEventRouterResponse,
    ): Item[]
    {
        // Repeatable quest base data is always in PMCProfile, `profileData` may be scav profile
        // TODO: consider moving repeatable quest data to profile-agnostic location
        const pmcProfile = this.profileHelper.getPmcProfile(sessionId);
        let questDetails = this.getQuestFromDb(questId, pmcProfile);
        if (!questDetails)
        {
            this.logger.warning(`Unable to find quest: ${questId} from db, unable to give quest rewards`);

            return [];
        }

        // Check for and apply intel center money bonus if it exists
        const questMoneyRewardBonus = this.getQuestMoneyRewardBonus(pmcProfile);
        if (questMoneyRewardBonus > 0)
        {
            // Apply additional bonus from hideout skill
            questDetails = this.applyMoneyBoost(questDetails, questMoneyRewardBonus, state); // money = money + (money * intelCenterBonus / 100)
        }

        // e.g. 'Success' or 'AvailableForFinish'
        const questStateAsString = QuestStatus[state];
        for (const reward of <IQuestReward[]>questDetails.rewards[questStateAsString])
        {
            switch (reward.type)
            {
                case QuestRewardType.SKILL:
                    this.profileHelper.addSkillPointsToPlayer(
                        profileData,
                        reward.target as SkillTypes,
                        Number(reward.value),
                    );
                    break;
                case QuestRewardType.EXPERIENCE:
                    this.profileHelper.addExperienceToPmc(sessionId, parseInt(<string>reward.value)); // this must occur first as the output object needs to take the modified profile exp value
                    break;
                case QuestRewardType.TRADER_STANDING:
                    this.traderHelper.addStandingToTrader(sessionId, reward.target, parseFloat(<string>reward.value));
                    break;
                case QuestRewardType.TRADER_UNLOCK:
                    this.traderHelper.setTraderUnlockedState(reward.target, true, sessionId);
                    break;
                case QuestRewardType.ITEM:
                    // Handled by getQuestRewardItems() below
                    break;
                case QuestRewardType.ASSORTMENT_UNLOCK:
                    // Handled elsewhere, TODO: find and say here
                    break;
                case QuestRewardType.STASH_ROWS:
                    this.logger.debug("Not implemented stash rows reward yet");
                    break;
                case QuestRewardType.PRODUCTIONS_SCHEME:
                    this.findAndAddHideoutProductionIdToProfile(
                        pmcProfile,
                        reward,
                        questDetails,
                        sessionId,
                        questResponse,
                    );
                    break;
                default:
                    this.logger.error(
                        this.localisationService.getText("quest-reward_type_not_handled", {
                            rewardType: reward.type,
                            questId: questId,
                            questName: questDetails.QuestName,
                        }),
                    );
                    break;
            }
        }

        return this.getQuestRewardItems(questDetails, state);
    }

    /**
     * WIP - Find hideout craft id and add to unlockedProductionRecipe array in player profile
     * also update client response recipeUnlocked array with craft id
     * @param pmcData Player profile
     * @param craftUnlockReward Reward item from quest with craft unlock details
     * @param questDetails Quest with craft unlock reward
     * @param sessionID Session id
     * @param response Response to send back to client
     */
    protected findAndAddHideoutProductionIdToProfile(
        pmcData: IPmcData,
        craftUnlockReward: IQuestReward,
        questDetails: IQuest,
        sessionID: string,
        response: IItemEventRouterResponse,
    ): void
    {
        // Get hideout crafts and find those that match by areatype/required level/end product tpl - hope for just one match
        const hideoutProductions = this.databaseServer.getTables().hideout.production;
        const matchingProductions = hideoutProductions.filter((x) =>
            x.areaType === Number.parseInt(craftUnlockReward.traderId)
            && x.requirements.some((x) => x.requiredLevel === craftUnlockReward.loyaltyLevel)
            && x.endProduct === craftUnlockReward.items[0]._tpl
        );

        // More/less than 1 match, above filtering wasn't strict enough
        if (matchingProductions.length !== 1)
        {
            this.logger.error(
                this.localisationService.getText("quest-unable_to_find_matching_hideout_production", {
                    questName: questDetails.QuestName,
                    matchCount: matchingProductions.length,
                }),
            );

            return;
        }

        // Add above match to pmc profile + client response
        const matchingCraftId = matchingProductions[0]._id;
        pmcData.UnlockedInfo.unlockedProductionRecipe.push(matchingCraftId);
        response.profileChanges[sessionID].recipeUnlocked[matchingCraftId] = true;
    }

    /**
     * Get players money reward bonus from profile
     * @param pmcData player profile
     * @returns bonus as a percent
     */
    protected getQuestMoneyRewardBonus(pmcData: IPmcData): number
    {
        // Check player has intel center
        const moneyRewardBonuses = pmcData.Bonuses.filter((x) => x.type === "QuestMoneyReward");
        if (!moneyRewardBonuses)
        {
            return 0;
        }

        // Get a total of the quest money rewards
        let moneyRewardBonus = moneyRewardBonuses.reduce((acc, cur) => acc + cur.value, 0);

        // Apply hideout management bonus to money reward (up to 51% bonus)
        const hideoutManagementSkill = this.profileHelper.getSkillFromProfile(pmcData, SkillTypes.HIDEOUT_MANAGEMENT);
        if (hideoutManagementSkill)
        {
            moneyRewardBonus *= 1 + (hideoutManagementSkill.Progress / 10000); // 5100 becomes 0.51, add 1 to it, 1.51, multiply the moneyreward bonus by it (e.g. 15 x 51)
        }

        return moneyRewardBonus;
    }

    /**
     * Find quest with 'findItem' condition that needs the item tpl be handed in
     * @param itemTpl item tpl to look for
     * @param questIds Quests to search through for the findItem condition
     * @returns quest id with 'FindItem' condition id
     */
    public getFindItemConditionByQuestItem(
        itemTpl: string,
        questIds: string[],
        allQuests: IQuest[],
    ): Record<string, string>
    {
        const result: Record<string, string> = {};
        for (const questId of questIds)
        {
            const questInDb = allQuests.find((x) => x._id === questId);
            if (!questInDb)
            {
                this.logger.debug(`Unable to find quest: ${questId} in db, cannot get 'FindItem' condition, skipping`);
                continue;
            }

            const condition = questInDb.conditions.AvailableForFinish.find((c) =>
                c.conditionType === "FindItem" && c?.target?.includes(itemTpl)
            );
            if (condition)
            {
                result[questId] = condition.id;

                break;
            }
        }

        return result;
    }

    /**
     * Add all quests to a profile with the provided statuses
     * @param pmcProfile profile to update
     * @param statuses statuses quests should have
     */
    public addAllQuestsToProfile(pmcProfile: IPmcData, statuses: QuestStatus[]): void
    {
        // Iterate over all quests in db
        const quests = this.databaseServer.getTables().templates.quests;
        for (const questKey in quests)
        {
            // Quest from db matches quests in profile, skip
            const questData = quests[questKey];
            if (pmcProfile.Quests.find((x) => x.qid === questData._id))
            {
                continue;
            }

            const statusesDict = {};
            for (const status of statuses)
            {
                statusesDict[status] = this.timeUtil.getTimestamp();
            }

            const questRecordToAdd: IQuestStatus = {
                qid: questKey,
                startTime: this.timeUtil.getTimestamp(),
                status: statuses[statuses.length - 1],
                statusTimers: statusesDict,
                completedConditions: [],
                availableAfter: 0,
            };

            if (pmcProfile.Quests.some((x) => x.qid === questKey))
            {
                // Update existing
                const existingQuest = pmcProfile.Quests.find((x) => x.qid === questKey);
                existingQuest.status = questRecordToAdd.status;
                existingQuest.statusTimers = questRecordToAdd.statusTimers;
            }
            else
            {
                // Add new
                pmcProfile.Quests.push(questRecordToAdd);
            }
        }
    }

    public findAndRemoveQuestFromArrayIfExists(questId: string, quests: IQuestStatus[]): void
    {
        const pmcQuestToReplaceStatus = quests.find((x) => x.qid === questId);
        if (pmcQuestToReplaceStatus)
        {
            quests.splice(quests.indexOf(pmcQuestToReplaceStatus, 1));
        }
    }

    /**
     * Return a list of quests that would fail when supplied quest is completed
     * @param completedQuestId quest completed id
     * @returns array of IQuest objects
     */
    public getQuestsFailedByCompletingQuest(completedQuestId: string): IQuest[]
    {
        const questsInDb = this.getQuestsFromDb();
        return questsInDb.filter((quest) =>
        {
            // No fail conditions, exit early
            if (!quest.conditions.Fail || quest.conditions.Fail.length === 0)
            {
                return false;
            }

            return quest.conditions.Fail.some((condition) => condition.target?.includes(completedQuestId));
        });
    }
}