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

package/src/persistence/PersistenceManager.ts

@@ -3,7 +3,15 @@ import * as fs from "fs";
 import * as path from "path";
 import * as zlib from "zlib";
 import { promisify } from "util";
-import type { SerializedPlayer, SerializedQueue, SerializedTrack, PersistenceOptions, PersistenceProvider } from "../types";
+import type {
+	SerializedPlayer,
+	SerializedQueue,
+	SerializedTrack,
+	PersistenceOptions,
+	PersistenceProvider,
+	DestroyedRecord,
+	BackupInfo,
+} from "../types";
 import type { Player } from "../structures/Player";
 import type { PlayerManager } from "../structures/PlayerManager";
 import type { Track } from "../types";
@@ -11,14 +19,26 @@ import type { Track } from "../types";
 const gzip = promisify(zlib.gzip);
 const gunzip = promisify(zlib.gunzip);
 
-// File provider implementation
-export class FileProvider implements PersistenceProvider {
+// File provider implementation with enhanced backup management
+class FileProvider implements PersistenceProvider {
 	private basePath: string;
 	private maxBackups: number;
+	private maxTotalBackups: number;
+	private backupRetentionDays: number;
 
-	constructor(basePath: string, maxBackups: number = 5) {
+	constructor(
+		basePath: string,
+		options: {
+			maxBackups?: number;
+			maxTotalBackups?: number;
+			backupRetentionDays?: number;
+		} = {},
+	) {
 		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 });
 		}
@@ -32,18 +52,165 @@ export class FileProvider implements PersistenceProvider {
 		return path.join(this.basePath, `${key}_backup_${timestamp}.json`);
 	}
 
+	private getAllBackups(): BackupInfo[] {
+		const files = fs.readdirSync(this.basePath);
+		const backups: BackupInfo[] = [];
+
+		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);
+	}
+
+	private getBackupsByKey(key: string): BackupInfo[] {
+		return this.getAllBackups().filter((b) => b.key === key);
+	}
+
 	private cleanOldBackups(key: string): void {
-		const backups = fs
-			.readdirSync(this.basePath)
-			.filter((f) => f.startsWith(key) && f.includes("backup"))
-			.sort()
-			.reverse();
+		const backups = this.getBackupsByKey(key);
 
-		// Keep only maxBackups most recent
+		// 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);
+			}
+		}
+	}
+
+	private cleanOldBackupsByAge(): void {
+		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`);
+		}
+	}
+
+	private cleanTotalBackupsLimit(): void {
+		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: string): Promise<number> {
+		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(): Promise<number> {
+		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(): {
+		totalBackups: number;
+		totalSize: number;
+		oldestBackup: number | null;
+		newestBackup: number | null;
+		backupsByPlayer: Map<string, number>;
+	} {
+		const backups = this.getAllBackups();
+		let totalSize = 0;
+		let oldestBackup: number | null = null;
+		let newestBackup: number | null = null;
+		const backupsByPlayer = new Map<string, number>();
+
+		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: string, data: any, compress: boolean = false): Promise<void> {
@@ -62,6 +229,8 @@ export class FileProvider implements PersistenceProvider {
 			const backupPath = this.getBackupPath(key, Date.now());
 			fs.copyFileSync(filePath, backupPath);
 			this.cleanOldBackups(key);
+			this.cleanTotalBackupsLimit();
+			this.cleanOldBackupsByAge();
 		}
 
 		fs.writeFileSync(filePath, content);
@@ -92,11 +261,20 @@ export class FileProvider implements PersistenceProvider {
 
 		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(): Promise<string[]> {
 		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: string, backupTimestamp?: number): Promise<boolean> {
@@ -109,13 +287,9 @@ export class FileProvider implements PersistenceProvider {
 			}
 		} 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;
 			}
 		}
 
@@ -130,7 +304,7 @@ export class FileProvider implements PersistenceProvider {
 	}
 }
 
-// Custom provider for database integration
+// Custom provider for database integration (giữ nguyên)
 class CustomProvider implements PersistenceProvider {
 	constructor(
 		private saveFn: (key: string, data: any) => Promise<void>,
@@ -164,30 +338,46 @@ class CustomProvider implements PersistenceProvider {
 export class PersistenceManager extends EventEmitter {
 	private manager: PlayerManager;
 	private options: PersistenceOptions;
-	private provider: PersistenceProvider;
+	private provider: FileProvider | CustomProvider;
 	private saveInterval: NodeJS.Timeout | null = null;
 	private isSaving: boolean = false;
+	private isRestoring: boolean = false;
+	private destroyedPlayers: Map<string, DestroyedRecord> = new Map();
+	private restoredPlayers: Set<string> = new Set();
+	private backupCleanupDone: boolean = false;
 
 	constructor(manager: PlayerManager, options: PersistenceOptions) {
 		super();
 		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) 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;
@@ -199,6 +389,16 @@ export class PersistenceManager extends EventEmitter {
 
 		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();
 
@@ -210,28 +410,33 @@ export class PersistenceManager extends EventEmitter {
 		}
 	}
 
-	private createProvider(): PersistenceProvider {
+	private setupDestroyTracking(): void {
+		this.manager.on("playerDestroy", (player: Player) => {
+			this.markAsDestroyed(player.guildId);
+		});
+	}
+
+	private createProvider(): FileProvider | CustomProvider {
 		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: string, data: any) => {
 						if (this.options.save) {
-							// Call with single object argument if that's expected
 							const saveFn = this.options.save as any;
 							if (saveFn.length === 1) {
-								// Save function expects { key, data }
 								await saveFn({ key, data });
 							} else {
-								// Save function expects (key, data)
 								await saveFn(key, data);
 							}
 						}
@@ -240,11 +445,9 @@ export class PersistenceManager extends EventEmitter {
 						if (this.options.load) {
 							const loadFn = this.options.load as any;
 							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);
 							}
 						}
@@ -254,7 +457,11 @@ export class PersistenceManager extends EventEmitter {
 					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,
+				});
 		}
 	}
 
@@ -279,8 +486,154 @@ export class PersistenceManager extends EventEmitter {
 		this.debug(`Auto-save started (interval: ${this.options.saveInterval}ms)`);
 	}
 
+	// NEW: Cleanup backups on startup
+	private async cleanupBackupsOnStart(): Promise<void> {
+		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
+	private async cleanOldBackupsByAge(): Promise<number> {
+		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 as any).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
+	private async enforceTotalBackupLimit(): Promise<number> {
+		if (!(this.provider instanceof FileProvider)) return 0;
+
+		const backups = (this.provider as any).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;
+	}
+
+	private markAsDestroyed(guildId: string): void {
+		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);
+		});
+	}
+
+	private isDestroyed(guildId: string): boolean {
+		return this.destroyedPlayers.has(guildId);
+	}
+
+	private async saveDestroyedStatus(): Promise<void> {
+		const destroyedData = Array.from(this.destroyedPlayers.values());
+		await this.provider.save("__destroyed_players__", destroyedData);
+	}
+
+	private async loadDestroyedStatus(): Promise<void> {
+		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);
+		}
+	}
+
+	private async clearDestroyedStatus(guildId: string): Promise<void> {
+		this.destroyedPlayers.delete(guildId);
+		await this.saveDestroyedStatus();
+	}
+
 	private serializeTrack(track: Track): SerializedTrack {
-		// Create base object with required fields only (avoid duplication)
 		const serialized: SerializedTrack = {
 			id: track.id,
 			title: track.title,
@@ -292,12 +645,10 @@ export class PersistenceManager extends EventEmitter {
 			isLive: track.isLive || false,
 		};
 
-		// Add optional fields if they exist on the track
 		const trackAny = track as any;
 		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",
@@ -331,16 +682,13 @@ export class PersistenceManager extends EventEmitter {
 	}
 
 	private serializePlayer(player: Player): SerializedPlayer {
-		// Get filters safely - access through public method
 		let filters: string[] = [];
 		try {
 			const filterString = (player as any).filter?.getFilterString();
 			if (filterString) {
 				filters = filterString.split(",").filter(Boolean);
 			}
-		} catch (e) {
-			// Filter may not be accessible
-		}
+		} catch (e) {}
 
 		return {
 			guildId: player.guildId,
@@ -352,11 +700,11 @@ export class PersistenceManager extends EventEmitter {
 			filters: filters.length > 0 ? filters : undefined,
 			lastUpdate: Date.now(),
 			version: "1.0.0",
+			wasDestroyed: false,
 		};
 	}
 
 	private deserializeTrack(data: SerializedTrack): Track {
-		// Create base track object
 		const track: any = {
 			id: data.id,
 			title: data.title,
@@ -368,11 +716,9 @@ export class PersistenceManager extends EventEmitter {
 			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)
@@ -390,9 +736,14 @@ export class PersistenceManager extends EventEmitter {
 	async savePlayer(player: Player): Promise<boolean> {
 		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;
@@ -416,7 +767,6 @@ export class PersistenceManager extends EventEmitter {
 			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);
@@ -437,39 +787,49 @@ export class PersistenceManager extends EventEmitter {
 	/**
 	 * Load a single player
 	 */
-	async loadPlayer(guildId: string, restorePosition: boolean = true): Promise<boolean> {
+	async loadPlayer(guildId: string, restorePosition: boolean = true, skipIfDestroyed: boolean = true): Promise<boolean> {
 		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 as SerializedQueue;
 
-			// 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: SerializedTrack) => this.deserializeTrack(t));
+				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);
 				} else {
@@ -477,10 +837,8 @@ export class PersistenceManager extends EventEmitter {
 				}
 			}
 
-			// Restore volume
 			player.setVolume(data.volume);
 
-			// Restore filters - safely access through public method
 			if (data.filters && data.filters.length > 0) {
 				try {
 					const filterManager = (player as any).filter;
@@ -492,6 +850,9 @@ export class PersistenceManager extends EventEmitter {
 				}
 			}
 
+			this.restoredPlayers.add(guildId);
+			await this.clearDestroyedStatus(guildId);
+
 			this.debug(`Loaded player: ${guildId}`);
 			this.emit("playerLoaded", guildId, data);
 			return true;
@@ -503,20 +864,36 @@ export class PersistenceManager extends EventEmitter {
 	}
 
 	/**
-	 * Load all saved players
+	 * Load all saved players with auto-restore logic
 	 */
 	async loadAll(restorePosition: boolean = true): Promise<Map<string, boolean>> {
 		if (!this.options.enabled) return new Map();
 
+		await this.loadDestroyedStatus();
+
 		const results = new Map<string, boolean>();
 
 		try {
 			const keys = await this.provider.list();
-			this.debug(`Found ${keys.length} saved players`);
+			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 keys) {
-				const success = await this.loadPlayer(guildId, restorePosition);
-				results.set(guildId, success);
+				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);
@@ -528,6 +905,53 @@ export class PersistenceManager extends EventEmitter {
 		return results;
 	}
 
+	/**
+	 * Mark a player as destroyed
+	 */
+	async markPlayerDestroyed(guildId: string, reason?: string): Promise<void> {
+		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: string): Promise<void> {
+		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
 	 */
@@ -536,6 +960,8 @@ export class PersistenceManager extends EventEmitter {
 
 		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;
@@ -554,7 +980,67 @@ export class PersistenceManager extends EventEmitter {
 			return false;
 		}
 
-		return await (this.provider as FileProvider).restoreBackup(guildId, timestamp);
+		const success = await (this.provider as FileProvider).restoreBackup(guildId, timestamp);
+		if (success) {
+			await this.clearDestroyed(guildId);
+		}
+		return success;
+	}
+
+	/**
+	 * Clean all backups for a specific player
+	 */
+	async cleanBackupsForPlayer(guildId: string): Promise<number> {
+		if (!(this.provider instanceof FileProvider)) {
+			this.debug("Backup cleanup only supported for file provider");
+			return 0;
+		}
+
+		const deleted = await (this.provider as FileProvider).cleanAllBackupsForPlayer(guildId);
+		this.debug(`Cleaned ${deleted} backups for player: ${guildId}`);
+		this.emit("backupsCleaned", guildId, deleted);
+		return deleted;
+	}
+
+	/**
+	 * Clean all backups
+	 */
+	async cleanAllBackups(): Promise<number> {
+		if (!(this.provider instanceof FileProvider)) {
+			this.debug("Backup cleanup only supported for file provider");
+			return 0;
+		}
+
+		const deleted = await (this.provider as FileProvider).cleanAllBackups();
+		this.debug(`Cleaned all ${deleted} backups`);
+		this.emit("allBackupsCleaned", deleted);
+		return deleted;
+	}
+
+	/**
+	 * Get backup statistics
+	 */
+	getBackupStats(): {
+		totalBackups: number;
+		totalSizeMB: number;
+		oldestBackup: Date | null;
+		newestBackup: Date | null;
+		backupsByPlayer: Record<string, number>;
+	} | null {
+		if (!(this.provider instanceof FileProvider)) {
+			this.debug("Backup stats only supported for file provider");
+			return null;
+		}
+
+		const stats = (this.provider as FileProvider).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),
+		};
 	}
 
 	/**
@@ -567,6 +1053,21 @@ export class PersistenceManager extends EventEmitter {
 		}
 
 		await this.saveAll();
+		await this.saveDestroyedStatus();
 		this.debug("Persistence manager shut down");
 	}
+
+	/**
+	 * Get list of destroyed players
+	 */
+	getDestroyedPlayers(): DestroyedRecord[] {
+		return Array.from(this.destroyedPlayers.values());
+	}
+
+	/**
+	 * Check if auto-restore is enabled
+	 */
+	isAutoRestoreEnabled(): boolean {
+		return this.options.autoRestoreOnRestart === true;
+	}
 }