magmastream 2.9.0-dev.2 → 2.9.0-dev.21

package/dist/structures/Manager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagerEventTypes = exports.PlayerStateEventTypes = exports.SearchPlatform = exports.UseNodeOptions = exports.TrackPartial = exports.Manager = void 0;
+exports.ManagerEventTypes = exports.PlayerStateEventTypes = exports.AutoPlayPlatform = exports.SearchPlatform = exports.UseNodeOptions = exports.TrackPartial = exports.StateStorageType = exports.Manager = void 0;
 const tslib_1 = require("tslib");
 const Utils_1 = require("./Utils");
 const collection_1 = require("@discordjs/collection");
@@ -10,6 +10,7 @@ const managerCheck_1 = tslib_1.__importDefault(require("../utils/managerCheck"))
 const blockedWords_1 = require("../config/blockedWords");
 const promises_1 = tslib_1.__importDefault(require("fs/promises"));
 const path_1 = tslib_1.__importDefault(require("path"));
+const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
 /**
  * The main hub for interacting with Lavalink and using Magmastream,
  */
@@ -21,13 +22,14 @@ class Manager extends events_1.EventEmitter {
     /** The options that were set. */
     options;
     initiated = false;
+    redis;
     /**
      * Initiates the Manager class.
      * @param options
      * @param options.enabledPlugins - An array of enabledPlugins to load.
      * @param options.nodes - An array of node options to create nodes from.
      * @param options.playNextOnEnd - Whether to automatically play the first track in the queue when the player is created.
-     * @param options.autoPlaySearchPlatform - The search platform autoplay will use. Fallback to Youtube if not found.
+     * @param options.autoPlaySearchPlatforms - The search platform autoplay will use. Fallback to Youtube if not found.
      * @param options.enablePriorityMode - Whether to use the priority when selecting a node to play on.
      * @param options.clientName - The name of the client to send to Lavalink.
      * @param options.defaultSearchPlatform - The default search platform to use when searching for tracks.
@@ -61,9 +63,9 @@ class Manager extends events_1.EventEmitter {
             enablePriorityMode: false,
             clientName: "Magmastream",
             defaultSearchPlatform: SearchPlatform.YouTube,
-            // autoPlaySearchPlatform: SearchPlatform.YouTube,
             useNode: UseNodeOptions.LeastPlayers,
             maxPreviousTracks: options.maxPreviousTracks ?? 20,
+            stateStorage: { type: StateStorageType.Collection },
             ...options,
         };
         if (this.options.nodes) {
@@ -119,7 +121,7 @@ class Manager extends events_1.EventEmitter {
         this.options.clusterId = clusterId;
         for (const node of this.nodes.values()) {
             try {
-                node.connect(); // Connect the node
+                node.connect();
             }
             catch (err) {
                 this.emit(ManagerEventTypes.NodeError, node, err);
@@ -132,6 +134,15 @@ class Manager extends events_1.EventEmitter {
                 plugin.load(this);
             }
         }
+        if (this.options.stateStorage?.type === StateStorageType.Redis) {
+            const config = this.options.stateStorage.redisConfig;
+            this.redis = new ioredis_1.default({
+                host: config.host,
+                port: Number(config.port),
+                password: config.password,
+                db: config.db ?? 0,
+            });
+        }
         this.initiated = true;
         return this;
     }
@@ -199,6 +210,23 @@ class Manager extends events_1.EventEmitter {
             throw new Error(`An error occurred while searching: ${err}`);
         }
     }
+    /**
+     * Returns a player or undefined if it does not exist.
+     * @param guildId The guild ID of the player to retrieve.
+     * @returns The player if it exists, undefined otherwise.
+     */
+    getPlayer(guildId) {
+        return this.players.get(guildId);
+    }
+    /**
+     * @deprecated - Will be removed with v2.10.0 use {@link getPlayer} instead
+     * Returns a player or undefined if it does not exist.
+     * @param guildId The guild ID of the player to retrieve.
+     * @returns The player if it exists, undefined otherwise.
+     */
+    async get(guildId) {
+        return this.players.get(guildId);
+    }
     /**
      * Creates a player or returns one if it already exists.
      * @param options The options to create the player with.
@@ -212,14 +240,6 @@ class Manager extends events_1.EventEmitter {
         this.emit(ManagerEventTypes.Debug, `[MANAGER] Creating new player with options: ${JSON.stringify(options)}`);
         return new (Utils_1.Structure.get("Player"))(options);
     }
-    /**
-     * Returns a player or undefined if it does not exist.
-     * @param guildId The guild ID of the player to retrieve.
-     * @returns The player if it exists, undefined otherwise.
-     */
-    get(guildId) {
-        return this.players.get(guildId);
-    }
     /**
      * Destroys a player.
      * @param guildId The guild ID of the player to destroy.
@@ -284,7 +304,7 @@ class Manager extends events_1.EventEmitter {
         const update = "d" in data ? data.d : data;
         if (!this.isValidUpdate(update))
             return;
-        const player = this.players.get(update.guild_id);
+        const player = this.getPlayer(update.guild_id);
         if (!player)
             return;
         this.emit(ManagerEventTypes.Debug, `[MANAGER] Updating voice state: ${JSON.stringify(update)}`);
@@ -293,8 +313,9 @@ class Manager extends events_1.EventEmitter {
         }
         if (update.user_id !== this.options.clientId)
             return;
-        if (!player.voiceState.sessionId && player.voiceState.event) {
-            if (player.state !== Utils_1.StateTypes.Disconnected) {
+        const missingSessionButHasEvent = !player.voiceState.sessionId && player.voiceState.event;
+        if (missingSessionButHasEvent) {
+            if (player.state !== Utils_1.StateTypes.Destroying && player.state !== Utils_1.StateTypes.Disconnected) {
                 await player.destroy();
             }
             return;
@@ -337,21 +358,57 @@ class Manager extends events_1.EventEmitter {
      * @param {string} guildId - The guild ID of the player to save
      */
     async savePlayerState(guildId) {
-        try {
-            const playerStateFilePath = await this.getPlayerFilePath(guildId);
-            const player = this.players.get(guildId);
-            if (!player || player.state === Utils_1.StateTypes.Disconnected || !player.voiceChannelId) {
-                console.warn(`Skipping save for inactive player: ${guildId}`);
+        switch (this.options.stateStorage.type) {
+            case StateStorageType.Collection:
+                {
+                    try {
+                        const playerStateFilePath = await this.getPlayerFilePath(guildId);
+                        const player = this.getPlayer(guildId);
+                        if (!player || player.state === Utils_1.StateTypes.Disconnected || !player.voiceChannelId) {
+                            console.warn(`Skipping save for inactive player: ${guildId}`);
+                            return;
+                        }
+                        const serializedPlayer = this.serializePlayer(player);
+                        await promises_1.default.writeFile(playerStateFilePath, JSON.stringify(serializedPlayer, null, 2), "utf-8");
+                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Player state saved: ${guildId}`);
+                    }
+                    catch (error) {
+                        console.error(`Error saving player state for guild ${guildId}:`, error);
+                    }
+                }
+                break;
+            case StateStorageType.Redis:
+                {
+                    try {
+                        const player = this.getPlayer(guildId);
+                        if (!player || player.state === Utils_1.StateTypes.Disconnected || !player.voiceChannelId) {
+                            console.warn(`Skipping save for inactive player: ${guildId}`);
+                            return;
+                        }
+                        const serializedPlayer = this.serializePlayer(player);
+                        const redisKey = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:${guildId}`;
+                        await this.redis.set(redisKey, JSON.stringify(serializedPlayer));
+                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Player state saved to Redis: ${guildId}`);
+                    }
+                    catch (error) {
+                        console.error(`Error saving player state to Redis for guild ${guildId}:`, error);
+                    }
+                }
+                break;
+            default:
                 return;
-            }
-            const serializedPlayer = this.serializePlayer(player);
-            await promises_1.default.writeFile(playerStateFilePath, JSON.stringify(serializedPlayer, null, 2), "utf-8");
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Player state saved: ${guildId}`);
-        }
-        catch (error) {
-            console.error(`Error saving player state for guild ${guildId}:`, error);
         }
     }
+    /**
+     * Sleeps for a specified amount of time.
+     * @param ms The amount of time to sleep in milliseconds.
+     * @returns A promise that resolves after the specified amount of time.
+     */
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
     /**
      * Loads player states from the JSON file.
      * @param nodeId The ID of the node to load player states from.
@@ -363,168 +420,332 @@ class Manager extends events_1.EventEmitter {
         if (!node)
             throw new Error(`Could not find node: ${nodeId}`);
         const info = (await node.rest.getAllPlayers());
-        const playerStatesDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
-        try {
-            // Check if the directory exists, and create it if it doesn't
-            await promises_1.default.access(playerStatesDir).catch(async () => {
-                await promises_1.default.mkdir(playerStatesDir, { recursive: true });
-                this.emit(ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playerStatesDir}`);
-            });
-            // Read the contents of the directory
-            const playerFiles = await promises_1.default.readdir(playerStatesDir);
-            // Process each file in the directory
-            for (const file of playerFiles) {
-                const filePath = path_1.default.join(playerStatesDir, file);
-                try {
-                    // Check if the file exists (though readdir should only return valid files)
-                    await promises_1.default.access(filePath);
-                    // Read the file asynchronously
-                    const data = await promises_1.default.readFile(filePath, "utf-8");
-                    const state = JSON.parse(data);
-                    if (state && typeof state === "object" && state.guildId && state.node.options.identifier === nodeId) {
-                        const lavaPlayer = info.find((player) => player.guildId === state.guildId);
-                        if (!lavaPlayer) {
-                            await this.destroy(state.guildId);
-                        }
-                        const playerOptions = {
-                            guildId: state.options.guildId,
-                            textChannelId: state.options.textChannelId,
-                            voiceChannelId: state.options.voiceChannelId,
-                            selfDeafen: state.options.selfDeafen,
-                            volume: lavaPlayer.volume || state.options.volume,
-                        };
-                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${JSON.stringify(state.options)}`);
-                        const player = this.create(playerOptions);
-                        await player.node.rest.updatePlayer({
-                            guildId: state.options.guildId,
-                            data: { voice: { token: state.voiceState.event.token, endpoint: state.voiceState.event.endpoint, sessionId: state.voiceState.sessionId } },
+        switch (this.options.stateStorage.type) {
+            case StateStorageType.Collection:
+                {
+                    const playerStatesDir = path_1.default.join(process.cwd(), "magmastream", "dist", "sessionData", "players");
+                    try {
+                        // Check if the directory exists, and create it if it doesn't
+                        await promises_1.default.access(playerStatesDir).catch(async () => {
+                            await promises_1.default.mkdir(playerStatesDir, { recursive: true });
+                            this.emit(ManagerEventTypes.Debug, `[MANAGER] Created directory: ${playerStatesDir}`);
                         });
-                        player.connect();
-                        const tracks = [];
-                        const currentTrack = state.queue.current;
-                        const queueTracks = state.queue.tracks;
-                        if (lavaPlayer) {
-                            if (lavaPlayer.track) {
-                                tracks.push(...queueTracks);
-                                if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
-                                    player.queue.current = Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester);
-                                }
-                            }
-                            else {
-                                if (!currentTrack) {
-                                    const payload = {
-                                        reason: Utils_1.TrackEndReasonTypes.Finished,
+                        // Read the contents of the directory
+                        const playerFiles = await promises_1.default.readdir(playerStatesDir);
+                        // Process each file in the directory
+                        for (const file of playerFiles) {
+                            const filePath = path_1.default.join(playerStatesDir, file);
+                            try {
+                                // Check if the file exists (though readdir should only return valid files)
+                                await promises_1.default.access(filePath); // Check if the file exists
+                                const data = await promises_1.default.readFile(filePath, "utf-8");
+                                const state = JSON.parse(data);
+                                if (state && typeof state === "object" && state.guildId && state.node.options.identifier === nodeId) {
+                                    const lavaPlayer = info.find((player) => player.guildId === state.guildId);
+                                    if (!lavaPlayer) {
+                                        await this.destroy(state.guildId);
+                                    }
+                                    const playerOptions = {
+                                        guildId: state.options.guildId,
+                                        textChannelId: state.options.textChannelId,
+                                        voiceChannelId: state.options.voiceChannelId,
+                                        selfDeafen: state.options.selfDeafen,
+                                        volume: lavaPlayer.volume || state.options.volume,
+                                        node: nodeId,
                                     };
-                                    await node.queueEnd(player, currentTrack, payload);
-                                }
-                                else {
-                                    tracks.push(currentTrack, ...queueTracks);
+                                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${JSON.stringify(state.options)}`);
+                                    const player = this.create(playerOptions);
+                                    await player.node.rest.updatePlayer({
+                                        guildId: state.options.guildId,
+                                        data: { voice: { token: state.voiceState.event.token, endpoint: state.voiceState.event.endpoint, sessionId: state.voiceState.sessionId } },
+                                    });
+                                    player.connect();
+                                    const tracks = [];
+                                    const currentTrack = state.queue.current;
+                                    const queueTracks = state.queue.tracks;
+                                    if (lavaPlayer) {
+                                        if (lavaPlayer.track) {
+                                            tracks.push(...queueTracks);
+                                            if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                                await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                            }
+                                        }
+                                        else {
+                                            if (!currentTrack) {
+                                                const payload = {
+                                                    reason: Utils_1.TrackEndReasonTypes.Finished,
+                                                };
+                                                await node.queueEnd(player, currentTrack, payload);
+                                            }
+                                            else {
+                                                tracks.push(currentTrack, ...queueTracks);
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        if (!currentTrack) {
+                                            const payload = {
+                                                reason: Utils_1.TrackEndReasonTypes.Finished,
+                                            };
+                                            await node.queueEnd(player, currentTrack, payload);
+                                        }
+                                        else {
+                                            tracks.push(currentTrack, ...queueTracks);
+                                        }
+                                    }
+                                    if (tracks.length > 0) {
+                                        await player.queue.add(tracks);
+                                    }
+                                    if (state.queue.previous.length > 0) {
+                                        await player.queue.addPrevious(state.queue.previous);
+                                    }
+                                    else {
+                                        await player.queue.clearPrevious();
+                                    }
+                                    if (state.paused) {
+                                        await player.pause(true);
+                                    }
+                                    else {
+                                        player.paused = false;
+                                    }
+                                    if (state.trackRepeat)
+                                        player.setTrackRepeat(true);
+                                    if (state.queueRepeat)
+                                        player.setQueueRepeat(true);
+                                    if (state.dynamicRepeat) {
+                                        player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
+                                    }
+                                    if (state.isAutoplay) {
+                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                    }
+                                    if (state.data) {
+                                        for (const [name, value] of Object.entries(state.data)) {
+                                            player.set(name, value);
+                                        }
+                                    }
+                                    const filterActions = {
+                                        bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
+                                        distort: (enabled) => player.filters.distort(enabled),
+                                        setDistortion: () => player.filters.setDistortion(state.filters.distortion),
+                                        eightD: (enabled) => player.filters.eightD(enabled),
+                                        setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+                                        nightcore: (enabled) => player.filters.nightcore(enabled),
+                                        slowmo: (enabled) => player.filters.slowmo(enabled),
+                                        soft: (enabled) => player.filters.soft(enabled),
+                                        trebleBass: (enabled) => player.filters.trebleBass(enabled),
+                                        setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+                                        tv: (enabled) => player.filters.tv(enabled),
+                                        vibrato: () => player.filters.setVibrato(state.filters.vibrato),
+                                        vaporwave: (enabled) => player.filters.vaporwave(enabled),
+                                        pop: (enabled) => player.filters.pop(enabled),
+                                        party: (enabled) => player.filters.party(enabled),
+                                        earrape: (enabled) => player.filters.earrape(enabled),
+                                        electronic: (enabled) => player.filters.electronic(enabled),
+                                        radio: (enabled) => player.filters.radio(enabled),
+                                        setRotation: () => player.filters.setRotation(state.filters.rotation),
+                                        tremolo: (enabled) => player.filters.tremolo(enabled),
+                                        china: (enabled) => player.filters.china(enabled),
+                                        chipmunk: (enabled) => player.filters.chipmunk(enabled),
+                                        darthvader: (enabled) => player.filters.darthvader(enabled),
+                                        daycore: (enabled) => player.filters.daycore(enabled),
+                                        doubletime: (enabled) => player.filters.doubletime(enabled),
+                                        demon: (enabled) => player.filters.demon(enabled),
+                                    };
+                                    // Iterate through filterStatus and apply the enabled filters
+                                    for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
+                                        if (isEnabled && filterActions[filter]) {
+                                            filterActions[filter](true);
+                                        }
+                                    }
+                                    await this.sleep(1000);
                                 }
                             }
+                            catch (error) {
+                                this.emit(ManagerEventTypes.Debug, `[MANAGER] Error processing file ${filePath}: ${error}`);
+                                continue; // Skip to the next file if there's an error
+                            }
                         }
-                        else {
-                            if (!currentTrack) {
-                                const payload = {
-                                    reason: Utils_1.TrackEndReasonTypes.Finished,
-                                };
-                                await node.queueEnd(player, currentTrack, payload);
+                        // Delete all files inside playerStatesDir where nodeId matches
+                        for (const file of playerFiles) {
+                            const filePath = path_1.default.join(playerStatesDir, file);
+                            try {
+                                await promises_1.default.access(filePath); // Check if the file exists
+                                const data = await promises_1.default.readFile(filePath, "utf-8");
+                                const state = JSON.parse(data);
+                                if (state && typeof state === "object" && state.node.options.identifier === nodeId) {
+                                    await promises_1.default.unlink(filePath); // Delete the file asynchronously
+                                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Deleted player state file: ${filePath}`);
+                                }
                             }
-                            else {
-                                tracks.push(currentTrack, ...queueTracks);
+                            catch (error) {
+                                this.emit(ManagerEventTypes.Debug, `[MANAGER] Error deleting file ${filePath}: ${error}`);
+                                continue; // Skip to the next file if there's an error
                             }
                         }
-                        if (tracks.length > 0) {
-                            player.queue.add(tracks);
-                        }
-                        if (state.queue.previous.length > 0) {
-                            player.queue.previous = state.queue.previous;
-                        }
-                        else {
-                            player.queue.previous = [];
-                        }
-                        if (state.paused) {
-                            await player.pause(true);
-                        }
-                        else {
-                            player.paused = false;
-                        }
-                        if (state.trackRepeat)
-                            player.setTrackRepeat(true);
-                        if (state.queueRepeat)
-                            player.setQueueRepeat(true);
-                        if (state.dynamicRepeat) {
-                            player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
-                        }
-                        if (state.isAutoplay) {
-                            Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
-                            player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
-                        }
-                        if (state.data) {
-                            for (const [name, value] of Object.entries(state.data)) {
-                                player.set(name, value);
+                    }
+                    catch (error) {
+                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${error}`);
+                    }
+                }
+                break;
+            case StateStorageType.Redis:
+                {
+                    try {
+                        // Get all keys matching our pattern
+                        const redisKeyPattern = `${this.options.stateStorage.redisConfig.prefix?.endsWith(":")
+                            ? this.options.stateStorage.redisConfig.prefix
+                            : this.options.stateStorage.redisConfig.prefix ?? "magmastream:"}playerstore:*`;
+                        const keys = await this.redis.keys(redisKeyPattern);
+                        for (const key of keys) {
+                            try {
+                                const data = await this.redis.get(key);
+                                if (!data)
+                                    continue;
+                                const state = JSON.parse(data);
+                                if (!state || typeof state !== "object")
+                                    continue;
+                                const guildId = key.split(":").pop();
+                                if (!guildId)
+                                    continue;
+                                if (state.node?.options?.identifier === nodeId) {
+                                    const lavaPlayer = info.find((player) => player.guildId === guildId);
+                                    if (!lavaPlayer) {
+                                        await this.destroy(guildId);
+                                    }
+                                    const playerOptions = {
+                                        guildId: state.options.guildId,
+                                        textChannelId: state.options.textChannelId,
+                                        voiceChannelId: state.options.voiceChannelId,
+                                        selfDeafen: state.options.selfDeafen,
+                                        volume: lavaPlayer?.volume || state.options.volume,
+                                        node: nodeId,
+                                    };
+                                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${guildId} from Redis`);
+                                    const player = this.create(playerOptions);
+                                    await player.node.rest.updatePlayer({
+                                        guildId: state.options.guildId,
+                                        data: { voice: { token: state.voiceState.event.token, endpoint: state.voiceState.event.endpoint, sessionId: state.voiceState.sessionId } },
+                                    });
+                                    player.connect();
+                                    // Rest of the player state restoration code (tracks, filters, etc.)
+                                    const tracks = [];
+                                    const currentTrack = state.queue.current;
+                                    const queueTracks = state.queue.tracks;
+                                    if (lavaPlayer) {
+                                        if (lavaPlayer.track) {
+                                            tracks.push(...queueTracks);
+                                            if (currentTrack && currentTrack.uri === lavaPlayer.track.info.uri) {
+                                                await player.queue.setCurrent(Utils_1.TrackUtils.build(lavaPlayer.track, currentTrack.requester));
+                                            }
+                                        }
+                                        else {
+                                            if (!currentTrack) {
+                                                const payload = {
+                                                    reason: Utils_1.TrackEndReasonTypes.Finished,
+                                                };
+                                                await node.queueEnd(player, currentTrack, payload);
+                                            }
+                                            else {
+                                                tracks.push(currentTrack, ...queueTracks);
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        if (!currentTrack) {
+                                            const payload = {
+                                                reason: Utils_1.TrackEndReasonTypes.Finished,
+                                            };
+                                            await node.queueEnd(player, currentTrack, payload);
+                                        }
+                                        else {
+                                            tracks.push(currentTrack, ...queueTracks);
+                                        }
+                                    }
+                                    if (tracks.length > 0) {
+                                        await player.queue.add(tracks);
+                                    }
+                                    if (state.queue.previous.length > 0) {
+                                        await player.queue.addPrevious(state.queue.previous);
+                                    }
+                                    else {
+                                        await player.queue.clearPrevious();
+                                    }
+                                    if (state.paused) {
+                                        await player.pause(true);
+                                    }
+                                    else {
+                                        player.paused = false;
+                                    }
+                                    if (state.trackRepeat)
+                                        player.setTrackRepeat(true);
+                                    if (state.queueRepeat)
+                                        player.setQueueRepeat(true);
+                                    if (state.dynamicRepeat) {
+                                        player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
+                                    }
+                                    if (state.isAutoplay) {
+                                        Object.setPrototypeOf(state.data.clientUser, { constructor: { name: "User" } });
+                                        player.setAutoplay(true, state.data.clientUser, state.autoplayTries);
+                                    }
+                                    if (state.data) {
+                                        for (const [name, value] of Object.entries(state.data)) {
+                                            player.set(name, value);
+                                        }
+                                    }
+                                    const filterActions = {
+                                        bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
+                                        distort: (enabled) => player.filters.distort(enabled),
+                                        setDistortion: () => player.filters.setDistortion(state.filters.distortion),
+                                        eightD: (enabled) => player.filters.eightD(enabled),
+                                        setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
+                                        nightcore: (enabled) => player.filters.nightcore(enabled),
+                                        slowmo: (enabled) => player.filters.slowmo(enabled),
+                                        soft: (enabled) => player.filters.soft(enabled),
+                                        trebleBass: (enabled) => player.filters.trebleBass(enabled),
+                                        setTimescale: () => player.filters.setTimescale(state.filters.timescale),
+                                        tv: (enabled) => player.filters.tv(enabled),
+                                        vibrato: () => player.filters.setVibrato(state.filters.vibrato),
+                                        vaporwave: (enabled) => player.filters.vaporwave(enabled),
+                                        pop: (enabled) => player.filters.pop(enabled),
+                                        party: (enabled) => player.filters.party(enabled),
+                                        earrape: (enabled) => player.filters.earrape(enabled),
+                                        electronic: (enabled) => player.filters.electronic(enabled),
+                                        radio: (enabled) => player.filters.radio(enabled),
+                                        setRotation: () => player.filters.setRotation(state.filters.rotation),
+                                        tremolo: (enabled) => player.filters.tremolo(enabled),
+                                        china: (enabled) => player.filters.china(enabled),
+                                        chipmunk: (enabled) => player.filters.chipmunk(enabled),
+                                        darthvader: (enabled) => player.filters.darthvader(enabled),
+                                        daycore: (enabled) => player.filters.daycore(enabled),
+                                        doubletime: (enabled) => player.filters.doubletime(enabled),
+                                        demon: (enabled) => player.filters.demon(enabled),
+                                    };
+                                    // Iterate through filterStatus and apply the enabled filters
+                                    for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
+                                        if (isEnabled && filterActions[filter]) {
+                                            filterActions[filter](true);
+                                        }
+                                    }
+                                    // After processing, delete the Redis key
+                                    await this.redis.del(key);
+                                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Deleted player state from Redis: ${key}`);
+                                    await this.sleep(1000);
+                                }
                             }
-                        }
-                        const filterActions = {
-                            bassboost: () => player.filters.bassBoost(state.filters.bassBoostlevel),
-                            distort: (enabled) => player.filters.distort(enabled),
-                            setDistortion: () => player.filters.setDistortion(state.filters.distortion),
-                            eightD: (enabled) => player.filters.eightD(enabled),
-                            setKaraoke: () => player.filters.setKaraoke(state.filters.karaoke),
-                            nightcore: (enabled) => player.filters.nightcore(enabled),
-                            slowmo: (enabled) => player.filters.slowmo(enabled),
-                            soft: (enabled) => player.filters.soft(enabled),
-                            trebleBass: (enabled) => player.filters.trebleBass(enabled),
-                            setTimescale: () => player.filters.setTimescale(state.filters.timescale),
-                            tv: (enabled) => player.filters.tv(enabled),
-                            vibrato: () => player.filters.setVibrato(state.filters.vibrato),
-                            vaporwave: (enabled) => player.filters.vaporwave(enabled),
-                            pop: (enabled) => player.filters.pop(enabled),
-                            party: (enabled) => player.filters.party(enabled),
-                            earrape: (enabled) => player.filters.earrape(enabled),
-                            electronic: (enabled) => player.filters.electronic(enabled),
-                            radio: (enabled) => player.filters.radio(enabled),
-                            setRotation: () => player.filters.setRotation(state.filters.rotation),
-                            tremolo: (enabled) => player.filters.tremolo(enabled),
-                            china: (enabled) => player.filters.china(enabled),
-                            chipmunk: (enabled) => player.filters.chipmunk(enabled),
-                            darthvader: (enabled) => player.filters.darthvader(enabled),
-                            daycore: (enabled) => player.filters.daycore(enabled),
-                            doubletime: (enabled) => player.filters.doubletime(enabled),
-                            demon: (enabled) => player.filters.demon(enabled),
-                        };
-                        // Iterate through filterStatus and apply the enabled filters
-                        for (const [filter, isEnabled] of Object.entries(state.filters.filterStatus)) {
-                            if (isEnabled && filterActions[filter]) {
-                                filterActions[filter](true);
+                            catch (error) {
+                                this.emit(ManagerEventTypes.Debug, `[MANAGER] Error processing Redis key ${key}: ${error}`);
+                                continue;
                             }
                         }
                     }
-                }
-                catch (error) {
-                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Error processing file ${filePath}: ${error}`);
-                    continue; // Skip to the next file if there's an error
-                }
-            }
-            // Delete all files inside playerStatesDir where nodeId matches
-            for (const file of playerFiles) {
-                const filePath = path_1.default.join(playerStatesDir, file);
-                try {
-                    await promises_1.default.access(filePath); // Check if the file exists
-                    const data = await promises_1.default.readFile(filePath, "utf-8");
-                    const state = JSON.parse(data);
-                    if (state && typeof state === "object" && state.node.options.identifier === nodeId) {
-                        await promises_1.default.unlink(filePath); // Delete the file asynchronously
-                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Deleted player state file: ${filePath}`);
+                    catch (error) {
+                        this.emit(ManagerEventTypes.Debug, `[MANAGER] Error loading player states from Redis: ${error}`);
                     }
                 }
-                catch (error) {
-                    this.emit(ManagerEventTypes.Debug, `[MANAGER] Error deleting file ${filePath}: ${error}`);
-                    continue; // Skip to the next file if there's an error
-                }
-            }
-        }
-        catch (error) {
-            this.emit(ManagerEventTypes.Debug, `[MANAGER] Error loading player states: ${error}`);
+                break;
+            default:
+                break;
         }
         this.emit(ManagerEventTypes.Debug, "[MANAGER] Finished loading saved players.");
     }
@@ -751,6 +972,8 @@ class Manager extends events_1.EventEmitter {
                 return null;
             }
             if (key === "filters") {
+                if (!value || typeof value !== "object")
+                    return null;
                 return {
                     distortion: value.distortion ?? null,
                     equalizer: value.equalizer ?? [],
@@ -761,19 +984,19 @@ class Manager extends events_1.EventEmitter {
                     reverb: value.reverb ?? null,
                     volume: value.volume ?? 1.0,
                     bassBoostlevel: value.bassBoostlevel ?? null,
-                    filterStatus: { ...value.filtersStatus },
+                    filterStatus: value.filtersStatus ? { ...value.filtersStatus } : {},
                 };
             }
             if (key === "queue") {
                 return {
                     current: value.current || null,
-                    tracks: [...value],
-                    previous: [...value.previous],
+                    tracks: Array.isArray(value) ? [...value] : [],
+                    previous: Array.isArray(value.previous) ? [...value.previous] : [],
                 };
             }
             if (key === "data") {
                 return {
-                    clientUser: value.Internal_BotUser ?? null,
+                    clientUser: value?.Internal_BotUser ?? null,
                 };
             }
             return serialize(value);
@@ -873,6 +1096,11 @@ class Manager extends events_1.EventEmitter {
     }
 }
 exports.Manager = Manager;
+var StateStorageType;
+(function (StateStorageType) {
+    StateStorageType["Collection"] = "collection";
+    StateStorageType["Redis"] = "redis";
+})(StateStorageType || (exports.StateStorageType = StateStorageType = {}));
 var TrackPartial;
 (function (TrackPartial) {
     /** The base64 encoded string of the track */
@@ -917,6 +1145,7 @@ var SearchPlatform;
     SearchPlatform["Bandcamp"] = "bcsearch";
     SearchPlatform["Deezer"] = "dzsearch";
     SearchPlatform["Jiosaavn"] = "jssearch";
+    SearchPlatform["Qobuz"] = "qbsearch";
     SearchPlatform["SoundCloud"] = "scsearch";
     SearchPlatform["Spotify"] = "spsearch";
     SearchPlatform["Tidal"] = "tdsearch";
@@ -924,6 +1153,16 @@ var SearchPlatform;
     SearchPlatform["YouTube"] = "ytsearch";
     SearchPlatform["YouTubeMusic"] = "ytmsearch";
 })(SearchPlatform || (exports.SearchPlatform = SearchPlatform = {}));
+var AutoPlayPlatform;
+(function (AutoPlayPlatform) {
+    AutoPlayPlatform["Spotify"] = "spotify";
+    AutoPlayPlatform["Deezer"] = "deezer";
+    AutoPlayPlatform["SoundCloud"] = "soundcloud";
+    AutoPlayPlatform["Tidal"] = "tidal";
+    AutoPlayPlatform["VKMusic"] = "vkmusic";
+    AutoPlayPlatform["Qobuz"] = "qobuz";
+    AutoPlayPlatform["YouTube"] = "youtube";
+})(AutoPlayPlatform || (exports.AutoPlayPlatform = AutoPlayPlatform = {}));
 var PlayerStateEventTypes;
 (function (PlayerStateEventTypes) {
     PlayerStateEventTypes["AutoPlayChange"] = "playerAutoplay";
@@ -963,3 +1202,4 @@ var ManagerEventTypes;
     ManagerEventTypes["ChapterStarted"] = "chapterStarted";
     ManagerEventTypes["ChaptersLoaded"] = "chaptersLoaded";
 })(ManagerEventTypes || (exports.ManagerEventTypes = ManagerEventTypes = {}));
+// PlayerStore WILL BE REMOVED IF YOU DONT FIND A USE FOR IT.