jellytau/src/lib/stores/downloads.ts

// Download manager state store
// TRACES: UR-011, UR-013, UR-018 | DR-015, DR-017
import { writable, derived, get } from 'svelte/store';
import { commands } from '$lib/api/bindings';
import { listen, type UnlistenFn } from '@tauri-apps/api/event';
import { createLogger } from '$lib/utils/logger';

const log = createLogger('Downloads');

// Event listener state
let unlistenFn: UnlistenFn | null = null;
let isEventsInitialized = false;

export interface DownloadInfo {
	id: number;
	itemId: string;
	userId: string;
	filePath: string;
	fileSize?: number;
	mimeType?: string;
	status: 'pending' | 'downloading' | 'completed' | 'failed' | 'paused';
	progress: number;
	bytesDownloaded: number;
	queuedAt: string;
	startedAt?: string;
	completedAt?: string;
	errorMessage?: string;
	retryCount: number;
	priority: number;
	// Item metadata for display (audio)
	itemName?: string;
	artistName?: string;
	albumName?: string;
	// Video-specific metadata
	seriesName?: string;
	seasonName?: string;
	episodeNumber?: number;
	seasonNumber?: number;
	qualityPreset?: string;
	mediaType: 'audio' | 'video';
	// Download source tracking
	downloadSource: 'user' | 'auto';
}

export interface DownloadEvent {
	type:
		| 'queued'
		| 'started'
		| 'progress'
		| 'completed'
		| 'failed'
		| 'paused'
		| 'cancelled'
		| 'waitingForNetwork';
	/** Absent on 'waitingForNetwork', which is queue-wide rather than per-download. */
	downloadId: number;
	itemId: string;
	bytesDownloaded?: number;
	totalBytes?: number;
	progress?: number;
	filePath?: string;
	error?: string;
}

export interface DownloadStats {
	total: number;
	activeCount: number;
	queuedCount: number;
	completedCount: number;
	failedCount: number;
	pausedCount: number;
}

interface DownloadsState {
	downloads: Record<number, DownloadInfo>;
	stats: DownloadStats;
}

/**
 * True when the download queue is held because "WiFi Only" is enabled and the
 * device is on a metered/cellular network. Pending rows stay pending; the queue
 * resumes automatically when an acceptable network appears.
 *
 * TRACES: UR-053 | DR-074
 */
export const waitingForNetwork = writable(false);

function createDownloadsStore() {
	const { subscribe, update, set } = writable<DownloadsState>({
		downloads: {},
		stats: {
			total: 0,
			activeCount: 0,
			queuedCount: 0,
			completedCount: 0,
			failedCount: 0,
			pausedCount: 0
		}
	});

	// Prevent concurrent refresh calls (race condition protection)
	let refreshInProgress = false;
	let pendingRefreshRequest: { userId: string; statusFilter?: string[] } | null = null;

	// Helper function to refresh downloads (avoids `this` binding issues)
	async function refreshDownloads(userId: string, statusFilter?: string[]): Promise<void> {
		// If a refresh is already in progress, queue this request instead
		if (refreshInProgress) {
			log.debug('🔄 Refresh already in progress, queuing request for user:', userId);
			pendingRefreshRequest = { userId, statusFilter };
			return;
		}

		refreshInProgress = true;

		try {
			log.debug('🔄 Refreshing downloads for user:', userId);
			const response = (await commands.getDownloads(
				userId,
				statusFilter ?? null
			)) as unknown as { downloads: DownloadInfo[]; stats: DownloadStats };
			log.debug('   Got', response.downloads.length, 'downloads from backend');
			log.debug('   Stats:', response.stats);

			update((state) => {
				const downloadsMap: Record<number, DownloadInfo> = {};

				for (const download of response.downloads) {
					downloadsMap[download.id] = download;
				}

				// No count calculation - use pre-computed stats from Rust!
				return {
					downloads: downloadsMap,
					stats: response.stats
				};
			});
		} catch (error) {
			log.error('Failed to refresh downloads:', error);
			throw error;
		} finally {
			refreshInProgress = false;

			// Process queued request if any
			if (pendingRefreshRequest) {
				const { userId: queuedUserId, statusFilter: queuedFilter } = pendingRefreshRequest;
				pendingRefreshRequest = null;
				await refreshDownloads(queuedUserId, queuedFilter);
			}
		}
	}

	return {
		subscribe,

		/**
		 * Queue a single item for download
		 */
		async downloadItem(
			itemId: string,
			userId: string,
			filePath: string,
			mimeType?: string,
			priority?: number,
			itemName?: string,
			artistName?: string,
			albumName?: string
		): Promise<number> {
			try {
				log.debug('📥 downloadItem called:', { itemId, userId, filePath, itemName, artistName, albumName });
				const downloadId = await commands.downloadItem({
					itemId,
					userId,
					filePath,
					mimeType: mimeType ?? null,
					priority: priority ?? null,
					itemName: itemName ?? null,
					artistName: artistName ?? null,
					albumName: albumName ?? null,
					expectedSize: null
				});
				log.debug('   Got download ID from backend:', downloadId);

				// Fetch download info and add to store
				log.debug('   Refreshing downloads...');
				await refreshDownloads(userId);
				log.debug('   Refresh complete. Store state:', get({ subscribe }));

				return downloadId;
			} catch (error) {
				log.error('Failed to queue download:', error);
				throw error;
			}
		},

		/**
		 * Queue an entire album for download.
		 *
		 * The backend does all of it — listing the album's tracks, queueing them,
		 * resolving each stream URL and starting the queue. It returns the queued
		 * row ids for reporting only; nothing here pairs them back to tracks.
		 *
		 * TRACES: UR-018, UR-055 | DR-173
		 */
		async downloadAlbum(
			handle: string,
			albumId: string,
			userId: string,
			basePath: string
		): Promise<number[]> {
			try {
				log.debug('📥 downloadAlbum called:', { albumId, userId, basePath });
				const downloadIds = await commands.downloadAlbum(handle, albumId, userId, basePath);
				log.debug('   Got download IDs from backend:', downloadIds);

				// Refresh downloads
				await refreshDownloads(userId);

				return downloadIds;
			} catch (error) {
				log.error('Failed to queue album download:', error);
				throw error;
			}
		},

		/**
		 * Queue a video item (movie/episode) for download with quality preset
		 */
		async downloadVideo(
			itemId: string,
			userId: string,
			filePath: string,
			mimeType?: string,
			priority?: number,
			itemName?: string,
			qualityPreset?: string,
			seriesName?: string,
			seasonName?: string,
			episodeNumber?: number,
			seasonNumber?: number
		): Promise<number> {
			try {
				log.debug('🎬 downloadVideo called:', {
					itemId,
					userId,
					filePath,
					itemName,
					qualityPreset,
					seriesName
				});
				const downloadId = await commands.downloadVideo({
					itemId,
					userId,
					filePath,
					mimeType: mimeType ?? null,
					priority: priority ?? null,
					itemName: itemName ?? null,
					qualityPreset: qualityPreset ?? null,
					seriesName: seriesName ?? null,
					seasonName: seasonName ?? null,
					episodeNumber: episodeNumber ?? null,
					seasonNumber: seasonNumber ?? null
				});
				log.debug('   Got download ID from backend:', downloadId);

				// Refresh downloads
				await refreshDownloads(userId);

				return downloadId;
			} catch (error) {
				log.error('Failed to queue video download:', error);
				throw error;
			}
		},

		/**
		 * Queue all episodes of a series for download
		 */
		async downloadSeries(
			seriesId: string,
			seriesName: string,
			userId: string,
			basePath: string,
			qualityPreset?: string
		): Promise<number[]> {
			try {
				log.debug('📺 downloadSeries called:', {
					seriesId,
					seriesName,
					userId,
					basePath,
					qualityPreset
				});
				const downloadIds = await commands.downloadSeries(
					seriesId,
					seriesName,
					userId,
					basePath,
					qualityPreset ?? null
				);
				log.debug('   Queued', downloadIds.length, 'episodes for download');

				// Refresh downloads
				await refreshDownloads(userId);

				return downloadIds;
			} catch (error) {
				log.error('Failed to queue series download:', error);
				throw error;
			}
		},

		/**
		 * Queue all episodes of a season for download
		 */
		async downloadSeason(
			seasonId: string,
			seriesName: string,
			seasonName: string,
			seasonNumber: number,
			userId: string,
			basePath: string,
			qualityPreset?: string
		): Promise<number[]> {
			try {
				log.debug('📺 downloadSeason called:', {
					seasonId,
					seriesName,
					seasonName,
					seasonNumber,
					qualityPreset
				});
				const downloadIds = await commands.downloadSeason(
					seasonId,
					seriesName,
					seasonName,
					seasonNumber,
					userId,
					basePath,
					qualityPreset ?? null
				);
				log.debug('   Queued', downloadIds.length, 'episodes for download');

				// Refresh downloads
				await refreshDownloads(userId);

				return downloadIds;
			} catch (error) {
				log.error('Failed to queue season download:', error);
				throw error;
			}
		},

		/**
		 * Pin an item's metadata (protects from cache clear)
		 */
		async pinItem(itemId: string): Promise<void> {
			try {
				await commands.pinItem(itemId);
			} catch (error) {
				log.error('Failed to pin item:', error);
				throw error;
			}
		},

		/**
		 * Unpin an item's metadata
		 */
		async unpinItem(itemId: string): Promise<void> {
			try {
				await commands.unpinItem(itemId);
			} catch (error) {
				log.error('Failed to unpin item:', error);
				throw error;
			}
		},

		/**
		 * Check if an item is pinned
		 */
		async isItemPinned(itemId: string): Promise<boolean> {
			try {
				return await commands.isItemPinned(itemId);
			} catch (error) {
				log.error('Failed to check pin status:', error);
				return false;
			}
		},

		/**
		 * Pause a download
		 */
		async pause(downloadId: number): Promise<void> {
			try {
				await commands.pauseDownload(downloadId);
			} catch (error) {
				log.error('Failed to pause download:', error);
				throw error;
			}
		},

		/**
		 * Resume a paused download
		 */
		async resume(downloadId: number): Promise<void> {
			try {
				await commands.resumeDownload(downloadId);
			} catch (error) {
				log.error('Failed to resume download:', error);
				throw error;
			}
		},

		/**
		 * Cancel a download
		 */
		async cancel(downloadId: number): Promise<void> {
			try {
				await commands.cancelDownload(downloadId);
			} catch (error) {
				log.error('Failed to cancel download:', error);
				throw error;
			}
		},

		/**
		 * Delete a completed download
		 */
		async delete(downloadId: number): Promise<void> {
			try {
				await commands.deleteDownload(downloadId);
				update((state) => {
					const { [downloadId]: removed, ...remaining } = state.downloads;
					return { ...state, downloads: remaining };
				});
			} catch (error) {
				log.error('Failed to delete download:', error);
				throw error;
			}
		},

		/**
		 * Refresh downloads list from backend
		 */
		refresh: refreshDownloads,

		/**
		 * Update a specific download in the store (for event handling)
		 */
		updateDownload(downloadId: number, updates: Partial<DownloadInfo>): void {
			update((state) => {
				const download = state.downloads[downloadId];
				if (!download) {
					log.debug('   Download not in store:', downloadId);
					return state;
				}

				const updatedDownload = { ...download, ...updates };
				const newDownloads = { ...state.downloads, [downloadId]: updatedDownload };

				log.debug('   Store updated for download', downloadId, ':', updates);
				// No count calculation - stats remain as-is until next refresh
				return {
					downloads: newDownloads,
					stats: state.stats
				};
			});
		},

		/**
		 * Remove a download from the store
		 */
		removeDownload(downloadId: number): void {
			update((state) => {
				const { [downloadId]: removed, ...remaining } = state.downloads;
				if (!removed) return state;

				// No count calculation - stats remain as-is until next refresh
				return {
					downloads: remaining,
					stats: state.stats
				};
			});
		}
	};
}

export const downloads = createDownloadsStore();

// Derived stores
export const activeDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.status === 'downloading')
);

export const completedDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.status === 'completed')
);

export const pendingDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.status === 'pending')
);

export const failedDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.status === 'failed')
);

export const videoDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.mediaType === 'video')
);

export const audioDownloads = derived(downloads, ($d) =>
	Object.values($d.downloads).filter((d) => d.mediaType === 'audio' || !d.mediaType)
);

/**
 * Initialize download event listeners.
 * Should be called once when the app starts (e.g., in +layout.svelte).
 */
export async function initDownloadEvents(): Promise<void> {
	if (isEventsInitialized) {
		log.warn('Download events already initialized');
		return;
	}

	try {
		log.debug('🎧 Setting up download event listener...');
		unlistenFn = await listen<DownloadEvent>('download-event', (event) => {
			const payload = event.payload;
			log.debug('📬 Received download event:', payload.type, 'for download:', payload.downloadId);
			log.debug('   Full event payload:', JSON.stringify(payload));

			// Update the store based on event type
			downloads.subscribe((state) => {
				const download = state.downloads[payload.downloadId];
				log.debug('   Current download state:', download ? download.status : 'NOT IN STORE');
			})(); // Immediately unsubscribe after reading

			handleDownloadEvent(payload);
		});

		isEventsInitialized = true;
		log.debug('✅ Download event listener registered successfully');
	} catch (err) {
		log.error('❌ Failed to register download event listener:', err);
	}
}

/**
 * Clean up download event listeners.
 * Should be called when the app is destroyed.
 */
export function cleanupDownloadEvents(): void {
	if (unlistenFn) {
		unlistenFn();
		unlistenFn = null;
	}
	isEventsInitialized = false;
}

/**
 * Check if the download event listener is initialized.
 */
export function isDownloadEventsInitialized(): boolean {
	return isEventsInitialized;
}

/**
 * Handle a download event and update the store.
 */
function handleDownloadEvent(payload: DownloadEvent): void {
	const currentState = get(downloads);
	const download = currentState.downloads[payload.downloadId];

	switch (payload.type) {
		case 'queued':
			// Just increment queue count - the download will be fetched on refresh
			break;

		case 'started':
			if (download) {
				updateDownloadInStore(payload.downloadId, {
					status: 'downloading',
					startedAt: new Date().toISOString()
				});
			}
			break;

		case 'progress':
			if (download && payload.progress !== undefined) {
				updateDownloadInStore(payload.downloadId, {
					progress: payload.progress,
					bytesDownloaded: payload.bytesDownloaded || download.bytesDownloaded,
					fileSize: payload.totalBytes || download.fileSize
				});
			}
			break;

		case 'completed':
			if (download) {
				// Persist to database
				commands.markDownloadCompleted(
					payload.downloadId,
					payload.totalBytes || download.fileSize || download.bytesDownloaded,
					payload.filePath || download.filePath
				).catch((err) => log.error('Failed to persist download completion:', err));

				updateDownloadInStore(payload.downloadId, {
					status: 'completed',
					progress: 1.0,
					completedAt: new Date().toISOString(),
					filePath: payload.filePath || download.filePath
				});
			}
			break;

		case 'failed':
			if (download) {
				// Persist to database
				commands.markDownloadFailed(
					payload.downloadId,
					payload.error || 'Unknown error'
				).catch((err) => log.error('Failed to persist download failure:', err));

				updateDownloadInStore(payload.downloadId, {
					status: 'failed',
					errorMessage: payload.error
				});
			}
			break;

		case 'paused':
			if (download) {
				updateDownloadInStore(payload.downloadId, {
					status: 'paused'
				});
			}
			break;

		case 'cancelled':
			removeDownloadFromStore(payload.downloadId);
			break;

		case 'waitingForNetwork':
			// Queue-wide, not tied to one download: the pump refused to start
			// anything because WiFi-only is on and we're on a metered network.
			waitingForNetwork.set(true);
			break;
	}

	// Any per-download progress proves the gate isn't holding us any more.
	if (payload.type === 'started' || payload.type === 'progress') {
		waitingForNetwork.set(false);
	}
}

/**
 * Helper to update a download in the store.
 */
function updateDownloadInStore(downloadId: number, updates: Partial<DownloadInfo>): void {
	log.debug('   updateDownloadInStore:', downloadId, updates);
	downloads.updateDownload(downloadId, updates);
}

/**
 * Helper to remove a download from the store.
 */
function removeDownloadFromStore(downloadId: number): void {
	log.debug('   removeDownloadFromStore:', downloadId);
	downloads.removeDownload(downloadId);
}