import { WorldState } from "@/src/models/worldStateModel";
import { unixTimesInMs } from "@/src/constants/timeConstants";
import {
    IActiveChallenge,
    IActiveMission,
    IJob,
    ILiteSortie,
    ISortie,
    ISyndicateMission,
    IVoidStorm,
    IWorldStateDocument
} from "@/src/types/worldStateTypes";
import { getRandomNodes, getCurrentRotation, getRandomRotation } from "@/src/helpers/worldstateHelpers";
import { ExportRegions, ExportNightwave } from "warframe-public-export-plus";
import { logger } from "@/src/utils/logger";
import {
    factionSyndicates,
    neutralJobsSyndicates,
    neutralSyndicates,
    restSyndicates,
    CertusNormalJobs,
    CertusNarmerJobs,
    EntratiNormalJobs,
    missionIndexToMissionTypes,
    validFissureMissionIndex,
    omniaNodes,
    endStates,
    modifierTypes,
    voidTiers,
    FortunaNarmerJobs,
    FortunaNormalJobs,
    liteSortiesMissionIndex,
    EntratiEndlessJobs,
    normalCircuitRotations,
    hardCircuitRotations,
    liteSortiesBosses
} from "@/src/constants/worldStateConstants";

export const createWorldState = () => {
    let ws = new WorldState() as IWorldStateDocument;
    ws = updateSyndicateMissions(ws);
    ws = updateVoidFissures(ws);
    ws = updateSorties(ws);
    ws = updateCircuit(ws);
    ws = updateNightWave(ws);
    ws = updateNodeOverrides(ws);
    return ws;
};

export const getWorldState = async () => {
    let ws = await WorldState.findOne();
    if (!ws) {
        ws = createWorldState();
    }
    return ws as IWorldStateDocument;
};

export const worldStateRunner = async () => {
    await getWorldState();
    setInterval(async () => {
        try {
            logger.info("Update worldState");
            let ws = await getWorldState();
            ws = updateSyndicateMissions(ws);
            ws = updateVoidFissures(ws);
            ws = updateSorties(ws);
            ws = updateCircuit(ws);
            ws = updateNightWave(ws);
            ws = updateNodeOverrides(ws);
            await ws.save();
        } catch (error) {
            logger.error("Failed to update worldState:", error);
        }
    }, unixTimesInMs.minute);
};

const updateSyndicateMissions = (ws: IWorldStateDocument) => {
    const currentDate = Date.now();
    const oneDayIntervalStart =
        Math.floor(currentDate / unixTimesInMs.day) * unixTimesInMs.day + 16 * unixTimesInMs.hour;
    const oneDayIntervalEnd = oneDayIntervalStart + unixTimesInMs.day;

    const neutralJobsIntervalStart = Math.floor(currentDate / (2.5 * unixTimesInMs.hour)) * (2.5 * unixTimesInMs.hour);
    const neutralJobsIntervalEnd = neutralJobsIntervalStart + 2.5 * unixTimesInMs.hour;

    const neutralSeed = Math.floor(Math.random() * 99999 + 1);

    try {
        const syndicateArray = ws.SyndicateMissions || [];

        const existingTags = syndicateArray.map(syndicate => syndicate.Tag);

        const createNewSyndicateEntry = (tag: string): ISyndicateMission => {
            switch (true) {
                case factionSyndicates.includes(tag):
                    return {
                        Tag: tag,
                        Seed: Math.floor(Math.random() * 99999 + 1),
                        Nodes: getRandomNodes(7),
                        Activation: oneDayIntervalStart,
                        Expiry: oneDayIntervalEnd
                    };
                case neutralJobsSyndicates.includes(tag):
                    return {
                        Tag: tag,
                        Seed: neutralSeed,
                        Nodes: [],
                        Activation: neutralJobsIntervalStart,
                        Expiry: neutralJobsIntervalEnd,
                        Jobs: getJobs(tag)
                    };
                case neutralSyndicates.includes(tag):
                    return {
                        Tag: tag,
                        Seed: neutralSeed,
                        Nodes: [],
                        Activation: neutralJobsIntervalStart,
                        Expiry: neutralJobsIntervalEnd
                    };
                case restSyndicates.includes(tag):
                    return {
                        Tag: tag,
                        Seed: Math.floor(Math.random() * 99999 + 1),
                        Nodes: [],
                        Activation: oneDayIntervalStart,
                        Expiry: oneDayIntervalEnd
                    };
                default:
                    throw new Error(`Unhandled syndicate tag: ${tag}`);
            }
        };

        [...factionSyndicates, ...neutralJobsSyndicates, ...neutralSyndicates, ...restSyndicates].forEach(tag => {
            if (!existingTags.includes(tag)) {
                syndicateArray.push(createNewSyndicateEntry(tag));
            } else {
                const syndicateIndex = existingTags.indexOf(tag);
                const shouldUpdate = currentDate >= syndicateArray[syndicateIndex].Expiry;

                if (shouldUpdate) {
                    syndicateArray[syndicateIndex] = {
                        ...syndicateArray[syndicateIndex],
                        Tag: tag,
                        Seed:
                            neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
                                ? neutralSeed
                                : Math.floor(Math.random() * 99999 + 1),
                        Nodes:
                            neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
                                ? []
                                : getRandomNodes(7),
                        Activation:
                            neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
                                ? neutralJobsIntervalStart
                                : oneDayIntervalStart,
                        Expiry:
                            neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
                                ? neutralJobsIntervalEnd
                                : oneDayIntervalEnd,
                        Jobs: neutralJobsSyndicates.includes(tag) ? getJobs(tag) : undefined
                    };
                }
            }
        });

        ws.SyndicateMissions = syndicateArray;

        return ws;
    } catch (error) {
        throw new Error(`Error while updating Syndicates ${error}`);
    }
};

const getJobs = (tag: string): IJob[] => {
    const rotation = getCurrentRotation();
    switch (tag) {
        case "CetusSyndicate":
            return [
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierATable${rotation}Rewards`,
                    masteryReq: 0,
                    minEnemyLevel: 5,
                    maxEnemyLevel: 15,
                    xpAmounts: [410, 410, 410]
                },
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierBTable${rotation}Rewards`,
                    masteryReq: 1,
                    minEnemyLevel: 10,
                    maxEnemyLevel: 30,
                    xpAmounts: [750, 750, 750]
                },
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierCTable${rotation}Rewards`,
                    masteryReq: 2,
                    minEnemyLevel: 20,
                    maxEnemyLevel: 40,
                    xpAmounts: [580, 580, 580, 850]
                },
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierDTable${rotation}Rewards`,
                    masteryReq: 3,
                    minEnemyLevel: 30,
                    maxEnemyLevel: 50,
                    xpAmounts: [580, 580, 580, 580, 1130]
                },
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierETable${rotation}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 40,
                    maxEnemyLevel: 60,
                    xpAmounts: [710, 710, 710, 710, 1390]
                },
                {
                    jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierETable${rotation}Rewards`,
                    masteryReq: 10,
                    minEnemyLevel: 100,
                    maxEnemyLevel: 100,
                    xpAmounts: [840, 840, 840, 840, 1660]
                },
                {
                    jobType: CertusNarmerJobs[Math.floor(Math.random() * CertusNarmerJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/NarmerTable${rotation}Rewards`,
                    masteryReq: 0,
                    minEnemyLevel: 50,
                    maxEnemyLevel: 70,
                    xpAmounts: [820, 820, 820, 820, 1610]
                }
            ];

        case "SolarisSyndicate":
            return [
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierATable${rotation}Rewards`,
                    masteryReq: 0,
                    minEnemyLevel: 5,
                    maxEnemyLevel: 15,
                    xpAmounts: [410, 410, 410]
                },
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierBTable${rotation}Rewards`,
                    masteryReq: 1,
                    minEnemyLevel: 10,
                    maxEnemyLevel: 30,
                    xpAmounts: [750, 750, 750]
                },
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierCTable${rotation}Rewards`,
                    masteryReq: 2,
                    minEnemyLevel: 20,
                    maxEnemyLevel: 40,
                    xpAmounts: [580, 580, 580, 850]
                },
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierDTable${rotation}Rewards`,
                    masteryReq: 3,
                    minEnemyLevel: 30,
                    maxEnemyLevel: 50,
                    xpAmounts: [580, 580, 580, 580, 1130]
                },
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierETable${rotation}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 40,
                    maxEnemyLevel: 60,
                    xpAmounts: [710, 710, 710, 710, 1390]
                },
                {
                    jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierETable${rotation}Rewards`,
                    masteryReq: 10,
                    minEnemyLevel: 100,
                    maxEnemyLevel: 100,
                    xpAmounts: [840, 840, 840, 840, 1660]
                },
                {
                    jobType: FortunaNarmerJobs[Math.floor(Math.random() * FortunaNarmerJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusNarmerTable${rotation}Rewards`,
                    masteryReq: 0,
                    minEnemyLevel: 50,
                    maxEnemyLevel: 70,
                    xpAmounts: [820, 820, 820, 820, 1610]
                }
            ];

        case "EntratiSyndicate":
            return [
                {
                    jobType: EntratiNormalJobs[Math.floor(Math.random() * EntratiNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierATable${getRandomRotation()}Rewards`,
                    masteryReq: 0,
                    minEnemyLevel: 5,
                    maxEnemyLevel: 15,
                    xpAmounts: [5, 5, 5]
                },
                {
                    jobType: EntratiNormalJobs[Math.floor(Math.random() * EntratiNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierCTable${getRandomRotation()}Rewards`,
                    masteryReq: 1,
                    minEnemyLevel: 15,
                    maxEnemyLevel: 25,
                    xpAmounts: [9, 9, 9]
                },
                {
                    jobType: EntratiEndlessJobs[Math.floor(Math.random() * EntratiEndlessJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierBTable${getRandomRotation()}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 25,
                    maxEnemyLevel: 30,
                    endless: true,
                    xpAmounts: [14, 14, 14]
                },
                {
                    jobType: EntratiNormalJobs[Math.floor(Math.random() * EntratiNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierDTable${getRandomRotation()}Rewards`,
                    masteryReq: 2,
                    minEnemyLevel: 30,
                    maxEnemyLevel: 40,
                    xpAmounts: [19, 19, 19, 29]
                },
                {
                    jobType: EntratiNormalJobs[Math.floor(Math.random() * EntratiNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierETable${getRandomRotation()}Rewards`,
                    masteryReq: 3,
                    minEnemyLevel: 40,
                    maxEnemyLevel: 60,
                    xpAmounts: [21, 21, 21, 21, 41]
                },
                {
                    jobType: EntratiNormalJobs[Math.floor(Math.random() * EntratiNormalJobs.length)],
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierETable${getRandomRotation()}Rewards`,
                    masteryReq: 10,
                    minEnemyLevel: 100,
                    maxEnemyLevel: 100,
                    xpAmounts: [25, 25, 25, 25, 50]
                },
                {
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierATable${getCurrentRotation()}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 30,
                    maxEnemyLevel: 40,
                    xpAmounts: [2, 2, 2, 4],
                    locationTag: "ChamberB",
                    isVault: true
                },
                {
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierBTable${getCurrentRotation()}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 40,
                    maxEnemyLevel: 50,
                    xpAmounts: [4, 4, 4, 5],
                    locationTag: "ChamberA",
                    isVault: true
                },
                {
                    rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierCTable${getCurrentRotation()}Rewards`,
                    masteryReq: 5,
                    minEnemyLevel: 50,
                    maxEnemyLevel: 60,
                    xpAmounts: [5, 5, 5, 7],
                    locationTag: "ChamberC",
                    isVault: true
                }
            ];

        default:
            throw new Error(`Error while updating Syndicates: Unknown Jobs syndicate ${tag}`);
    }
};

const updateVoidFissures = (ws: IWorldStateDocument) => {
    const curDate = Date.now();
    try {
        const voidFissures = ws.ActiveMissions;
        const voidStorms = ws.VoidStorms;
        const voidFissuresByTier: { [key: string]: IActiveMission[] } = {
            VoidT1: [],
            VoidT2: [],
            VoidT3: [],
            VoidT4: [],
            VoidT5: [],
            VoidT6: []
        };
        const voidStormsByTier: { [key: string]: IVoidStorm[] } = {
            VoidT1: [],
            VoidT2: [],
            VoidT3: [],
            VoidT4: [],
            VoidT5: [],
            VoidT6: []
        };

        if (voidFissures) {
            voidFissures.forEach(mission => {
                const tier = mission.Modifier;
                if (tier) {
                    if (!voidFissuresByTier[tier]) {
                        voidFissuresByTier[tier] = [];
                    }
                    voidFissuresByTier[tier].push(mission);
                }
            });
        }

        if (voidStorms) {
            voidStorms.forEach(mission => {
                const tier = mission.ActiveMissionTier;
                if (tier) {
                    if (!voidStormsByTier[tier]) {
                        voidStormsByTier[tier] = [];
                    }
                    voidStormsByTier[tier].push(mission);
                }
            });
        }

        voidTiers.forEach(voidTier => {
            if (voidFissuresByTier[voidTier].length < 3) {
                const nodeData = getRandomFissureNode(false, voidTier == "VoidT6");
                if (!nodeData.missionIndex) nodeData.missionIndex = 1;
                const node = {
                    Region: nodeData.systemIndex,
                    Seed: Math.floor(Math.random() * 99999 + 1),
                    Activation: curDate,
                    Expiry: curDate + Math.floor(Math.random() * unixTimesInMs.hour),
                    Node: nodeData.nodeKey,
                    MissionType: missionIndexToMissionTypes[nodeData.missionIndex],
                    Modifier: voidTier,
                    Hard: Math.random() < 0.1
                } as IActiveMission;
                voidFissures?.push(node);
            }

            if (voidStormsByTier[voidTier].length < 2) {
                const nodeData = getRandomFissureNode(true, voidTier == "VoidT6");
                const node = {
                    Activation: curDate,
                    Expiry: curDate + Math.floor(Math.random() * unixTimesInMs.hour),
                    Node: nodeData.nodeKey,
                    ActiveMissionTier: voidTier
                } as IVoidStorm;
                voidStorms?.push(node);
            }
        });
        return ws;
    } catch (error) {
        throw new Error(`Error while updating VoidFissures: ${error}`);
    }
};

const getRandomFissureNode = (isRailJack: boolean, isOmnia: boolean) => {
    const validNodes = Object.entries(ExportRegions)
        .map(([key, node]) => ({ ...node, nodeKey: key }))
        .filter(node => {
            if (node.missionIndex && node.missionName) {
                return (
                    validFissureMissionIndex.includes(node.missionIndex) &&
                    (!node.missionName.includes("Archwing") || !node.missionName.includes("Railjack"))
                );
            } else return false;
        });

    if (isRailJack) {
        const railJackNodes = Object.keys(ExportRegions).filter(key => key.includes("CrewBattleNode"));
        const randomKey = railJackNodes[Math.floor(Math.random() * railJackNodes.length)];
        return { nodeKey: randomKey };
    }

    if (isOmnia) {
        const validOmniaNodes = validNodes.filter(node => omniaNodes.includes(node.nodeKey));
        const randomNode = validOmniaNodes[Math.floor(Math.random() * validOmniaNodes.length)];
        return {
            nodeKey: randomNode.nodeKey,
            systemIndex: randomNode.systemIndex,
            missionIndex: randomNode.missionIndex
        };
    }

    const randomNode = validNodes[Math.floor(Math.random() * validNodes.length)];
    return {
        nodeKey: randomNode.nodeKey,
        systemIndex: randomNode.systemIndex,
        missionIndex: randomNode.missionIndex
    };
};

const updateSorties = (ws: IWorldStateDocument) => {
    const currentDate = Date.now();
    const oneDayIntervalStart =
        Math.floor(currentDate / unixTimesInMs.day) * unixTimesInMs.day + 16 * unixTimesInMs.hour;
    const oneDayIntervalEnd = oneDayIntervalStart + unixTimesInMs.day;
    const oneWeekIntervalStart =
        Math.floor(currentDate / unixTimesInMs.week) * unixTimesInMs.week + 16 * unixTimesInMs.hour;
    const oneWeekIntervalEnd = oneWeekIntervalStart + unixTimesInMs.week;

    type node = {
        systemIndex: number;
        missionIndex: number;
        nodeKey: string;
    };

    const nodes = Object.entries(ExportRegions).map(([key, node]) => {
        return {
            systemIndex: node.systemIndex,
            missionIndex: node.missionIndex,
            nodeKey: key
        } as node;
    });

    try {
        const liteSorties: ILiteSortie[] = ws?.LiteSorties;
        const sorties: ISortie[] = ws?.Sorties;

        [...liteSorties, ...sorties].forEach((sortie, index, array) => {
            if (currentDate >= sortie.Expiry) array.splice(index, 1);
        });

        if (liteSorties.length < 1) {
            const liteSortiesBoss = liteSortiesBosses[Math.floor(Math.random() * liteSortiesBosses.length)];

            const liteSortiesSystemIndex = nodes.filter(node => {
                switch (liteSortiesBoss) {
                    case "SORTIE_BOSS_AMAR":
                        return node.systemIndex === 3;
                    case "SORTIE_BOSS_NIRA":
                        return node.systemIndex === 4;
                    case "SORTIE_BOSS_PAAZUL":
                        return node.systemIndex === 0;
                    default:
                        throw new Error(`Unknown liteSortiesBoss: ${liteSortiesBoss}`);
                }
            });

            const filteredLiteSortiesNodes = liteSortiesMissionIndex.map(missionIndexArray =>
                liteSortiesSystemIndex.filter(node => missionIndexArray.includes(node.missionIndex))
            );

            const selectedLiteSortiesNodes = filteredLiteSortiesNodes.map(
                filteredNodes => filteredNodes[Math.floor(Math.random() * filteredNodes.length)]
            );

            const sortie = {
                Activation: oneWeekIntervalStart,
                Expiry: oneWeekIntervalEnd,
                Reward: "/Lotus/Types/Game/MissionDecks/ArchonSortieRewards",
                Seed: Math.floor(Math.random() * 99999 + 1),
                Boss: liteSortiesBoss,
                Missions: selectedLiteSortiesNodes.map(node => ({
                    missionType: missionIndexToMissionTypes[node.missionIndex],
                    node: node.nodeKey
                }))
            };

            liteSorties.push(sortie);
        }

        if (sorties.length < 1) {
            const randomState = endStates[Math.floor(Math.random() * endStates.length)];
            const selectedSortieNodes = Array.from({ length: 3 }, () => {
                const randomIndex = Math.floor(Math.random() * randomState.regions.length);
                const filteredNodes = nodes.filter(
                    node =>
                        randomState.regions[randomIndex].systemIndex === node.systemIndex &&
                        randomState.regions[randomIndex].missionIndex.includes(node.missionIndex)
                );
                return filteredNodes[Math.floor(Math.random() * filteredNodes.length)];
            });

            const sortie: ISortie = {
                Activation: oneDayIntervalStart,
                Expiry: oneDayIntervalEnd,
                ExtraDrops: [],
                Reward: "/Lotus/Types/Game/MissionDecks/SortieRewards",
                Seed: Math.floor(Math.random() * 99999 + 1),
                Boss: randomState.bossName,
                Variants: selectedSortieNodes.map(node => ({
                    missionType: missionIndexToMissionTypes[node.missionIndex],
                    modifierType: modifierTypes[Math.floor(Math.random() * modifierTypes.length)],
                    node: node.nodeKey,
                    tileset: "CorpusShipTileset" // needs more info about tilesets used in nodes
                })),
                Twitter: true
            };
            sorties.push(sortie);
        }

        return ws;
    } catch (error) {
        throw new Error(`Error while updating Sorties ${error}`);
    }
};

const updateCircuit = (ws: IWorldStateDocument) => {
    try {
        const curWeek = Math.floor(Date.now() / unixTimesInMs.week);
        const normalIndex = curWeek % normalCircuitRotations.length;
        const hardIndex = curWeek % hardCircuitRotations.length;
        ws.EndlessXpChoices = [
            { Category: "EXC_NORMAL", Choices: normalCircuitRotations[normalIndex] },
            { Category: "EXC_HARD", Choices: hardCircuitRotations[hardIndex] }
        ];
        return ws;
    } catch (error) {
        throw new Error(`Error while updating Circuit ${error}`);
    }
};

const updateNightWave = (ws: IWorldStateDocument) => {
    const currentDate = Date.now();
    const oneDayIntervalStart =
        Math.floor(currentDate / unixTimesInMs.day) * unixTimesInMs.day + 16 * unixTimesInMs.hour;
    const oneDayIntervalEnd = oneDayIntervalStart + unixTimesInMs.day;
    const oneWeekIntervalStart =
        Math.floor(currentDate / unixTimesInMs.week) * unixTimesInMs.week + 16 * unixTimesInMs.hour;
    const oneWeekIntervalEnd = oneWeekIntervalStart + unixTimesInMs.week;

    try {
        let season = ws.SeasonInfo;
        if (!season)
            season = {
                Activation: 1715796000000,
                Expiry: 9999999999999,
                AffiliationTag: "RadioLegionIntermission10Syndicate",
                Season: 12,
                Phase: 0,
                Params: "",
                ActiveChallenges: [],
                UsedChallenges: []
            };
        const activeChallenges = season.ActiveChallenges.filter(challenge => currentDate < challenge.Expiry);
        const usedChallenges = season.UsedChallenges;

        const exportChallenges = Object.keys(ExportNightwave.challenges);
        const filterChallenges = (prefix: string): string[] =>
            exportChallenges.filter(challenge => challenge.startsWith(prefix));

        const dailyChallenges = filterChallenges("/Lotus/Types/Challenges/Seasons/Daily/");
        const weeklyChallenges = filterChallenges("/Lotus/Types/Challenges/Seasons/Weekly/");
        const weeklyHardChallenges = filterChallenges("/Lotus/Types/Challenges/Seasons/WeeklyHard/");

        let dailyCount = 0,
            weeklyCount = 0,
            weeklyHardCount = 0;

        activeChallenges.forEach(challenge => {
            if (challenge.Challenge.startsWith("/Lotus/Types/Challenges/Seasons/Daily/")) dailyCount++;
            else if (challenge.Challenge.startsWith("/Lotus/Types/Challenges/Seasons/Weekly/")) weeklyCount++;
            else if (challenge.Challenge.startsWith("/Lotus/Types/Challenges/Seasons/WeeklyHard/")) weeklyHardCount++;
        });

        const addChallenges = (
            count: number,
            limit: number,
            intervalStart: number,
            intervalEnd: number,
            challengesArray: string[],
            isDaily = false
        ) => {
            while (count < limit) {
                challengesArray = challengesArray.filter(challenge => !usedChallenges.includes(challenge));
                const uniqueName = challengesArray[Math.floor(Math.random() * challengesArray.length)];
                const challenge: IActiveChallenge = {
                    Activation: intervalStart,
                    Expiry: intervalEnd,
                    Challenge: uniqueName
                };
                if (isDaily) {
                    challenge.Daily = true;
                } else {
                    usedChallenges.push(uniqueName);
                }
                activeChallenges.push(challenge);
                count++;
            }
        };

        addChallenges(dailyCount, 3, oneDayIntervalStart, oneDayIntervalEnd, dailyChallenges, true);
        addChallenges(weeklyCount, 5, oneWeekIntervalStart, oneWeekIntervalEnd, weeklyChallenges);
        addChallenges(weeklyHardCount, 2, oneWeekIntervalStart, oneWeekIntervalEnd, weeklyHardChallenges);

        season = {
            Activation: season.Activation || 1715796000000,
            Expiry: season.Expiry || 9999999999999,
            AffiliationTag: season.AffiliationTag || "RadioLegionIntermission10Syndicate",
            Season: season.Season || 12,
            Phase: season.Phase || 0,
            Params: season.Params || "",
            ActiveChallenges: activeChallenges,
            UsedChallenges: usedChallenges
        };

        ws.SeasonInfo = season;
        return ws;
    } catch (error) {
        throw new Error(`Error while updating NightWave ${error}`);
    }
};

const updateNodeOverrides = (ws: IWorldStateDocument) => {
    try {
        const curWeek = Math.floor(Date.now() / unixTimesInMs.week);
        let overrides = ws.NodeOverrides;
        if (overrides == undefined || overrides.length < 1) {
            overrides = [
                { Node: "EuropaHUB", Hide: true },
                { Node: "ErisHUB", Hide: true },
                { Node: "VenusHUB", Hide: true },
                { Node: "SolNode802", Seed: curWeek }, // Elite sanctuary onslaught
                {
                    Node: "EarthHUB",
                    Hide: false,
                    LevelOverride: "/Lotus/Levels/Proc/Hub/RelayStationHubTwoB"
                },
                {
                    Node: "MercuryHUB",
                    Hide: true,
                    LevelOverride: "/Lotus/Levels/Proc/Hub/RelayStationHubHydroid"
                }
            ];
        } else {
            const solNodeIndex = overrides.findIndex(node => node.Node === "SolNode802");

            if (solNodeIndex !== -1) {
                if (overrides[solNodeIndex].Seed !== curWeek) overrides[solNodeIndex].Seed = curWeek;
            } else {
                overrides.push({ Node: "SolNode802", Seed: curWeek });
            }
        }
        ws.NodeOverrides = overrides;
        return ws;
    } catch (error) {
        throw new Error(`Error while updating NodeOverrides ${error}`);
    }
};