web-app/src/lib/pages/print/store.svelte.js

// lib/pages/print/store.svelte.js
import { onDestroy, tick } from 'svelte';
import { getPricePerPage } from '$lib/common/utils/pricing.util.js';
import { detectFileType, pagesLabel as _pagesLabel } from '$lib/common/utils/file.util.js';
import { loadPdfDocument, renderPageToImage } from '$lib/common/services/pdf.service.js';

/**
 * @typedef {{ id: number, file: File, previewUrl: string | null, fileType: 'image' | 'pdf' | 'other', expanded: boolean, format: 'A4' | 'A5', colorMode: 'bw' | 'color', qualityIndex: number, copies: number, totalPages: number, selectedPages: Set<number>, pdfDoc: any }} FileEntry
 */

export function createPrintStore() {
	let files = $state(/** @type {FileEntry[]} */ ([]));
	let activeFile = $state(/** @type {FileEntry | null} */ (null));
	let viewMode = $state(/** @type {'gallery' | 'preview'} */ ('gallery'));
	let showPayment = $state(false);
	let isPrinting = $state(false);

	let galleryThumbnails = $state([]);
	let galleryLoading = $state(false);
	let previewPagesCache = $state({});
	let isPreviewRendering = $state(false);

	let uid = 0;

	const totalPrice = $derived(
		files.reduce((sum, f) => {
			const pages = f.selectedPages?.size || 0;
			return sum + pages * f.copies * getPricePerPage(pages);
		}, 0)
	);

	const extraCopies = $derived(files.reduce((sum, f) => sum + (f.copies - 1), 0));

	function updateFile(id, changes) {
		files = files.map((f) => (f.id === id ? { ...f, ...changes } : f));
		if (activeFile?.id === id) {
			activeFile = files.find((f) => f.id === id);
		}
	}

	async function ensurePdfLoaded(entry) {
		if (entry.pdfDoc) return entry.pdfDoc;
		const pdf = await loadPdfDocument(entry.file);
		if (pdf) {
			const numPages = pdf.numPages;
			updateFile(entry.id, {
				pdfDoc: pdf,
				totalPages: numPages,
				selectedPages: new Set(Array.from({ length: numPages }, (_, i) => i + 1))
			});
		} else {
			updateFile(entry.id, { totalPages: 0 });
		}
		return pdf;
	}

	async function addFiles(fileList) {
		if (!fileList || fileList.length === 0) return;
		const newFiles = [];
		for (let i = 0; i < fileList.length; i++) {
			const file = fileList[i];
			const fType = detectFileType(file);
			newFiles.push({
				id: ++uid,
				file,
				previewUrl: URL.createObjectURL(file),
				fileType: fType,
				expanded: false,
				format: 'A4',
				colorMode: 'bw',
				qualityIndex: 1,
				copies: 1,
				totalPages: fType === 'image' ? 1 : 0,
				selectedPages: fType === 'image' ? new Set([1]) : new Set(),
				pdfDoc: null
			});
		}
		files = [...files, ...newFiles];
		for (const entry of newFiles) {
			if (entry.fileType === 'pdf') ensurePdfLoaded(entry);
		}
	}

	function removeFile(id) {
		const f = files.find((x) => x.id === id);
		if (f?.previewUrl) URL.revokeObjectURL(f.previewUrl);
		files = files.filter((x) => x.id !== id);
	}

	function toggleExpand(id) {
		updateFile(id, { expanded: !files.find((f) => f.id === id)?.expanded });
	}

	async function openGallery(entry) {
		activeFile = entry;
		viewMode = 'gallery';
		galleryThumbnails = [];
		galleryLoading = true;
		previewPagesCache = {};
		await tick();

		const pdf = await ensurePdfLoaded(entry);
		if (!pdf || entry.totalPages === 0) {
			galleryLoading = false;
			return;
		}

		const thumbs = [];
		for (let i = 1; i <= entry.totalPages; i++) {
			try {
				thumbs.push(await renderPageToImage(pdf, i, 0.4));
			} catch {
				thumbs.push('');
			}
			galleryThumbnails = [...thumbs];
		}
		galleryLoading = false;
	}

	async function openPreview(entry) {
		activeFile = entry;
		viewMode = 'preview';
		previewPagesCache = {};
		galleryThumbnails = [];
		await tick();
		if (entry.fileType === 'pdf') {
			const pdf = await ensurePdfLoaded(entry);
			if (pdf && entry.totalPages > 0) {
				preloadPreviewPages(entry, 1, 5);
			}
		}
	}

	async function preloadPreviewPages(entry, startPage, count) {
		const currentFile = files.find((f) => f.id === entry.id);
		const pdf = currentFile?.pdfDoc || entry.pdfDoc;
		if (!pdf || isPreviewRendering) return;

		isPreviewRendering = true;
		const endPage = Math.min(startPage + count - 1, entry.totalPages);
		const newCache = {};

		for (let i = startPage; i <= endPage; i++) {
			if (previewPagesCache[i]) continue;
			try {
				newCache[i] = await renderPageToImage(pdf, i, 1.5);
			} catch (e) {
				console.error(`Failed to render preview page ${i}`, e);
			}
		}

		if (Object.keys(newCache).length > 0) {
			previewPagesCache = { ...previewPagesCache, ...newCache };
		}
		isPreviewRendering = false;
	}

	function togglePageSelection(pageNum) {
		if (!activeFile?.selectedPages) return;
		const newSet = new Set(activeFile.selectedPages);
		if (newSet.has(pageNum)) {
			if (newSet.size > 1) newSet.delete(pageNum);
		} else {
			newSet.add(pageNum);
		}
		updateFile(activeFile.id, { selectedPages: newSet });
	}

	function selectAllPages() {
		if (!activeFile?.totalPages) return;
		updateFile(activeFile.id, {
			selectedPages: new Set(Array.from({ length: activeFile.totalPages }, (_, i) => i + 1))
		});
	}

	function deselectAllPages() {
		if (!activeFile) return;
		updateFile(activeFile.id, { selectedPages: new Set([1]) });
	}

	async function submitPrint() {
		if (files.length === 0 || isPrinting) return;
		isPrinting = true;
		const formData = new FormData();
		for (const f of files) {
			formData.append('files', f.file, f.file.name);
			formData.append(
				'settings',
				JSON.stringify({
					filename: f.file.name,
					pages: f.selectedPages ? Array.from(f.selectedPages).sort((a, b) => a - b).join(',') : 'all',
					copies: f.copies,
					colorMode: f.colorMode,
					format: f.format
				})
			);
		}
		try {
			const res = await fetch('/api/print', { method: 'POST', body: formData });
			const text = await res.text();
			alert(res.ok ? `✅ Успешно!\n${text}` : `❌ Ошибка (${res.status}):\n${text}`);
		} catch {
			alert('⚠️ Не удалось связаться с сервером печати.');
		} finally {
			isPrinting = false;
			showPayment = false;
		}
	}

	onDestroy(() => {
		files.forEach((f) => f.previewUrl && URL.revokeObjectURL(f.previewUrl));
	});

	return {
		get files() { return files; },
		get activeFile() { return activeFile; },
		get viewMode() { return viewMode; },
		get showPayment() { return showPayment; },
		get isPrinting() { return isPrinting; },
		get totalPrice() { return totalPrice; },
		get extraCopies() { return extraCopies; },
		get galleryThumbnails() { return galleryThumbnails; },
		get galleryLoading() { return galleryLoading; },
		get previewPagesCache() { return previewPagesCache; },
		get isPreviewRendering() { return isPreviewRendering; },

		addFiles,
		removeFile,
		toggleExpand,
		updateFile,
		openGallery,
		openPreview,
		closeOverlay: () => { activeFile = null; galleryThumbnails = []; previewPagesCache = {}; },
		openPayment: () => { if (files.length > 0 && !isPrinting) showPayment = true; },
		hidePayment: () => { showPayment = false; },
		submitPrint,
		togglePageSelection,
		selectAllPages,
		deselectAllPages,
		requestPreviewPages: (start, count) => { if (activeFile) preloadPreviewPages(activeFile, start, count); },
		pagesLabel: _pagesLabel
	};
}