ziplayer 0.2.7-dev.1 → 0.2.7-dev.2

package/dist/persistence/PersistenceManager.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistenceManager = exports.FileProvider = void 0;
+exports.PersistenceManager = void 0;
 const events_1 = require("events");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -41,11 +41,13 @@ 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
+// File provider implementation with enhanced backup management
 class FileProvider {
-    constructor(basePath, maxBackups = 5) {
+    constructor(basePath, options = {}) {
         this.basePath = basePath;
-        this.maxBackups = maxBackups;
+        this.maxBackups = options.maxBackups ?? 5;
+        this.maxTotalBackups = options.maxTotalBackups ?? 50;
+        this.backupRetentionDays = options.backupRetentionDays ?? 7;
         if (!fs.existsSync(basePath)) {
             fs.mkdirSync(basePath, { recursive: true });
         }
@@ -56,18 +58,143 @@ class FileProvider {
     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 = fs
-            .readdirSync(this.basePath)
-            .filter((f) => f.startsWith(key) && f.includes("backup"))
-            .sort()
-            .reverse();
-        // Keep only maxBackups most recent
+        const backups = this.getBackupsByKey(key);
+        // Delete old backups exceeding maxBackups per player
         for (let i = this.maxBackups; i < backups.length; i++) {
-            const backupPath = path.join(this.basePath, backups[i]);
-            fs.unlinkSync(backupPath);
+            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);
@@ -82,6 +209,8 @@ class FileProvider {
             const backupPath = this.getBackupPath(key, Date.now());
             fs.copyFileSync(filePath, backupPath);
             this.cleanOldBackups(key);
+            this.cleanTotalBackupsLimit();
+            this.cleanOldBackupsByAge();
         }
         fs.writeFileSync(filePath, content);
     }
@@ -107,10 +236,19 @@ class FileProvider {
             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) => f.endsWith(".json") || f.endsWith(".json.gz")).map((f) => f.replace(/\.json(\.gz)?$/, ""));
+        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;
@@ -122,13 +260,9 @@ class FileProvider {
         }
         else {
             // Get latest backup
-            const backups = fs
-                .readdirSync(this.basePath)
-                .filter((f) => f.startsWith(key) && f.includes("backup"))
-                .sort()
-                .reverse();
+            const backups = this.getBackupsByKey(key);
             if (backups.length > 0) {
-                backupFile = path.join(this.basePath, backups[0]);
+                backupFile = backups[0].path;
             }
         }
         if (backupFile && fs.existsSync(backupFile)) {
@@ -140,8 +274,7 @@ class FileProvider {
         return false;
     }
 }
-exports.FileProvider = FileProvider;
-// Custom provider for database integration
+// Custom provider for database integration (giữ nguyên)
 class CustomProvider {
     constructor(saveFn, loadFn, deleteFn, listFn) {
         this.saveFn = saveFn;
@@ -172,18 +305,27 @@ class PersistenceManager extends events_1.EventEmitter {
         super();
         this.saveInterval = null;
         this.isSaving = false;
+        this.isRestoring = false;
+        this.destroyedPlayers = new Map();
+        this.restoredPlayers = new Set();
+        this.backupCleanupDone = false;
         this.manager = manager;
-        // Fix: Don't use spread that causes duplicate 'enabled'
+        // 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",
         };
-        // Merge options manually to avoid spread duplication
+        // Merge manually
         if (options.enabled !== undefined)
             this.options.enabled = options.enabled;
         if (options.provider !== undefined)
@@ -192,8 +334,18 @@ class PersistenceManager extends events_1.EventEmitter {
             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)
@@ -211,6 +363,14 @@ class PersistenceManager extends events_1.EventEmitter {
         if (options.list !== undefined)
             this.options.list = options.list;
         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) {
@@ -220,28 +380,32 @@ class PersistenceManager extends events_1.EventEmitter {
             }
         }
     }
+    setupDestroyTracking() {
+        this.manager.on("playerDestroy", (player) => {
+            this.markAsDestroyed(player.guildId);
+        });
+    }
     createProvider() {
         switch (this.options.provider) {
             case "file":
-                return new FileProvider(this.options.filePath, this.options.maxBackups);
+                return new FileProvider(this.options.filePath, {
+                    maxBackups: this.options.maxBackups,
+                    maxTotalBackups: this.options.maxTotalBackups,
+                    backupRetentionDays: this.options.backupRetentionDays,
+                });
             case "redis":
-                // Implement Redis provider if needed
                 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");
                 }
-                // Fix: Pass the save and load functions with correct signatures
                 return new CustomProvider(async (key, data) => {
                     if (this.options.save) {
-                        // Call with single object argument if that's expected
                         const saveFn = this.options.save;
                         if (saveFn.length === 1) {
-                            // Save function expects { key, data }
                             await saveFn({ key, data });
                         }
                         else {
-                            // Save function expects (key, data)
                             await saveFn(key, data);
                         }
                     }
@@ -249,19 +413,21 @@ class PersistenceManager extends events_1.EventEmitter {
                     if (this.options.load) {
                         const loadFn = this.options.load;
                         if (loadFn.length === 0) {
-                            // Load function expects no args, returns all data
                             const allData = await loadFn();
                             return allData?.get?.(key) || allData?.[key] || null;
                         }
                         else {
-                            // Load function expects key
                             return await loadFn(key);
                         }
                     }
                     return null;
                 }, this.options.delete, this.options.list);
             default:
-                return new FileProvider(this.options.filePath, this.options.maxBackups);
+                return new FileProvider(this.options.filePath, {
+                    maxBackups: this.options.maxBackups,
+                    maxTotalBackups: this.options.maxTotalBackups,
+                    backupRetentionDays: this.options.backupRetentionDays,
+                });
         }
     }
     debug(message, ...params) {
@@ -281,8 +447,137 @@ class PersistenceManager extends events_1.EventEmitter {
         }, 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) {
-        // Create base object with required fields only (avoid duplication)
         const serialized = {
             id: track.id,
             title: track.title,
@@ -293,13 +588,11 @@ class PersistenceManager extends events_1.EventEmitter {
             requestedBy: track.requestedBy,
             isLive: track.isLive || false,
         };
-        // Add optional fields if they exist on the track
         const trackAny = track;
         if (trackAny.author)
             serialized.author = trackAny.author;
         if (trackAny.artwork)
             serialized.artwork = trackAny.artwork;
-        // Add any extra metadata (excluding fields we already set)
         const excludedFields = new Set([
             "id",
             "title",
@@ -330,7 +623,6 @@ class PersistenceManager extends events_1.EventEmitter {
         };
     }
     serializePlayer(player) {
-        // Get filters safely - access through public method
         let filters = [];
         try {
             const filterString = player.filter?.getFilterString();
@@ -338,9 +630,7 @@ class PersistenceManager extends events_1.EventEmitter {
                 filters = filterString.split(",").filter(Boolean);
             }
         }
-        catch (e) {
-            // Filter may not be accessible
-        }
+        catch (e) { }
         return {
             guildId: player.guildId,
             queue: this.serializeQueue(player),
@@ -351,10 +641,10 @@ class PersistenceManager extends events_1.EventEmitter {
             filters: filters.length > 0 ? filters : undefined,
             lastUpdate: Date.now(),
             version: "1.0.0",
+            wasDestroyed: false,
         };
     }
     deserializeTrack(data) {
-        // Create base track object
         const track = {
             id: data.id,
             title: data.title,
@@ -365,12 +655,10 @@ class PersistenceManager extends events_1.EventEmitter {
             requestedBy: data.requestedBy,
             isLive: data.isLive || false,
         };
-        // Add optional fields if they exist
         if (data.author)
             track.author = data.author;
         if (data.artwork)
             track.artwork = data.artwork;
-        // Add any extra metadata from serialized data
         for (const key of Object.keys(data)) {
             if (!["id", "title", "url", "source", "duration", "thumbnail", "requestedBy", "isLive", "author", "artwork"].includes(key)) {
                 track[key] = data[key];
@@ -384,9 +672,13 @@ class PersistenceManager extends events_1.EventEmitter {
     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);
+            await this.provider.save(player.guildId, data, this.options.compress);
             this.debug(`Saved player: ${player.guildId}`);
             this.emit("playerSaved", player.guildId);
             return true;
@@ -408,7 +700,6 @@ class PersistenceManager extends events_1.EventEmitter {
         try {
             const players = this.manager.getAll();
             this.debug(`Saving ${players.length} players...`);
-            // Save in parallel with limit
             const batchSize = 5;
             for (let i = 0; i < players.length; i += batchSize) {
                 const batch = players.slice(i, i + batchSize);
@@ -427,34 +718,41 @@ class PersistenceManager extends events_1.EventEmitter {
     /**
      * Load a single player
      */
-    async loadPlayer(guildId, restorePosition = true) {
+    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);
             if (!data)
                 return false;
-            // Check if player already exists
+            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);
             }
-            // Restore queue
             const queue = data.queue;
-            // Clear current queue
             player.queue.clear();
             player.queue.loop(queue.loopMode);
             player.queue.autoPlay(queue.autoPlay);
-            // Restore tracks
             if (queue.tracks.length > 0) {
                 const tracks = queue.tracks.map((t) => this.deserializeTrack(t));
                 player.queue.addMultiple(tracks);
             }
-            // Restore current track if exists
             if (queue.current && player.connection) {
                 const currentTrack = this.deserializeTrack(queue.current);
                 player.queue.willNextTrack(currentTrack);
-                // Restore playback position if requested
                 if (restorePosition && queue.position && queue.position > 0) {
                     await player.refreshPlayerResource(true, queue.position);
                 }
@@ -462,9 +760,7 @@ class PersistenceManager extends events_1.EventEmitter {
                     await player.play(currentTrack);
                 }
             }
-            // Restore volume
             player.setVolume(data.volume);
-            // Restore filters - safely access through public method
             if (data.filters && data.filters.length > 0) {
                 try {
                     const filterManager = player.filter;
@@ -476,6 +772,8 @@ class PersistenceManager extends events_1.EventEmitter {
                     this.debug(`Failed to restore filters for ${guildId}:`, e);
                 }
             }
+            this.restoredPlayers.add(guildId);
+            await this.clearDestroyedStatus(guildId);
             this.debug(`Loaded player: ${guildId}`);
             this.emit("playerLoaded", guildId, data);
             return true;
@@ -487,18 +785,32 @@ class PersistenceManager extends events_1.EventEmitter {
         }
     }
     /**
-     * Load all saved players
+     * 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();
-            this.debug(`Found ${keys.length} saved players`);
-            for (const guildId of keys) {
-                const success = await this.loadPlayer(guildId, restorePosition);
-                results.set(guildId, success);
+            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);
+                }
+            }
+            else {
+                for (const guildId of playerKeys) {
+                    const success = await this.loadPlayer(guildId, restorePosition, true);
+                    results.set(guildId, success);
+                }
             }
             this.emit("loadedAll", results);
         }
@@ -508,6 +820,49 @@ class PersistenceManager extends events_1.EventEmitter {
         }
         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
      */
@@ -516,6 +871,8 @@ class PersistenceManager extends events_1.EventEmitter {
             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;
@@ -533,7 +890,54 @@ class PersistenceManager extends events_1.EventEmitter {
             this.debug("Restore from backup only supported for file provider");
             return false;
         }
-        return await this.provider.restoreBackup(guildId, timestamp);
+        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
@@ -544,8 +948,21 @@ class PersistenceManager extends events_1.EventEmitter {
             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