index.tsx

import { ApplicationCommandInputType, sendBotMessage } from "@api/Commands";
import definePlugin from "@utils/types";
import { findStore, findByProps } from "@webpack";
import { FluxDispatcher, RunningGameStore, Toasts, showToast } from "@webpack/common";

const supportedTasks = ["WATCH_VIDEO", "PLAY_ON_DESKTOP", "STREAM_ON_DESKTOP", "PLAY_ACTIVITY", "WATCH_VIDEO_ON_MOBILE"];
let isRunning = false;

function sleep(ms: number) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// Stores are fetched lazily
let QuestsStore: any;
let ApplicationStreamingStore: any;
let AuthStore: any;

function loadStores() {
    if (QuestsStore && ApplicationStreamingStore && AuthStore) return true;

    try {
        QuestsStore = findByProps("getQuest", "quests") || findByProps("getQuest") || findStore("QuestsStore");
        ApplicationStreamingStore = findByProps("getStreamerActiveStreamMetadata") || findStore("ApplicationStreamingStore");
        AuthStore = findByProps("getToken");

        return !!(QuestsStore && ApplicationStreamingStore && AuthStore);
    } catch (e) {
        console.error("[QuestHelper] Error loading stores:", e);
        return false;
    }
}

async function apiCall(method: string, endpoint: string, body?: any) {
    const token = AuthStore.getToken();
    const url = `https://discord.com/api/v9${endpoint}`;

    const options: RequestInit = {
        method: method,
        headers: {
            "Authorization": token,
            "Content-Type": "application/json",
        },
    };

    if (body) {
        options.body = JSON.stringify(body);
    }

    const res = await fetch(url, options);
    if (!res.ok) {
        throw new Error(`API Error ${res.status}: ${res.statusText}`);
    }

    // safe parsing
    const text = await res.text();
    try {
        return JSON.parse(text);
    } catch {
        return text;
    }
}

async function completeVideoQuest(quest: any, taskName: string, secondsNeeded: number, secondsDone: number) {
    const maxFuture = 10, speed = 7, interval = 1;
    const enrolledAt = new Date(quest.userStatus.enrolledAt).getTime();

    console.log(`[QuestHelper] Video progress: ${secondsDone}/${secondsNeeded}`);

    while (secondsDone < secondsNeeded) {
        if (!isRunning) return;

        const maxAllowed = Math.floor((Date.now() - enrolledAt) / 1000) + maxFuture;
        const diff = maxAllowed - secondsDone;
        const timestamp = secondsDone + speed;

        if (diff >= speed) {
            try {
                const res = await apiCall("POST", `/quests/${quest.id}/video-progress`, {
                    timestamp: Math.min(secondsNeeded, timestamp + Math.random())
                });

                if (res && res.completed_at != null) {
                    console.log(`[QuestHelper] Video quest completed via API Response.`);
                    return;
                }
            } catch (e) {
                console.error("[QuestHelper] API Error", e);
            }
            secondsDone = Math.min(secondsNeeded, timestamp);
            console.log(`[QuestHelper] Video progress updated: ${secondsDone}/${secondsNeeded}`);
        }

        await sleep(interval * 1000);
    }

    try {
        if (isRunning) {
            await apiCall("POST", `/quests/${quest.id}/video-progress`, { timestamp: secondsNeeded });
        }
    } catch (e) { }
}

async function completePlayDesktopQuest(quest: any, applicationId: string, applicationName: string, secondsNeeded: number) {
    return new Promise<void>(async (resolve) => {
        let appData;
        try {
            const res = await apiCall("GET", `/applications/public?application_ids=${applicationId}`);
            if (Array.isArray(res) && res.length > 0) {
                appData = res[0];
            }
        } catch (e) {
            console.error("[QuestHelper] Failed to fetch app data", e);
        }

        if (!appData) {
            console.log(`[QuestHelper] Could not retrieve metadata for ${applicationName}. Using fallback.`);
            appData = { name: applicationName, executables: [{ os: "win32", name: "game.exe" }] };
        }

        const exeName = appData.executables.find((x: any) => x.os === "win32")?.name.replace(">", "") || "game.exe";
        const pid = Math.floor(Math.random() * 30000) + 1000;

        console.log(`[QuestHelper] Mocking game: ${appData.name} (PID: ${pid})`);

        const fakeGame = {
            cmdLine: `C:\\Program Files\\${appData.name}\\${exeName}`,
            exeName,
            exePath: `c:/program files/${appData.name.toLowerCase()}/${exeName}`,
            hidden: false,
            isLauncher: false,
            id: applicationId,
            name: appData.name,
            pid: pid,
            pidPath: [pid],
            processName: appData.name,
            start: Date.now(),
        };

        const realGetRunningGames = RunningGameStore.getRunningGames;
        const realGetGameForPID = RunningGameStore.getGameForPID;
        const realGames = RunningGameStore.getRunningGames();
        const fakeGames = [fakeGame];

        // @ts-ignore
        RunningGameStore.getRunningGames = () => fakeGames;
        // @ts-ignore
        RunningGameStore.getGameForPID = (pid) => fakeGames.find(x => x.pid === pid);

        FluxDispatcher.dispatch({ type: "RUNNING_GAMES_CHANGE", removed: realGames, added: [fakeGame], games: fakeGames });

        const cleanup = () => {
            // @ts-ignore
            RunningGameStore.getRunningGames = realGetRunningGames;
            // @ts-ignore
            RunningGameStore.getGameForPID = realGetGameForPID;
            FluxDispatcher.dispatch({ type: "RUNNING_GAMES_CHANGE", removed: [fakeGame], added: [], games: [] });
            FluxDispatcher.unsubscribe("QUESTS_SEND_HEARTBEAT_SUCCESS", onHeartbeat);
            console.log(`[QuestHelper] Stopped mocking ${applicationName}`);
        };

        const onHeartbeat = (data: any) => {
            if (!isRunning) {
                cleanup();
                resolve();
                return;
            }

            const userStatus = data.userStatus;
            let progress = 0;

            if (quest.config.configVersion === 1) {
                progress = userStatus?.streamProgressSeconds ?? 0;
            } else {
                progress = Math.floor(userStatus?.progress?.PLAY_ON_DESKTOP?.value ?? 0);
            }

            console.log(`[QuestHelper] Heartbeat: ${progress}/${secondsNeeded}s`);

            if (progress >= secondsNeeded) {
                cleanup();
                resolve();
            }
        };

        FluxDispatcher.subscribe("QUESTS_SEND_HEARTBEAT_SUCCESS", onHeartbeat);
        console.log(`[QuestHelper] Listening for heartbeats...`);
    });
}

async function completeStreamDesktopQuest(quest: any, applicationId: string, secondsNeeded: number) {
    return new Promise<void>((resolve) => {
        const pid = Math.floor(Math.random() * 30000) + 1000;
        let realFunc = ApplicationStreamingStore.getStreamerActiveStreamMetadata;

        ApplicationStreamingStore.getStreamerActiveStreamMetadata = () => ({
            id: applicationId,
            pid,
            sourceName: null
        });

        const cleanup = () => {
            ApplicationStreamingStore.getStreamerActiveStreamMetadata = realFunc;
            FluxDispatcher.unsubscribe("QUESTS_SEND_HEARTBEAT_SUCCESS", onHeartbeat);
        };

        const onHeartbeat = (data: any) => {
            if (!isRunning) {
                cleanup();
                resolve();
                return;
            }

            const userStatus = data.userStatus;
            let progress = 0;
            if (quest.config.configVersion === 1) {
                progress = userStatus?.streamProgressSeconds ?? 0;
            } else {
                progress = Math.floor(userStatus?.progress?.STREAM_ON_DESKTOP?.value ?? 0);
            }

            if (progress >= secondsNeeded) {
                cleanup();
                resolve();
            }
        };
        FluxDispatcher.subscribe("QUESTS_SEND_HEARTBEAT_SUCCESS", onHeartbeat);
    });
}

async function runQuests(ctx: any) {
    if (isRunning) {
        showToast("QuestHelper is already running.", Toasts.Type.MESSAGE);
        return;
    }
    isRunning = true;

    if (!loadStores()) {
        const missing = [];
        if (!QuestsStore) missing.push("QuestsStore");
        if (!ApplicationStreamingStore) missing.push("ApplicationStreamingStore");
        if (!AuthStore) missing.push("AuthStore");

        console.error("[QuestHelper] Failed to load stores:", missing);
        showToast(`QuestHelper Error: Missing stores: ${missing.join(", ")}`, Toasts.Type.FAILURE);
        isRunning = false;
        return;
    }

    if (!QuestsStore.quests) {
        console.error("[QuestHelper] QuestsStore found but .quests property is missing!", QuestsStore);
        showToast("QuestHelper Error: Invalid QuestsStore", Toasts.Type.FAILURE);
        isRunning = false;
        return;
    }

    const quests = [...QuestsStore.quests.values()].filter((x: any) =>
        x.userStatus?.enrolledAt &&
        !x.userStatus?.completedAt &&
        new Date(x.config.expiresAt).getTime() > Date.now() &&
        supportedTasks.find(y => Object.keys((x.config.taskConfig ?? x.config.taskConfigV2).tasks).includes(y))
    );

    if (quests.length === 0) {
        showToast("No eligible uncompleted quests found.", Toasts.Type.MESSAGE);
        isRunning = false;
        return;
    }

    sendBotMessage(ctx.channel.id, { content: `Found ${quests.length} quest(s). Execution started...` });
    showToast(`Starting ${quests.length} quest(s)...`, Toasts.Type.MESSAGE);

    for (const quest of quests) {
        if (!isRunning) break;

        const applicationId = quest.config.application.id;
        const applicationName = quest.config.application.name;
        const taskConfig = quest.config.taskConfig ?? quest.config.taskConfigV2;
        const taskName = supportedTasks.find(x => taskConfig.tasks[x] != null) as string;
        const secondsNeeded = taskConfig.tasks[taskName].target;
        let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;

        console.log(`[QuestHelper] Starting ${quest.config.messages.questName} (${taskName})`);

        // Show updated toast message for starting quest
        showToast(`Starting Quest: ${quest.config.messages.questName}`, Toasts.Type.MESSAGE);

        try {
            if (taskName === "WATCH_VIDEO" || taskName === "WATCH_VIDEO_ON_MOBILE") {
                await completeVideoQuest(quest, taskName, secondsNeeded, secondsDone);
            } else if (taskName === "PLAY_ON_DESKTOP") {
                await completePlayDesktopQuest(quest, applicationId, applicationName, secondsNeeded);
            } else if (taskName === "STREAM_ON_DESKTOP") {
                await completeStreamDesktopQuest(quest, applicationId, secondsNeeded);
            } else {
                console.log(`Skipping quest ${quest.config.messages.questName} - Type ${taskName} not fully implemented in plugin yet.`);
            }
        } catch (err) {
            console.error(err);
            showToast(`Quest Failed: ${quest.config.messages.questName}`, Toasts.Type.FAILURE);
        }
        await sleep(2000);
    }

    if (isRunning) {
        showToast("All quests finished!", Toasts.Type.SUCCESS);
        sendBotMessage(ctx.channel.id, { content: "All quests finished!" });
    } else {
        showToast("Quest execution stopped.", Toasts.Type.MESSAGE);
    }
    isRunning = false;
}

export default definePlugin({
    name: "DiscordQuestHelper",
    description: "Automates Discord quests sequentially",
    authors: [{ name: "@DMR3-CODE", id: 0n }],
    commands: [
        {
            name: "quests",
            description: "Manage Discord Quests",
            inputType: ApplicationCommandInputType.BUILT_IN,
            options: [
                {
                    name: "start",
                    description: "Start auto-completing quests",
                    type: 1, // SUB_COMMAND
                    options: []
                },
                {
                    name: "stop",
                    description: "Stop Quest Helper",
                    type: 1, // SUB_COMMAND
                    options: []
                }
            ],
            execute: async (args, ctx) => {
                if (args[0].name === "start") {
                    runQuests(ctx).catch(err => {
                        console.error("[QuestHelper] Fatal", err);
                        showToast("Fatal error in QuestHelper", Toasts.Type.FAILURE);
                        isRunning = false;
                    });
                    return { content: "Quest Helper started..." };
                } else if (args[0].name === "stop") {
                    if (isRunning) {
                        isRunning = false;
                        return { content: "Stopping Quest Helper..." };
                    } else {
                        return { content: "Quest Helper is not running." };
                    }
                }
                return { content: "Invalid subcommand" };
            }
        }
    ]
});