ziplayer 0.2.7-dev.3 → 0.3.0

package/dist/structures/PersistenceManager.js

@@ -0,0 +1,1008 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistenceManager = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const zlib = __importStar(require("zlib"));
+const util_1 = require("util");
+const gzip = (0, util_1.promisify)(zlib.gzip);
+const gunzip = (0, util_1.promisify)(zlib.gunzip);
+// File provider implementation with enhanced backup management
+class FileProvider {
+    constructor(basePath, options = {}) {
+        this.basePath = basePath;
+        this.maxBackups = options.maxBackups ?? 5;
+        this.maxTotalBackups = options.maxTotalBackups ?? 50;
+        this.backupRetentionDays = options.backupRetentionDays ?? 7;
+        if (!fs.existsSync(basePath)) {
+            fs.mkdirSync(basePath, { recursive: true });
+        }
+    }
+    getFilePath(key) {
+        return path.join(this.basePath, `${key}.json`);
+    }
+    getBackupPath(key, timestamp) {
+        return path.join(this.basePath, `${key}_backup_${timestamp}.json`);
+    }
+    getAllBackups() {
+        const files = fs.readdirSync(this.basePath);
+        const backups = [];
+        for (const file of files) {
+            const match = file.match(/^(.+)_backup_(\d+)\.json(\.gz)?$/);
+            if (match) {
+                const [, key, timestampStr] = match;
+                const timestamp = parseInt(timestampStr, 10);
+                const filePath = path.join(this.basePath, file);
+                const stats = fs.statSync(filePath);
+                const isCompressed = file.endsWith(".gz");
+                backups.push({
+                    key,
+                    path: filePath,
+                    timestamp,
+                    size: stats.size,
+                    isCompressed,
+                });
+            }
+        }
+        return backups.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    getBackupsByKey(key) {
+        return this.getAllBackups().filter((b) => b.key === key);
+    }
+    cleanOldBackups(key) {
+        const backups = this.getBackupsByKey(key);
+        // Delete old backups exceeding maxBackups per player
+        for (let i = this.maxBackups; i < backups.length; i++) {
+            try {
+                fs.unlinkSync(backups[i].path);
+                console.log(`[Persistence] Deleted old backup: ${path.basename(backups[i].path)}`);
+            }
+            catch (err) {
+                console.error(`[Persistence] Failed to delete backup: ${backups[i].path}`, err);
+            }
+        }
+    }
+    cleanOldBackupsByAge() {
+        const now = Date.now();
+        const retentionMs = this.backupRetentionDays * 24 * 60 * 60 * 1000;
+        const backups = this.getAllBackups();
+        let deletedCount = 0;
+        for (const backup of backups) {
+            if (now - backup.timestamp > retentionMs) {
+                try {
+                    fs.unlinkSync(backup.path);
+                    deletedCount++;
+                }
+                catch (err) {
+                    console.error(`[Persistence] Failed to delete old backup: ${backup.path}`, err);
+                }
+            }
+        }
+        if (deletedCount > 0) {
+            console.log(`[Persistence] Deleted ${deletedCount} backups older than ${this.backupRetentionDays} days`);
+        }
+    }
+    cleanTotalBackupsLimit() {
+        let backups = this.getAllBackups();
+        if (backups.length <= this.maxTotalBackups)
+            return;
+        // Delete oldest backups
+        const toDelete = backups.slice(this.maxTotalBackups);
+        let deletedCount = 0;
+        for (const backup of toDelete) {
+            try {
+                fs.unlinkSync(backup.path);
+                deletedCount++;
+            }
+            catch (err) {
+                console.error(`[Persistence] Failed to delete backup: ${backup.path}`, err);
+            }
+        }
+        if (deletedCount > 0) {
+            console.log(`[Persistence] Deleted ${deletedCount} backups (exceeded limit ${this.maxTotalBackups})`);
+        }
+    }
+    // NEW: Clean all backups for a specific player
+    async cleanAllBackupsForPlayer(key) {
+        const backups = this.getBackupsByKey(key);
+        let deletedCount = 0;
+        for (const backup of backups) {
+            try {
+                fs.unlinkSync(backup.path);
+                deletedCount++;
+            }
+            catch (err) {
+                console.error(`[Persistence] Failed to delete backup: ${backup.path}`, err);
+            }
+        }
+        if (deletedCount > 0) {
+            console.log(`[Persistence] Deleted ${deletedCount} backups for player: ${key}`);
+        }
+        return deletedCount;
+    }
+    // NEW: Clean all backups
+    async cleanAllBackups() {
+        const backups = this.getAllBackups();
+        let deletedCount = 0;
+        for (const backup of backups) {
+            try {
+                fs.unlinkSync(backup.path);
+                deletedCount++;
+            }
+            catch (err) {
+                console.error(`[Persistence] Failed to delete backup: ${backup.path}`, err);
+            }
+        }
+        if (deletedCount > 0) {
+            console.log(`[Persistence] Deleted all ${deletedCount} backups`);
+        }
+        return deletedCount;
+    }
+    // NEW: Get backup statistics
+    getBackupStats() {
+        const backups = this.getAllBackups();
+        let totalSize = 0;
+        let oldestBackup = null;
+        let newestBackup = null;
+        const backupsByPlayer = new Map();
+        for (const backup of backups) {
+            totalSize += backup.size;
+            if (oldestBackup === null || backup.timestamp < oldestBackup)
+                oldestBackup = backup.timestamp;
+            if (newestBackup === null || backup.timestamp > newestBackup)
+                newestBackup = backup.timestamp;
+            backupsByPlayer.set(backup.key, (backupsByPlayer.get(backup.key) || 0) + 1);
+        }
+        return {
+            totalBackups: backups.length,
+            totalSize,
+            oldestBackup,
+            newestBackup,
+            backupsByPlayer,
+        };
+    }
+    async save(key, data, compress = false) {
+        const filePath = this.getFilePath(key);
+        let content = JSON.stringify(data, null, 2);
+        if (compress) {
+            const compressed = await gzip(content);
+            content = compressed.toString("base64");
+            fs.writeFileSync(filePath + ".gz", content);
+            return;
+        }
+        // Create backup before overwriting
+        if (fs.existsSync(filePath)) {
+            const backupPath = this.getBackupPath(key, Date.now());
+            fs.copyFileSync(filePath, backupPath);
+            this.cleanOldBackups(key);
+            this.cleanTotalBackupsLimit();
+            this.cleanOldBackupsByAge();
+        }
+        fs.writeFileSync(filePath, content);
+    }
+    async load(key) {
+        const filePath = this.getFilePath(key);
+        const gzPath = filePath + ".gz";
+        if (fs.existsSync(gzPath)) {
+            const compressed = fs.readFileSync(gzPath, "utf8");
+            const buffer = Buffer.from(compressed, "base64");
+            const decompressed = await gunzip(buffer);
+            return JSON.parse(decompressed.toString());
+        }
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, "utf8");
+            return JSON.parse(content);
+        }
+        return null;
+    }
+    async delete(key) {
+        const filePath = this.getFilePath(key);
+        const gzPath = filePath + ".gz";
+        if (fs.existsSync(filePath))
+            fs.unlinkSync(filePath);
+        if (fs.existsSync(gzPath))
+            fs.unlinkSync(gzPath);
+        // Also delete backups for this player
+        await this.cleanAllBackupsForPlayer(key);
+    }
+    async list() {
+        const files = fs.readdirSync(this.basePath);
+        return files
+            .filter((f) => {
+            // Exclude backup files
+            if (f.includes("_backup_"))
+                return false;
+            return f.endsWith(".json") || f.endsWith(".json.gz");
+        })
+            .map((f) => f.replace(/\.json(\.gz)?$/, ""));
+    }
+    async restoreBackup(key, backupTimestamp) {
+        let backupFile = null;
+        if (backupTimestamp) {
+            const specific = this.getBackupPath(key, backupTimestamp);
+            if (fs.existsSync(specific)) {
+                backupFile = specific;
+            }
+        }
+        else {
+            // Get latest backup
+            const backups = this.getBackupsByKey(key);
+            if (backups.length > 0) {
+                backupFile = backups[0].path;
+            }
+        }
+        if (backupFile && fs.existsSync(backupFile)) {
+            const content = fs.readFileSync(backupFile, "utf8");
+            const data = JSON.parse(content);
+            await this.save(key, data);
+            return true;
+        }
+        return false;
+    }
+}
+// Custom provider for database integration (giữ nguyên)
+class CustomProvider {
+    constructor(saveFn, loadFn, deleteFn, listFn) {
+        this.saveFn = saveFn;
+        this.loadFn = loadFn;
+        this.deleteFn = deleteFn;
+        this.listFn = listFn;
+    }
+    async save(key, data) {
+        await this.saveFn(key, data);
+    }
+    async load(key) {
+        return await this.loadFn(key);
+    }
+    async delete(key) {
+        if (this.deleteFn) {
+            await this.deleteFn(key);
+        }
+    }
+    async list() {
+        if (this.listFn) {
+            return await this.listFn();
+        }
+        return [];
+    }
+}
+class PersistenceManager extends events_1.EventEmitter {
+    constructor(manager, options) {
+        super();
+        this.saveInterval = null;
+        this.isSaving = false;
+        this.isRestoring = false;
+        this.destroyedPlayers = new Map();
+        this.restoredPlayers = new Set();
+        this.backupCleanupDone = false;
+        this.manager = manager;
+        // Default options
+        this.options = {
+            enabled: true,
+            provider: "file",
+            saveInterval: 60000,
+            autoLoad: true,
+            autoRestoreOnRestart: true,
+            restoreDelay: 5000,
+            maxBackups: 5,
+            maxTotalBackups: 10,
+            autoCleanupBackupsOnStart: true,
+            backupRetentionDays: 2,
+            compress: false,
+            filePath: "./players_data",
+        };
+        this.client = options.client;
+        // Merge manually
+        if (options.enabled !== undefined)
+            this.options.enabled = options.enabled;
+        if (options.provider !== undefined)
+            this.options.provider = options.provider;
+        if (options.saveInterval !== undefined)
+            this.options.saveInterval = options.saveInterval;
+        if (options.autoLoad !== undefined)
+            this.options.autoLoad = options.autoLoad;
+        if (options.autoRestoreOnRestart !== undefined)
+            this.options.autoRestoreOnRestart = options.autoRestoreOnRestart;
+        if (options.restoreDelay !== undefined)
+            this.options.restoreDelay = options.restoreDelay;
+        if (options.maxBackups !== undefined)
+            this.options.maxBackups = options.maxBackups;
+        if (options.maxTotalBackups !== undefined)
+            this.options.maxTotalBackups = options.maxTotalBackups;
+        if (options.autoCleanupBackupsOnStart !== undefined)
+            this.options.autoCleanupBackupsOnStart = options.autoCleanupBackupsOnStart;
+        if (options.backupRetentionDays !== undefined)
+            this.options.backupRetentionDays = options.backupRetentionDays;
+        if (options.compress !== undefined)
+            this.options.compress = options.compress;
+        if (options.filePath !== undefined)
+            this.options.filePath = options.filePath;
+        if (options.redisUrl !== undefined)
+            this.options.redisUrl = options.redisUrl;
+        if (options.redisPrefix !== undefined)
+            this.options.redisPrefix = options.redisPrefix;
+        if (options.save !== undefined)
+            this.options.save = options.save;
+        if (options.load !== undefined)
+            this.options.load = options.load;
+        if (options.delete !== undefined)
+            this.options.delete = options.delete;
+        if (options.list !== undefined)
+            this.options.list = options.list;
+        if (options.autoConnect !== undefined)
+            this.options.autoConnect = options.autoConnect;
+        this.provider = this.createProvider();
+        // Hook into player destroy events
+        this.setupDestroyTracking();
+        // Clean up old backups on start
+        if (this.options.enabled && this.options.autoCleanupBackupsOnStart) {
+            this.cleanupBackupsOnStart().catch((err) => {
+                this.debug("Backup cleanup on start error:", err);
+            });
+        }
+        if (this.options.enabled) {
+            this.startAutoSave();
+            if (this.options.autoLoad) {
+                this.loadAll().catch((err) => {
+                    this.debug("Auto-load error:", err);
+                });
+            }
+        }
+    }
+    setupDestroyTracking() {
+        this.manager.on("playerDestroy", (player) => {
+            this.markAsDestroyed(player.guildId);
+        });
+    }
+    createProvider() {
+        switch (this.options.provider) {
+            case "file":
+                return new FileProvider(this.options.filePath, {
+                    maxBackups: this.options.maxBackups,
+                    maxTotalBackups: this.options.maxTotalBackups,
+                    backupRetentionDays: this.options.backupRetentionDays,
+                });
+            case "redis":
+                throw new Error("Redis provider not implemented yet");
+            case "database":
+                if (!this.options.save || !this.options.load) {
+                    throw new Error("Database provider requires save/load functions");
+                }
+                return new CustomProvider(async (key, data) => {
+                    if (this.options.save) {
+                        const saveFn = this.options.save;
+                        if (saveFn.length === 1) {
+                            await saveFn({ key, data });
+                        }
+                        else {
+                            await saveFn(key, data);
+                        }
+                    }
+                }, async (key) => {
+                    if (this.options.load) {
+                        const loadFn = this.options.load;
+                        if (loadFn.length === 0) {
+                            const allData = await loadFn();
+                            return allData?.get?.(key) || allData?.[key] || null;
+                        }
+                        else {
+                            return await loadFn(key);
+                        }
+                    }
+                    return null;
+                }, this.options.delete, this.options.list);
+            default:
+                return new FileProvider(this.options.filePath, {
+                    maxBackups: this.options.maxBackups,
+                    maxTotalBackups: this.options.maxTotalBackups,
+                    backupRetentionDays: this.options.backupRetentionDays,
+                });
+        }
+    }
+    debug(message, ...params) {
+        if (this.manager.debugEnabled) {
+            this.manager.emit("debug", `[Persistence] ${message}`, ...params);
+        }
+    }
+    startAutoSave() {
+        if (this.saveInterval) {
+            clearInterval(this.saveInterval);
+        }
+        this.saveInterval = setInterval(() => {
+            this.saveAll().catch((err) => {
+                this.debug("Auto-save error:", err);
+                this.emit("error", err);
+            });
+        }, this.options.saveInterval);
+        this.debug(`Auto-save started (interval: ${this.options.saveInterval}ms)`);
+    }
+    // NEW: Cleanup backups on startup
+    async cleanupBackupsOnStart() {
+        if (this.backupCleanupDone)
+            return;
+        this.debug("Starting backup cleanup on startup...");
+        // Only works for file provider
+        if (this.provider instanceof FileProvider) {
+            try {
+                // Clean old backups by age
+                // This is already handled in FileProvider, but we can log stats
+                const stats = this.provider.getBackupStats();
+                this.debug(`Backup stats before cleanup:`, {
+                    totalBackups: stats.totalBackups,
+                    totalSizeMB: (stats.totalSize / 1024 / 1024).toFixed(2),
+                    oldestBackup: stats.oldestBackup ? new Date(stats.oldestBackup).toISOString() : null,
+                    newestBackup: stats.newestBackup ? new Date(stats.newestBackup).toISOString() : null,
+                    backupsByPlayer: Object.fromEntries(stats.backupsByPlayer),
+                });
+                // Emit stats event
+                this.emit("backupStats", stats);
+                // The cleanup is already happening in FileProvider.save()
+                // But we can do a one-time deep cleanup on start
+                if (this.options.backupRetentionDays && this.options.backupRetentionDays > 0) {
+                    // Force a cleanup pass
+                    const deletedCount = await this.cleanOldBackupsByAge();
+                    if (deletedCount > 0) {
+                        this.debug(`Cleaned up ${deletedCount} old backups on startup`);
+                    }
+                }
+                // Enforce total backup limit
+                const totalLimitDeleted = await this.enforceTotalBackupLimit();
+                if (totalLimitDeleted > 0) {
+                    this.debug(`Enforced backup limit: deleted ${totalLimitDeleted} backups`);
+                }
+                this.backupCleanupDone = true;
+                this.emit("backupCleanupDone");
+            }
+            catch (error) {
+                this.debug("Backup cleanup error:", error);
+            }
+        }
+        else {
+            this.debug("Backup cleanup only supported for file provider");
+        }
+    }
+    // NEW: Clean old backups by age
+    async cleanOldBackupsByAge() {
+        if (!(this.provider instanceof FileProvider))
+            return 0;
+        const retentionMs = (this.options.backupRetentionDays ?? 2) * 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        const backups = this.provider.getAllBackups();
+        let deletedCount = 0;
+        for (const backup of backups) {
+            if (now - backup.timestamp > retentionMs) {
+                try {
+                    fs.unlinkSync(backup.path);
+                    deletedCount++;
+                }
+                catch (err) {
+                    this.debug(`Failed to delete old backup: ${backup.path}`, err);
+                }
+            }
+        }
+        if (deletedCount > 0) {
+            this.debug(`Deleted ${deletedCount} backups older than ${this.options.backupRetentionDays} days`);
+        }
+        return deletedCount;
+    }
+    // NEW: Enforce total backup limit
+    async enforceTotalBackupLimit() {
+        if (!(this.provider instanceof FileProvider))
+            return 0;
+        const backups = this.provider.getAllBackups();
+        const maxTotal = this.options.maxTotalBackups ?? 50;
+        if (backups.length <= maxTotal)
+            return 0;
+        const toDelete = backups.slice(maxTotal);
+        let deletedCount = 0;
+        for (const backup of toDelete) {
+            try {
+                fs.unlinkSync(backup.path);
+                deletedCount++;
+            }
+            catch (err) {
+                this.debug(`Failed to delete backup: ${backup.path}`, err);
+            }
+        }
+        if (deletedCount > 0) {
+            this.debug(`Deleted ${deletedCount} backups (exceeded limit ${maxTotal})`);
+        }
+        return deletedCount;
+    }
+    markAsDestroyed(guildId) {
+        this.destroyedPlayers.set(guildId, {
+            guildId,
+            destroyedAt: Date.now(),
+            reason: "player_destroy",
+        });
+        this.debug(`Marked player as destroyed: ${guildId}`);
+        this.saveDestroyedStatus().catch((err) => {
+            this.debug("Failed to save destroyed status:", err);
+        });
+    }
+    isDestroyed(guildId) {
+        return this.destroyedPlayers.has(guildId);
+    }
+    async saveDestroyedStatus() {
+        const destroyedData = Array.from(this.destroyedPlayers.values());
+        await this.provider.save("__destroyed_players__", destroyedData);
+    }
+    async loadDestroyedStatus() {
+        try {
+            const data = await this.provider.load("__destroyed_players__");
+            if (data && Array.isArray(data)) {
+                this.destroyedPlayers.clear();
+                for (const record of data) {
+                    this.destroyedPlayers.set(record.guildId, record);
+                }
+                this.debug(`Loaded ${this.destroyedPlayers.size} destroyed player records`);
+            }
+        }
+        catch (error) {
+            this.debug("Failed to load destroyed status:", error);
+        }
+    }
+    async clearDestroyedStatus(guildId) {
+        this.destroyedPlayers.delete(guildId);
+        await this.saveDestroyedStatus();
+    }
+    serializeTrack(track) {
+        const serialized = {
+            id: track.id,
+            title: track.title,
+            url: track.url,
+            source: track.source,
+            duration: track.duration,
+            thumbnail: track.thumbnail,
+            requestedBy: track.requestedBy,
+            isLive: track.isLive || false,
+        };
+        const trackAny = track;
+        if (trackAny.author)
+            serialized.author = trackAny.author;
+        if (trackAny.artwork)
+            serialized.artwork = trackAny.artwork;
+        const excludedFields = new Set([
+            "id",
+            "title",
+            "url",
+            "source",
+            "duration",
+            "thumbnail",
+            "requestedBy",
+            "isLive",
+            "author",
+            "artwork",
+        ]);
+        for (const key of Object.keys(trackAny)) {
+            if (!excludedFields.has(key) && trackAny[key] !== undefined) {
+                serialized[key] = trackAny[key];
+            }
+        }
+        return serialized;
+    }
+    serializeQueue(player) {
+        return {
+            tracks: player.upcomingTracks.map((t) => this.serializeTrack(t)),
+            current: player.currentTrack ? this.serializeTrack(player.currentTrack) : null,
+            history: player.previousTracks.map((t) => this.serializeTrack(t)),
+            loopMode: player.queue.loop(),
+            autoPlay: player.queue.autoPlay(),
+            position: player.getTime().current,
+        };
+    }
+    serializePlayer(player) {
+        let filters = [];
+        try {
+            const filterString = player.filter?.getFilterString();
+            if (filterString) {
+                filters = filterString.split(",").filter(Boolean);
+            }
+        }
+        catch (e) { }
+        return {
+            guildId: player.guildId,
+            queue: this.serializeQueue(player),
+            volume: player.volume,
+            isPlaying: player.isPlaying,
+            isPaused: player.isPaused,
+            options: player.options,
+            filters: filters.length > 0 ? filters : undefined,
+            lastUpdate: Date.now(),
+            version: "1.0.0",
+            wasDestroyed: false,
+            voiceChannelId: player.channelConnection?.id,
+            adapterCreator: player.channelConnection?.guild?.adapterCreator,
+        };
+    }
+    deserializeTrack(data) {
+        const track = {
+            id: data.id,
+            title: data.title,
+            url: data.url,
+            source: data.source,
+            duration: data.duration,
+            thumbnail: data.thumbnail,
+            requestedBy: data.requestedBy,
+            isLive: data.isLive || false,
+        };
+        if (data.author)
+            track.author = data.author;
+        if (data.artwork)
+            track.artwork = data.artwork;
+        for (const key of Object.keys(data)) {
+            if (!["id", "title", "url", "source", "duration", "thumbnail", "requestedBy", "isLive", "author", "artwork"].includes(key)) {
+                track[key] = data[key];
+            }
+        }
+        return track;
+    }
+    /**
+     * Save a single player
+     */
+    async savePlayer(player) {
+        if (!this.options.enabled)
+            return false;
+        if (this.isDestroyed(player.guildId)) {
+            this.debug(`Skipping save for destroyed player: ${player.guildId}`);
+            return false;
+        }
+        try {
+            const data = this.serializePlayer(player);
+            await this.provider.save(player.guildId, data, this.options.compress);
+            this.debug(`Saved player: ${player.guildId}`);
+            this.emit("playerSaved", player.guildId);
+            return true;
+        }
+        catch (error) {
+            this.debug(`Failed to save player ${player.guildId}:`, error);
+            this.emit("error", error);
+            return false;
+        }
+    }
+    /**
+     * Save all players
+     */
+    async saveAll() {
+        if (!this.options.enabled || this.isSaving)
+            return new Map();
+        this.isSaving = true;
+        const results = new Map();
+        try {
+            const players = this.manager.getAll();
+            this.debug(`Saving ${players.length} players...`);
+            const batchSize = 5;
+            for (let i = 0; i < players.length; i += batchSize) {
+                const batch = players.slice(i, i + batchSize);
+                const promises = batch.map((p) => this.savePlayer(p));
+                const batchResults = await Promise.all(promises);
+                batch.forEach((p, idx) => results.set(p.guildId, batchResults[idx]));
+            }
+            this.debug(`Saved ${results.size} players`);
+            this.emit("savedAll", results);
+        }
+        finally {
+            this.isSaving = false;
+        }
+        return results;
+    }
+    /**
+     * Load a single player
+     */
+    async loadPlayer(guildId, restorePosition = true, skipIfDestroyed = true) {
+        if (!this.options.enabled)
+            return false;
+        if (skipIfDestroyed && this.isDestroyed(guildId)) {
+            this.debug(`Skipping load for destroyed player: ${guildId}`);
+            this.emit("playerSkipped", guildId, "destroyed");
+            return false;
+        }
+        if (this.restoredPlayers.has(guildId)) {
+            this.debug(`Skipping already restored player: ${guildId}`);
+            return true;
+        }
+        try {
+            const data = await this.provider.load(guildId);
+            console.log("[Persistence] Loaded data for", guildId, {
+                voiceChannelId: !!data.voiceChannelId,
+                adapterCreator: data.adapterCreator,
+                autoConnect: data.options?.autoConnect,
+                optionsAutoConnect: this.options.autoConnect,
+            });
+            if (!data)
+                return false;
+            if (data.wasDestroyed === true) {
+                this.debug(`Skipping load for player marked as destroyed: ${guildId}`);
+                return false;
+            }
+            let player = this.manager.get(guildId);
+            if (!player) {
+                player = await this.manager.create(guildId, data.options);
+            }
+            this.debug(`[Persistence] Attempting to auto-connect to channel: ${data.voiceChannelId}`);
+            try {
+                const client = this.client;
+                if (!client) {
+                    this.debug(`[Persistence] Cannot auto-connect: No client available`);
+                }
+                else {
+                    const guild = client.guilds.cache.get(guildId);
+                    if (!guild) {
+                        this.debug(`[Persistence] Cannot auto-connect: Guild ${guildId} not found`);
+                    }
+                    else {
+                        const voiceChannel = guild.channels.cache.get(data.voiceChannelId);
+                        if (voiceChannel && voiceChannel.isVoiceBased()) {
+                            await player.connect(voiceChannel);
+                            this.debug(`[Persistence] Auto-connected player ${guildId} to channel ${voiceChannel.name}`);
+                        }
+                        else {
+                            this.debug(`[Persistence] Voice channel ${data.voiceChannelId} not found or not a voice channel`);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.debug(`[Persistence] Failed to auto-connect player ${guildId} on load:`, err);
+            }
+            const queue = data.queue;
+            player.queue.clear();
+            player.queue.loop(queue.loopMode);
+            player.queue.autoPlay(queue.autoPlay);
+            if (queue.tracks.length > 0) {
+                const tracks = queue.tracks.map((t) => this.deserializeTrack(t));
+                player.queue.addMultiple(tracks);
+            }
+            if (queue.current && player.connection) {
+                const currentTrack = this.deserializeTrack(queue.current);
+                player.queue.willNextTrack(currentTrack);
+                if (restorePosition && queue.position && queue.position > 0) {
+                    await player.refreshPlayerResource(true, queue.position);
+                }
+                else {
+                    await player.play(currentTrack);
+                }
+            }
+            player.setVolume(data.volume);
+            if (data.filters && data.filters.length > 0) {
+                try {
+                    const filterManager = player.filter;
+                    if (filterManager && typeof filterManager.applyFilters === "function") {
+                        await filterManager.applyFilters(data.filters);
+                    }
+                }
+                catch (e) {
+                    this.debug(`Failed to restore filters for ${guildId}:`, e);
+                }
+            }
+            if (data.isPaused) {
+                player.pause();
+            }
+            else if (!data.isPlaying) {
+                player.stop();
+            }
+            else if (data.isPlaying) {
+                player.resume();
+            }
+            this.restoredPlayers.add(guildId);
+            await this.clearDestroyedStatus(guildId);
+            this.debug(`Loaded player: ${guildId}`);
+            this.emit("playerLoaded", guildId, data);
+            return true;
+        }
+        catch (error) {
+            this.debug(`Failed to load player ${guildId}:`, error);
+            this.emit("error", error);
+            return false;
+        }
+    }
+    /**
+     * Load all saved players with auto-restore logic
+     */
+    async loadAll(restorePosition = true) {
+        if (!this.options.enabled)
+            return new Map();
+        await this.loadDestroyedStatus();
+        const results = new Map();
+        try {
+            const keys = await this.provider.list();
+            const playerKeys = keys.filter((k) => k !== "__destroyed_players__");
+            this.debug(`Found ${playerKeys.length} saved players`);
+            if (this.options.autoRestoreOnRestart) {
+                this.debug(`Auto-restore enabled, restoring players after ${this.options.restoreDelay}ms delay...`);
+                if (this.options.restoreDelay && this.options.restoreDelay > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, this.options.restoreDelay));
+                }
+                for (const guildId of playerKeys) {
+                    const success = await this.loadPlayer(guildId, restorePosition, true);
+                    results.set(guildId, success);
+                }
+                this.emit("loadedAll", results);
+            }
+        }
+        catch (error) {
+            this.debug("Failed to load players:", error);
+            this.emit("error", error);
+        }
+        return results;
+    }
+    /**
+     * Mark a player as destroyed
+     */
+    async markPlayerDestroyed(guildId, reason) {
+        this.destroyedPlayers.set(guildId, {
+            guildId,
+            destroyedAt: Date.now(),
+            reason: reason || "manual_destroy",
+        });
+        try {
+            const data = await this.provider.load(guildId);
+            if (data) {
+                data.wasDestroyed = true;
+                data.destroyedAt = Date.now();
+                await this.provider.save(guildId, data, this.options.compress);
+            }
+        }
+        catch (error) {
+            this.debug(`Failed to mark player data as destroyed: ${guildId}`, error);
+        }
+        await this.saveDestroyedStatus();
+        this.debug(`Marked player as destroyed (won't restore on restart): ${guildId}`);
+        this.emit("playerMarkedDestroyed", guildId);
+    }
+    /**
+     * Clear destroyed status for a player
+     */
+    async clearDestroyed(guildId) {
+        await this.clearDestroyedStatus(guildId);
+        try {
+            const data = await this.provider.load(guildId);
+            if (data) {
+                data.wasDestroyed = false;
+                delete data.destroyedAt;
+                await this.provider.save(guildId, data, this.options.compress);
+            }
+        }
+        catch (error) {
+            this.debug(`Failed to clear destroyed flag in data: ${guildId}`, error);
+        }
+        this.debug(`Cleared destroyed status for: ${guildId}`);
+        this.emit("playerDestroyedCleared", guildId);
+    }
+    /**
+     * Delete a player's saved data
+     */
+    async deletePlayer(guildId) {
+        if (!this.options.enabled)
+            return false;
+        try {
+            await this.provider.delete(guildId);
+            await this.clearDestroyedStatus(guildId);
+            this.restoredPlayers.delete(guildId);
+            this.debug(`Deleted saved data for: ${guildId}`);
+            this.emit("playerDeleted", guildId);
+            return true;
+        }
+        catch (error) {
+            this.debug(`Failed to delete player ${guildId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Restore from backup
+     */
+    async restoreBackup(guildId, timestamp) {
+        if (!(this.provider instanceof FileProvider)) {
+            this.debug("Restore from backup only supported for file provider");
+            return false;
+        }
+        const success = await this.provider.restoreBackup(guildId, timestamp);
+        if (success) {
+            await this.clearDestroyed(guildId);
+        }
+        return success;
+    }
+    /**
+     * Clean all backups for a specific player
+     */
+    async cleanBackupsForPlayer(guildId) {
+        if (!(this.provider instanceof FileProvider)) {
+            this.debug("Backup cleanup only supported for file provider");
+            return 0;
+        }
+        const deleted = await this.provider.cleanAllBackupsForPlayer(guildId);
+        this.debug(`Cleaned ${deleted} backups for player: ${guildId}`);
+        this.emit("backupsCleaned", guildId, deleted);
+        return deleted;
+    }
+    /**
+     * Clean all backups
+     */
+    async cleanAllBackups() {
+        if (!(this.provider instanceof FileProvider)) {
+            this.debug("Backup cleanup only supported for file provider");
+            return 0;
+        }
+        const deleted = await this.provider.cleanAllBackups();
+        this.debug(`Cleaned all ${deleted} backups`);
+        this.emit("allBackupsCleaned", deleted);
+        return deleted;
+    }
+    /**
+     * Get backup statistics
+     */
+    getBackupStats() {
+        if (!(this.provider instanceof FileProvider)) {
+            this.debug("Backup stats only supported for file provider");
+            return null;
+        }
+        const stats = this.provider.getBackupStats();
+        return {
+            totalBackups: stats.totalBackups,
+            totalSizeMB: stats.totalSize / 1024 / 1024,
+            oldestBackup: stats.oldestBackup ? new Date(stats.oldestBackup) : null,
+            newestBackup: stats.newestBackup ? new Date(stats.newestBackup) : null,
+            backupsByPlayer: Object.fromEntries(stats.backupsByPlayer),
+        };
+    }
+    /**
+     * Stop auto-save and clean up
+     */
+    async shutdown() {
+        if (this.saveInterval) {
+            clearInterval(this.saveInterval);
+            this.saveInterval = null;
+        }
+        await this.saveAll();
+        await this.saveDestroyedStatus();
+        this.debug("Persistence manager shut down");
+    }
+    /**
+     * Get list of destroyed players
+     */
+    getDestroyedPlayers() {
+        return Array.from(this.destroyedPlayers.values());
+    }
+    /**
+     * Check if auto-restore is enabled
+     */
+    isAutoRestoreEnabled() {
+        return this.options.autoRestoreOnRestart === true;
+    }
+}
+exports.PersistenceManager = PersistenceManager;
+//# sourceMappingURL=PersistenceManager.js.map