script.js

// ============================================================================
// PDF ALCHEMY v1.4.0
// ============================================================================
'use strict';

const CONFIG = {
    MAX_FILE_SIZE: 200 * 1024 * 1024, // 200MB
    MAX_PAGES: 1000,
    MAX_FILES: 30,
    SUPPORTED_PDF_TYPES: ['application/pdf'],
    SUPPORTED_IMAGE_TYPES: ['image/jpeg', 'image/jpg', 'image/png', 'image/webp']
};

const SINGLE_FILE_TOOLS = new Set([
    'split', 'organize', 'pdf-to-img', 'unlock',
    'compress', 'watermark', 'metadata', 'extract-text', 'page-numbers'
]);

const TOOL_INFO = {
    'merge':        { title: 'Merge PDFs',     desc: 'Combine multiple PDF files into one document. Drag rows to reorder.', accept: '.pdf', label: 'Merge', icon: 'fa-copy' },
    'split':        { title: 'Split PDF',      desc: 'Extract specific page ranges into a new PDF, or burst into one PDF per page.', accept: '.pdf', label: 'Split', icon: 'fa-scissors' },
    'organize':     { title: 'Organize & Rotate', desc: 'Visually delete, rotate, and reorder pages of a PDF.', accept: '.pdf', label: 'Save', icon: 'fa-floppy-disk' },
    'compress':     { title: 'Compress PDF',   desc: 'Shrink file size by re-encoding pages as compressed JPEG images.', accept: '.pdf', label: 'Compress', icon: 'fa-file-zipper' },
    'pdf-to-img':   { title: 'PDF to Images',  desc: 'Render every page of your PDF as a high-resolution image (delivered as a ZIP).', accept: '.pdf', label: 'Convert', icon: 'fa-images' },
    'img-to-pdf':   { title: 'Images to PDF',  desc: 'Combine images into one multi-page PDF. JPG, PNG, WebP supported.', accept: '.png,.jpg,.jpeg,.webp', label: 'Build PDF', icon: 'fa-file-pdf' },
    'unlock':       { title: 'Unlock PDF',     desc: 'Remove restrictions from a PDF. Works for many PDFs where the owner password is blank or the file is otherwise editable.', accept: '.pdf', label: 'Unlock', icon: 'fa-lock-open' },
    'watermark':    { title: 'Watermark',      desc: 'Stamp every page with text. Customize size, position, color, and opacity.', accept: '.pdf', label: 'Apply', icon: 'fa-stamp' },
    'page-numbers': { title: 'Page Numbers',   desc: 'Insert page numbers in any corner with custom formatting.', accept: '.pdf', label: 'Number', icon: 'fa-list-ol' },
    'metadata':     { title: 'Edit Metadata',  desc: 'Update title, author, subject, and keywords of a PDF.', accept: '.pdf', label: 'Save', icon: 'fa-floppy-disk' },
    'extract-text': { title: 'Extract Text',   desc: 'Pull all text from your PDF into a plain text file.', accept: '.pdf', label: 'Extract', icon: 'fa-file-export' }
};

// State
let currentTool = 'merge';
let files = [];
let isProcessing = false;
let lastResult = null;
let dragDepth = 0;

// Library init
pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';
const { PDFDocument, degrees, rgb, StandardFonts } = PDFLib;

// DOM
const dropZone = document.getElementById('drop-zone');
const fileInput = document.getElementById('file-input');
const fileList = document.getElementById('file-list');
const processBtn = document.getElementById('process-btn');
const processBtnLabel = document.getElementById('process-btn-label');
const processBtnIcon = document.getElementById('process-btn-icon');
const optionsPanel = document.getElementById('options-panel');
const toolTitle = document.getElementById('current-tool-title');
const toolDesc = document.getElementById('tool-desc');
const contentContainer = document.getElementById('content-container');
const fileBadge = document.getElementById('file-badge');
const dropzoneHint = document.getElementById('dropzone-hint');
const resultPanel = document.getElementById('result-panel');
const sidebar = document.querySelector('aside.sidebar');
const sidebarBackdrop = document.getElementById('sidebar-backdrop');

// ---------- Init ----------
initDragAndDrop();
initKeyboard();
setupErrorHandlers();
switchTool('merge'); // sets header, button label, etc.
updateUI();

// ---------- Notifications ----------
function showNotification(message, type = 'info', duration = 4000) {
    const stack = document.getElementById('notification-stack');
    const note = document.createElement('div');
    note.className = `notification notification-${type} rounded-lg shadow-2xl p-4 flex items-start gap-3`;
    const iconMap = {
        'success': 'fa-circle-check text-green-700',
        'error':   'fa-circle-xmark text-red-700',
        'warning': 'fa-triangle-exclamation text-yellow-700',
        'info':    'fa-circle-info text-blue-700'
    };
    note.innerHTML = `
        <i class="fa-solid ${iconMap[type]} text-xl mt-0.5"></i>
        <div class="flex-1 text-sm font-medium text-gray-900" style="white-space: pre-line;">${escapeHtml(message)}</div>
        <button onclick="this.parentElement.classList.add('hiding'); setTimeout(()=>this.parentElement.remove(),300)" class="text-gray-500 hover:text-gray-700 flex-shrink-0">
            <i class="fa-solid fa-xmark"></i>
        </button>
    `;
    stack.appendChild(note);
    if (duration > 0) {
        setTimeout(() => {
            note.classList.add('hiding');
            setTimeout(() => note.remove(), 300);
        }, duration);
    }
}

function escapeHtml(s) {
    return String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
}

function setupErrorHandlers() {
    window.addEventListener('error', (e) => {
        console.error('Global error:', e.error);
        if (isProcessing) abortProcessing('Unexpected error: ' + (e.error?.message || 'unknown'));
    });
    window.addEventListener('unhandledrejection', (e) => {
        console.error('Unhandled rejection:', e.reason);
        if (isProcessing) abortProcessing('Operation failed: ' + (e.reason?.message || 'unknown'));
    });
}

// ---------- Keyboard shortcuts ----------
function initKeyboard() {
    document.addEventListener('keydown', (e) => {
        if (e.key === 'Escape') {
            if (document.getElementById('preview-modal')) {
                closePreview();
                return;
            }
            if (isProcessing) return; // ignore during processing
            if (sidebar.classList.contains('open')) toggleSidebar(false);
        }
        if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
            if (!processBtn.disabled) {
                e.preventDefault();
                processFiles();
            }
        }
    });
}

// ---------- Sidebar mobile ----------
function toggleSidebar(open) {
    sidebar.classList.toggle('open', open);
    sidebarBackdrop.classList.toggle('show', open);
}

// ---------- Tool switching ----------
function switchTool(tool) {
    if (!TOOL_INFO[tool]) return;
    currentTool = tool;

    contentContainer.classList.remove('animate-fade-in');
    void contentContainer.offsetWidth;
    contentContainer.classList.add('animate-fade-in');

    document.querySelectorAll('.tool-btn').forEach(btn => btn.classList.remove('active'));
    document.getElementById(`btn-${tool}`).classList.add('active');

    const info = TOOL_INFO[tool];
    toolTitle.textContent = info.title;
    toolDesc.textContent = info.desc;
    processBtnLabel.textContent = info.label;
    processBtnIcon.className = `fa-solid ${info.icon}`;
    fileInput.accept = info.accept;
    dropzoneHint.textContent = tool === 'img-to-pdf' ? 'JPG, PNG, WebP images' : 'PDF files only';

    renderOptionsPanel();
    hideResult();

    // Clean up incompatible files between tool switches
    if (files.length > 0) {
        const hasImages = files.some(f => f.file.type.startsWith('image/'));
        const wantsImages = (tool === 'img-to-pdf');
        if (hasImages !== wantsImages) {
            clearAll();
        } else if (SINGLE_FILE_TOOLS.has(tool) && files.length > 1) {
            files = [files[0]];
        }
    }
    renderFileList();
    updateUI();

    // close sidebar on mobile after pick
    if (window.innerWidth < 768) toggleSidebar(false);
}

// ---------- Options panel ----------
function renderOptionsPanel() {
    optionsPanel.innerHTML = '';
    optionsPanel.classList.add('hidden');

    const panels = {
        'split': () => `
            <h4 class="font-bold text-sm mb-3">Split Settings</h4>
            <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Page Ranges</label>
            <input type="text" id="split-range" placeholder="e.g. 1-3, 5, 7-9" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm font-mono focus:outline-none focus:border-brand-primary">
            <p class="text-xs text-brand-gray mt-2">Leave empty to burst every page into its own PDF (ZIP output).</p>
        `,
        'compress': () => `
            <h4 class="font-bold text-sm mb-3">Compression Settings</h4>
            <div class="flex justify-between items-center mb-1">
                <label class="block text-xs font-bold text-brand-gray uppercase">JPEG Quality</label>
                <span class="text-xs font-mono bg-brand-secondary px-2 py-0.5 rounded text-brand-dark" id="quality-val">Balanced</span>
            </div>
            <input type="range" id="compress-quality" min="0.1" max="0.95" step="0.05" value="0.6" oninput="updateQualityLabel(this.value)" class="w-full accent-brand-primary cursor-pointer h-2 bg-gray-200 rounded-lg appearance-none">
            <div class="flex justify-between text-[10px] text-brand-gray mt-1 font-mono uppercase">
                <span>Smaller File</span>
                <span>Higher Quality</span>
            </div>
            <div class="mt-3 grid grid-cols-2 gap-3">
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Resolution</label>
                    <select id="compress-resolution" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                        <option value="1.0">Standard (1x)</option>
                        <option value="1.5" selected>High (1.5x)</option>
                        <option value="2.0">Sharp (2x)</option>
                    </select>
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Mode</label>
                    <select id="compress-mode" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                        <option value="rasterize">Rasterize (smaller)</option>
                        <option value="rewrite">Re-save only (lossless)</option>
                    </select>
                </div>
            </div>
            <p class="text-xs text-amber-700 mt-3 bg-amber-50 p-2 rounded border border-amber-100 flex gap-2">
                <i class="fa-solid fa-circle-info mt-0.5"></i>
                <span>Rasterize loses text selection. Re-save only removes unused objects without altering content.</span>
            </p>
        `,
        'img-to-pdf': () => `
            <h4 class="font-bold text-sm mb-3">Output Settings</h4>
            <div class="grid grid-cols-2 gap-3">
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Page Size</label>
                    <select id="img-page-size" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                        <option value="fit">Fit image</option>
                        <option value="A4">A4 (210x297mm)</option>
                        <option value="Letter">Letter (8.5x11in)</option>
                    </select>
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Orientation</label>
                    <select id="img-orientation" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                        <option value="auto">Auto</option>
                        <option value="portrait">Portrait</option>
                        <option value="landscape">Landscape</option>
                    </select>
                </div>
            </div>
            <div class="mt-3">
                <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Margin (pts)</label>
                <input type="number" id="img-margin" value="0" min="0" max="200" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
            </div>
        `,
        'unlock': () => `
            <h4 class="font-bold text-sm mb-3">Unlock Options</h4>
            <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Password (if any)</label>
            <input type="password" id="unlock-password" placeholder="Leave blank to try without password" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm font-mono focus:outline-none focus:border-brand-primary">
            <p class="text-xs text-brand-gray mt-2">Works for most PDFs where you already know the password, or where only the owner restrictions need removing.</p>
        `,
        'watermark': () => `
            <h4 class="font-bold text-sm mb-3">Watermark Settings</h4>
            <div class="space-y-4">
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Watermark Text</label>
                    <input type="text" id="watermark-text" placeholder="CONFIDENTIAL" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                </div>
                <div class="grid grid-cols-2 gap-4">
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Font Size</label>
                        <input type="number" id="watermark-size" value="64" min="8" max="288" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                    </div>
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Opacity</label>
                        <div class="flex items-center gap-2">
                            <input type="range" id="watermark-opacity" min="0.05" max="1" step="0.05" value="0.3" class="flex-1 accent-brand-primary cursor-pointer h-2 bg-gray-200 rounded-lg appearance-none">
                            <span id="watermark-opacity-val" class="text-xs font-mono w-10 text-right">30%</span>
                        </div>
                    </div>
                </div>
                <div class="grid grid-cols-2 gap-4">
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Position</label>
                        <select id="watermark-position" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                            <option value="diagonal" selected>Diagonal</option>
                            <option value="center">Center</option>
                            <option value="top">Top</option>
                            <option value="bottom">Bottom</option>
                        </select>
                    </div>
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Color</label>
                        <input type="color" id="watermark-color" value="#D4A5A5" class="w-full h-9 bg-brand-base border border-gray-200 rounded cursor-pointer">
                    </div>
                </div>
            </div>
        `,
        'page-numbers': () => `
            <h4 class="font-bold text-sm mb-3">Numbering Settings</h4>
            <div class="space-y-4">
                <div class="grid grid-cols-2 gap-4">
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Format</label>
                        <select id="pn-format" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                            <option value="n">1</option>
                            <option value="n/total">1 / 10</option>
                            <option value="page-n">Page 1</option>
                            <option value="page-n-of-total" selected>Page 1 of 10</option>
                        </select>
                    </div>
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Position</label>
                        <select id="pn-position" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                            <option value="bottom-center" selected>Bottom Center</option>
                            <option value="bottom-right">Bottom Right</option>
                            <option value="bottom-left">Bottom Left</option>
                            <option value="top-center">Top Center</option>
                            <option value="top-right">Top Right</option>
                            <option value="top-left">Top Left</option>
                        </select>
                    </div>
                </div>
                <div class="grid grid-cols-3 gap-4">
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Size</label>
                        <input type="number" id="pn-size" value="11" min="6" max="36" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                    </div>
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Start at</label>
                        <input type="number" id="pn-start" value="1" min="1" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                    </div>
                    <div>
                        <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Color</label>
                        <input type="color" id="pn-color" value="#2B2D31" class="w-full h-9 bg-brand-base border border-gray-200 rounded cursor-pointer">
                    </div>
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Skip First Page</label>
                    <label class="flex items-center gap-2 text-sm text-brand-dark">
                        <input type="checkbox" id="pn-skip-first" class="accent-brand-primary">
                        <span>Don't number the cover/first page</span>
                    </label>
                </div>
            </div>
        `,
        'metadata': () => `
            <h4 class="font-bold text-sm mb-3">PDF Metadata</h4>
            <div class="space-y-3">
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Title</label>
                    <input type="text" id="meta-title" placeholder="Document Title" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Author</label>
                    <input type="text" id="meta-author" placeholder="Author Name" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Subject</label>
                    <input type="text" id="meta-subject" placeholder="Document Subject" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                </div>
                <div>
                    <label class="block text-xs font-bold text-brand-gray mb-1 uppercase">Keywords</label>
                    <input type="text" id="meta-keywords" placeholder="keyword1, keyword2, keyword3" class="w-full bg-brand-base border border-gray-200 rounded p-2 text-sm focus:outline-none focus:border-brand-primary">
                </div>
            </div>
        `
    };

    const fn = panels[currentTool];
    if (!fn) return;
    optionsPanel.classList.remove('hidden');
    optionsPanel.innerHTML = fn();

    // wire dynamic labels
    const op = document.getElementById('watermark-opacity');
    if (op) op.addEventListener('input', () => {
        document.getElementById('watermark-opacity-val').textContent = Math.round(op.value * 100) + '%';
    });
    // prefill metadata from loaded file
    if (currentTool === 'metadata') prefillMetadata();
}

async function prefillMetadata() {
    if (!files[0]) return;
    try {
        const buf = await files[0].file.arrayBuffer();
        const doc = await PDFDocument.load(buf, { ignoreEncryption: true });
        const set = (id, v) => { const el = document.getElementById(id); if (el && !el.value) el.value = v || ''; };
        set('meta-title', doc.getTitle());
        set('meta-author', doc.getAuthor());
        set('meta-subject', doc.getSubject());
        set('meta-keywords', (doc.getKeywords() || ''));
    } catch (e) { /* ignore */ }
}

function updateQualityLabel(val) {
    const label = document.getElementById('quality-val');
    if (!label) return;
    const v = parseFloat(val);
    if (v <= 0.3) label.textContent = 'Max Compression';
    else if (v <= 0.6) label.textContent = 'Balanced';
    else if (v <= 0.85) label.textContent = 'High Quality';
    else label.textContent = 'Near Lossless';
}

// ---------- File handling ----------
function initDragAndDrop() {
    dropZone.addEventListener('click', () => fileInput.click());

    ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(name => {
        dropZone.addEventListener(name, preventDefaults);
        document.body.addEventListener(name, preventDefaults);
    });

    // Body-level visual cue (counter avoids flicker on children)
    document.body.addEventListener('dragenter', () => {
        dragDepth++;
        document.body.classList.add('drag-active');
    });
    document.body.addEventListener('dragleave', () => {
        dragDepth--;
        if (dragDepth <= 0) {
            dragDepth = 0;
            document.body.classList.remove('drag-active');
        }
    });
    document.body.addEventListener('drop', () => {
        dragDepth = 0;
        document.body.classList.remove('drag-active');
    });

    ['dragenter', 'dragover'].forEach(n => dropZone.addEventListener(n, () => dropZone.classList.add('active')));
    ['dragleave', 'drop'].forEach(n => dropZone.addEventListener(n, () => dropZone.classList.remove('active')));

    dropZone.addEventListener('drop', e => handleFiles({ target: { files: e.dataTransfer.files } }));
    fileInput.addEventListener('change', handleFiles);
}

function preventDefaults(e) { e.preventDefault(); e.stopPropagation(); }

async function handleFiles(e) {
    const uploaded = [...e.target.files];
    if (uploaded.length === 0) return;
    if (files.length + uploaded.length > CONFIG.MAX_FILES) {
        showNotification(`Maximum ${CONFIG.MAX_FILES} files at once.`, 'warning');
        return;
    }

    const isImgTool = currentTool === 'img-to-pdf';
    const valid = [];
    for (const file of uploaded) {
        const isImg = CONFIG.SUPPORTED_IMAGE_TYPES.includes(file.type);
        const isPdf = CONFIG.SUPPORTED_PDF_TYPES.includes(file.type);

        if (isImgTool && !isImg) {
            showNotification(`${file.name}: image required`, 'error');
            continue;
        }
        if (!isImgTool && !isPdf) {
            showNotification(`${file.name}: PDF required`, 'error');
            continue;
        }
        if (file.size === 0) { showNotification(`${file.name}: empty file`, 'error'); continue; }
        if (file.size > CONFIG.MAX_FILE_SIZE) {
            showNotification(`${file.name}: over ${Math.round(CONFIG.MAX_FILE_SIZE/1024/1024)}MB limit`, 'error');
            continue;
        }
        valid.push(file);
    }

    if (valid.length === 0) return;

    if (SINGLE_FILE_TOOLS.has(currentTool)) {
        if (files.length > 0 || valid.length > 1) {
            files = [];
            if (valid.length > 1) showNotification('This tool processes one file at a time. Using the first.', 'info');
            valid.length = 1;
        }
    }

    for (const file of valid) {
        files.push({
            id: genId(),
            file,
            name: file.name,
            size: formatSize(file.size),
            rawSize: file.size,
            pageCount: 0
        });
    }

    hideResult();
    await generateThumbnails();
    renderFileList();
    updateUI();

    if (currentTool === 'metadata') prefillMetadata();

    // reset input so re-selecting the same file fires change
    fileInput.value = '';
}

function genId() {
    if (window.crypto?.randomUUID) return crypto.randomUUID().substring(0, 9);
    return Math.random().toString(36).substring(2, 11);
}

async function generateThumbnails() {
    for (const f of files) {
        if (f.thumbnail) continue;
        if (f.file.type === 'application/pdf') {
            try {
                const buf = await f.file.arrayBuffer();
                const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
                f.pageCount = pdf.numPages;
                if (f.pageCount > CONFIG.MAX_PAGES) {
                    showNotification(`${f.name}: ${f.pageCount} pages (limit ${CONFIG.MAX_PAGES}). May be slow.`, 'warning');
                }
                const page = await pdf.getPage(1);
                const vp = page.getViewport({ scale: 0.5 });
                const canvas = document.createElement('canvas');
                canvas.width = vp.width; canvas.height = vp.height;
                await page.render({ canvasContext: canvas.getContext('2d'), viewport: vp }).promise;
                f.thumbnail = canvas.toDataURL('image/jpeg', 0.75);
                pdf.destroy?.();
            } catch (err) {
                console.error('Thumbnail error:', err);
                if (err?.name === 'PasswordException') {
                    f.encrypted = true;
                    showNotification(`${f.name}: encrypted PDF detected. Use the Unlock tool first.`, 'warning', 6000);
                }
                f.thumbnail = null;
            }
        } else if (f.file.type.startsWith('image/')) {
            f.thumbnail = URL.createObjectURL(f.file);
            f.pageCount = 1;
        }
    }
}

function removeFile(id) {
    const f = files.find(x => x.id === id);
    if (f?.thumbnail?.startsWith('blob:')) URL.revokeObjectURL(f.thumbnail);
    files = files.filter(x => x.id !== id);
    renderFileList(); updateUI();
}

function clearAll() {
    files.forEach(f => { if (f.thumbnail?.startsWith('blob:')) URL.revokeObjectURL(f.thumbnail); });
    files = [];
    renderFileList(); updateUI(); hideResult();
    fileInput.value = '';
}

function updateUI() {
    const disabled = files.length === 0;
    processBtn.disabled = disabled;
    if (disabled) processBtn.classList.add('opacity-50', 'cursor-not-allowed', 'transform-none', 'shadow-none');
    else processBtn.classList.remove('opacity-50', 'cursor-not-allowed', 'transform-none', 'shadow-none');

    if (files.length > 0) {
        fileBadge.classList.remove('hidden');
        fileBadge.textContent = `${files.length} file${files.length === 1 ? '' : 's'}`;
    } else {
        fileBadge.classList.add('hidden');
    }
}

function formatSize(bytes) {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

// ---------- Rendering ----------
function renderFileList() {
    fileList.innerHTML = '';
    if (currentTool === 'organize' && files.length > 0) {
        renderOrganizeView();
        return;
    }

    files.forEach((f, index) => {
        const el = document.createElement('div');
        el.className = 'file-item bg-white p-3 md:p-4 rounded-lg border border-gray-100 shadow-sm flex items-center gap-3 md:gap-4 group hover:border-brand-primary transition-colors animate-fade-in';
        el.style.animationDelay = `${Math.min(index, 10) * 40}ms`;
        el.dataset.index = index;
        const canPreview = f.file.type === 'application/pdf';
        el.innerHTML = `
            <div class="w-6 md:w-8 text-brand-gray font-mono text-sm text-center">${index + 1}</div>
            <div class="w-12 h-16 bg-gray-50 rounded overflow-hidden border border-gray-200 flex-shrink-0 ${canPreview ? 'cursor-zoom-in hover:ring-2 hover:ring-brand-primary' : ''}" ${canPreview ? `onclick="previewFile('${f.id}')"` : ''}>
                ${f.thumbnail
                    ? `<img src="${f.thumbnail}" class="w-full h-full object-cover">`
                    : `<div class="w-full h-full flex items-center justify-center text-brand-gray"><i class="fa-solid fa-file-pdf"></i></div>`}
            </div>
            <div class="flex-1 min-w-0">
                <h4 class="font-medium text-sm text-brand-dark truncate">${escapeHtml(f.name)}</h4>
                <p class="text-xs text-brand-gray font-mono mt-0.5">${f.size}${f.pageCount ? ` • ${f.pageCount} page${f.pageCount === 1 ? '' : 's'}` : ''}${f.encrypted ? ' • <span class="text-amber-700">encrypted</span>' : ''}</p>
            </div>
            ${canPreview ? `<button onclick="previewFile('${f.id}')" title="Preview" class="hidden sm:flex w-8 h-8 items-center justify-center rounded-full text-brand-gray hover:bg-gray-100"><i class="fa-solid fa-eye"></i></button>` : ''}
            <button onclick="removeFile('${f.id}')" title="Remove" class="w-8 h-8 flex items-center justify-center rounded-full text-brand-gray hover:bg-red-50 hover:text-red-500 transition-colors">
                <i class="fa-solid fa-trash-can"></i>
            </button>
            ${currentTool === 'merge' ? `<div class="cursor-move text-brand-grayLight hover:text-brand-gray drag-handle"><i class="fa-solid fa-grip-vertical"></i></div>` : ''}
        `;

        if (currentTool === 'merge') {
            el.draggable = true;
            el.addEventListener('dragstart', e => {
                el.classList.add('dragging');
                e.dataTransfer.effectAllowed = 'move';
                e.dataTransfer.setData('text/plain', String(index));
            });
            el.addEventListener('dragend', () => {
                el.classList.remove('dragging');
                document.querySelectorAll('.file-item').forEach(it => it.classList.remove('drag-over'));
            });
            el.addEventListener('dragover', e => {
                e.preventDefault();
                if (document.querySelector('.dragging') !== el) el.classList.add('drag-over');
            });
            el.addEventListener('dragleave', () => el.classList.remove('drag-over'));
            el.addEventListener('drop', e => {
                e.preventDefault();
                el.classList.remove('drag-over');
                const oldIndex = parseInt(e.dataTransfer.getData('text/plain'));
                if (!isNaN(oldIndex) && oldIndex !== index) {
                    const item = files.splice(oldIndex, 1)[0];
                    files.splice(index, 0, item);
                    fileList.style.opacity = '0.5';
                    setTimeout(() => { renderFileList(); fileList.style.opacity = '1'; }, 120);
                }
            });
        }

        fileList.appendChild(el);
    });
}

async function renderOrganizeView() {
    const f = files[0];
    fileList.innerHTML = `
        <div class="flex justify-between items-center mb-4 animate-fade-in">
            <h3 class="font-bold text-brand-dark truncate">${escapeHtml(f.name)}</h3>
            <span class="text-xs font-mono text-brand-gray flex-shrink-0 ml-2">${f.pageOps ? f.pageOps.filter(p=>!p.deleted).length : f.pageCount} / ${f.pageCount} pages</span>
        </div>
    `;
    const grid = document.createElement('div');
    grid.className = 'pdf-grid';
    grid.id = 'pages-grid';
    fileList.appendChild(grid);

    if (!f.pageOps) {
        grid.innerHTML = '<p class="col-span-full text-sm text-brand-gray text-center py-10"><i class="fa-solid fa-spinner fa-spin mr-2"></i> Loading pages...</p>';
        f.pageOps = [];
        try {
            const buf = await f.file.arrayBuffer();
            const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
            for (let i = 1; i <= pdf.numPages; i++) {
                const page = await pdf.getPage(i);
                const vp = page.getViewport({ scale: 0.3 });
                const canvas = document.createElement('canvas');
                canvas.width = vp.width; canvas.height = vp.height;
                await page.render({ canvasContext: canvas.getContext('2d'), viewport: vp }).promise;
                f.pageOps.push({
                    originalIndex: i - 1,
                    rotation: 0,
                    deleted: false,
                    thumb: canvas.toDataURL('image/jpeg', 0.7)
                });
            }
            grid.innerHTML = '';
        } catch (e) {
            console.error(e);
            grid.innerHTML = '<p class="col-span-full text-red-500 text-sm text-center py-10">Failed to load pages.</p>';
            return;
        }
    } else {
        grid.innerHTML = '';
    }

    let draggedIndex = null;
    f.pageOps.forEach((page, idx) => {
        if (page.deleted) return;
        const card = document.createElement('div');
        card.className = 'page-card relative group bg-white p-2 rounded-lg border border-gray-200 shadow-sm hover:shadow-md transition-all animate-fade-in';
        card.style.animationDelay = `${Math.min(idx, 30) * 15}ms`;
        card.draggable = true;
        card.innerHTML = `
            <div class="relative overflow-hidden rounded bg-gray-50 aspect-[3/4] flex items-center justify-center">
                <img src="${page.thumb}" style="transform: rotate(${page.rotation}deg); transition: transform 0.3s;" class="max-w-full max-h-full object-contain pointer-events-none">
                <div class="absolute inset-0 bg-black/60 opacity-0 group-hover:opacity-100 flex items-center justify-center gap-2 transition-opacity">
                    <button onclick="rotatePage(${idx}, -90)" title="Rotate left" class="w-9 h-9 bg-white rounded-full flex items-center justify-center hover:bg-brand-secondary transition-colors"><i class="fa-solid fa-rotate-left"></i></button>
                    <button onclick="rotatePage(${idx}, 90)" title="Rotate right" class="w-9 h-9 bg-white rounded-full flex items-center justify-center hover:bg-brand-secondary transition-colors"><i class="fa-solid fa-rotate-right"></i></button>
                    <button onclick="deletePage(${idx})" title="Delete page" class="w-9 h-9 bg-white rounded-full flex items-center justify-center hover:bg-red-100 text-red-500 transition-colors"><i class="fa-solid fa-trash"></i></button>
                </div>
            </div>
            <div class="mt-2 text-center text-xs font-mono text-brand-gray">Page ${page.originalIndex + 1}</div>
        `;
        card.addEventListener('dragstart', e => {
            draggedIndex = idx;
            card.classList.add('dragging');
            e.dataTransfer.effectAllowed = 'move';
            e.dataTransfer.setData('text/plain', String(idx));
        });
        card.addEventListener('dragend', () => {
            card.classList.remove('dragging');
            document.querySelectorAll('.page-card').forEach(c => c.classList.remove('drag-over'));
            draggedIndex = null;
        });
        card.addEventListener('dragover', e => {
            e.preventDefault();
            if (draggedIndex !== null && draggedIndex !== idx) card.classList.add('drag-over');
        });
        card.addEventListener('dragleave', () => card.classList.remove('drag-over'));
        card.addEventListener('drop', e => {
            e.preventDefault();
            card.classList.remove('drag-over');
            if (draggedIndex !== null && draggedIndex !== idx) {
                const moved = f.pageOps.splice(draggedIndex, 1)[0];
                f.pageOps.splice(idx, 0, moved);
                grid.style.opacity = '0.6';
                setTimeout(() => { renderOrganizeView(); grid.style.opacity = '1'; }, 120);
            }
        });
        grid.appendChild(card);
    });

    if (f.pageOps.filter(p => !p.deleted).length === 0) {
        grid.innerHTML = '<p class="col-span-full text-sm text-brand-gray text-center py-10">All pages deleted. <button class="text-brand-primary underline" onclick="restoreAllPages()">Restore</button></p>';
    }
}

function rotatePage(idx, deg) {
    const op = files[0].pageOps[idx];
    op.rotation = (op.rotation + deg + 360) % 360;
    renderOrganizeView();
}
function deletePage(idx) {
    files[0].pageOps[idx].deleted = true;
    renderOrganizeView();
}
function restoreAllPages() {
    files[0].pageOps.forEach(p => p.deleted = false);
    renderOrganizeView();
}

// ---------- Preview modal ----------
async function previewFile(id) {
    const f = files.find(x => x.id === id);
    if (!f || f.file.type !== 'application/pdf') return;

    const mount = document.getElementById('modal-mount');
    mount.innerHTML = `
        <div id="preview-modal" class="modal-backdrop" onclick="if (event.target === this) closePreview()">
            <div class="modal-content">
                <div class="flex items-center justify-between p-4 border-b border-gray-100">
                    <div class="min-w-0">
                        <h3 class="font-display font-semibold text-brand-dark truncate">${escapeHtml(f.name)}</h3>
                        <p class="text-xs text-brand-gray font-mono" id="preview-page-info">Loading…</p>
                    </div>
                    <div class="flex items-center gap-2">
                        <button onclick="previewNav(-1)" class="w-9 h-9 rounded-lg hover:bg-gray-100" aria-label="Previous"><i class="fa-solid fa-chevron-left"></i></button>
                        <button onclick="previewNav(1)" class="w-9 h-9 rounded-lg hover:bg-gray-100" aria-label="Next"><i class="fa-solid fa-chevron-right"></i></button>
                        <button onclick="closePreview()" class="w-9 h-9 rounded-lg hover:bg-gray-100" aria-label="Close"><i class="fa-solid fa-xmark"></i></button>
                    </div>
                </div>
                <div class="flex-1 overflow-auto bg-gray-100 p-4 flex items-start justify-center">
                    <canvas id="preview-canvas" class="shadow-xl bg-white"></canvas>
                </div>
            </div>
        </div>
    `;

    try {
        const buf = await f.file.arrayBuffer();
        const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
        window._preview = { pdf, page: 1 };
        await renderPreviewPage();
    } catch (e) {
        showNotification('Could not load preview: ' + e.message, 'error');
        closePreview();
    }
}
async function renderPreviewPage() {
    const { pdf, page } = window._preview;
    const p = await pdf.getPage(page);
    const vp = p.getViewport({ scale: 1.5 });
    const canvas = document.getElementById('preview-canvas');
    if (!canvas) return;
    canvas.width = vp.width; canvas.height = vp.height;
    await p.render({ canvasContext: canvas.getContext('2d'), viewport: vp }).promise;
    document.getElementById('preview-page-info').textContent = `Page ${page} of ${pdf.numPages}`;
}
function previewNav(delta) {
    if (!window._preview) return;
    const p = window._preview;
    const next = p.page + delta;
    if (next < 1 || next > p.pdf.numPages) return;
    p.page = next;
    renderPreviewPage();
}
function closePreview() {
    const m = document.getElementById('preview-modal');
    if (m) m.remove();
    if (window._preview?.pdf?.destroy) window._preview.pdf.destroy();
    window._preview = null;
}

// ---------- Result panel ----------
function showResult({ name, blob }) {
    lastResult = { name, blob };
    const url = URL.createObjectURL(blob);
    resultPanel.classList.remove('hidden');
    resultPanel.innerHTML = `
        <div class="result-card p-4 md:p-6 rounded-xl shadow-sm flex flex-col sm:flex-row items-start sm:items-center gap-4">
            <div class="w-12 h-12 bg-white rounded-full flex items-center justify-center flex-shrink-0">
                <i class="fa-solid fa-circle-check text-green-600 text-2xl"></i>
            </div>
            <div class="flex-1 min-w-0">
                <h4 class="font-display font-semibold text-brand-dark">Done</h4>
                <p class="text-sm text-brand-gray truncate font-mono">${escapeHtml(name)} • ${formatSize(blob.size)}</p>
            </div>
            <div class="flex gap-2 w-full sm:w-auto">
                <a href="${url}" download="${escapeHtml(name)}" class="bg-brand-primary hover:bg-brand-primaryHover text-white px-4 py-2 rounded-lg text-sm font-bold flex items-center gap-2 flex-1 justify-center sm:flex-initial">
                    <i class="fa-solid fa-download"></i> Download
                </a>
            </div>
        </div>
    `;
    // also trigger immediate save
    saveAs(blob, name);
}
function hideResult() {
    resultPanel.classList.add('hidden');
    resultPanel.innerHTML = '';
    lastResult = null;
}

// ---------- Processing core ----------
async function processFiles() {
    if (isProcessing) return;
    if (files.length === 0) return;

    isProcessing = true;
    processBtn.disabled = true;
    const overlay = document.getElementById('processing-overlay');
    const progress = document.getElementById('progress-bar');
    const progressText = document.getElementById('processing-text');
    overlay.classList.remove('hidden');
    progress.style.width = '5%';
    progressText.textContent = 'Starting…';
    hideResult();

    try {
        await new Promise(r => setTimeout(r, 50));
        const handlers = {
            'merge': processMerge,
            'split': processSplit,
            'organize': processOrganize,
            'compress': processCompress,
            'pdf-to-img': processPdfToImg,
            'img-to-pdf': processImgToPdf,
            'unlock': processUnlock,
            'watermark': processWatermark,
            'page-numbers': processPageNumbers,
            'metadata': processMetadata,
            'extract-text': processExtractText
        };
        const fn = handlers[currentTool];
        if (!fn) throw new Error('Unknown tool');
        await fn();

        progress.style.width = '100%';
        progressText.textContent = 'Complete';
        showNotification('Finished successfully', 'success');
        setTimeout(() => {
            overlay.classList.add('hidden');
            progress.style.width = '0%';
        }, 600);
    } catch (err) {
        console.error(err);
        showNotification('Error: ' + (err.message || err), 'error', 6000);
        overlay.classList.add('hidden');
        progress.style.width = '0%';
    } finally {
        isProcessing = false;
        processBtn.disabled = files.length === 0;
    }
}

function setProgress(pct, text) {
    document.getElementById('progress-bar').style.width = `${Math.round(pct)}%`;
    if (text) document.getElementById('processing-text').textContent = text;
}

function abortProcessing(msg) {
    isProcessing = false;
    processBtn.disabled = files.length === 0;
    document.getElementById('processing-overlay').classList.add('hidden');
    showNotification(msg, 'error', 6000);
}

function deliverPdf(bytes, name) {
    const blob = new Blob([bytes], { type: 'application/pdf' });
    showResult({ name, blob });
}
function deliverBlob(blob, name) { showResult({ name, blob }); }

function stripExt(name, ext = '.pdf') {
    return name.toLowerCase().endsWith(ext) ? name.slice(0, -ext.length) : name;
}

// ---------- Merge ----------
async function processMerge() {
    const merged = await PDFDocument.create();
    for (let i = 0; i < files.length; i++) {
        setProgress(10 + (i / files.length) * 80, `Adding ${files[i].name}…`);
        const buf = await files[i].file.arrayBuffer();
        const src = await PDFDocument.load(buf, { ignoreEncryption: true });
        const pages = await merged.copyPages(src, src.getPageIndices());
        pages.forEach(p => merged.addPage(p));
    }
    setProgress(95, 'Saving…');
    const out = await merged.save();
    deliverPdf(out, 'merged_document.pdf');
}

// ---------- Split ----------
async function processSplit() {
    const rangeInput = document.getElementById('split-range').value.trim();
    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const src = await PDFDocument.load(buf, { ignoreEncryption: true });
    const total = src.getPageCount();

    if (!rangeInput) {
        const zip = new JSZip();
        const baseName = stripExt(file.name);
        for (let i = 0; i < total; i++) {
            setProgress((i / total) * 90, `Page ${i+1} of ${total}…`);
            const newPdf = await PDFDocument.create();
            const [page] = await newPdf.copyPages(src, [i]);
            newPdf.addPage(page);
            zip.file(`${baseName}_page_${String(i+1).padStart(3,'0')}.pdf`, await newPdf.save());
        }
        setProgress(95, 'Zipping…');
        const blob = await zip.generateAsync({ type: 'blob' });
        deliverBlob(blob, `${baseName}_split.zip`);
        return;
    }

    const indices = parseRanges(rangeInput, total);
    if (indices.length === 0) throw new Error('No valid pages in range.');

    setProgress(50, 'Building PDF…');
    const out = await PDFDocument.create();
    const copied = await out.copyPages(src, indices);
    copied.forEach(p => out.addPage(p));
    deliverPdf(await out.save(), `${stripExt(file.name)}_split.pdf`);
}

function parseRanges(input, max) {
    const set = new Set();
    for (const part of input.split(',')) {
        const trimmed = part.trim();
        if (!trimmed) continue;
        if (trimmed.includes('-')) {
            const [a, b] = trimmed.split('-').map(n => parseInt(n.trim()));
            if (!isNaN(a) && !isNaN(b)) {
                const lo = Math.min(a, b), hi = Math.max(a, b);
                for (let i = lo; i <= hi; i++) {
                    if (i >= 1 && i <= max) set.add(i - 1);
                }
            }
        } else {
            const n = parseInt(trimmed);
            if (!isNaN(n) && n >= 1 && n <= max) set.add(n - 1);
        }
    }
    return [...set].sort((a, b) => a - b);
}

// ---------- Organize ----------
async function processOrganize() {
    const f = files[0];
    if (!f.pageOps) throw new Error('Page data not loaded yet. Wait a moment and try again.');
    const kept = f.pageOps.filter(p => !p.deleted);
    if (kept.length === 0) throw new Error('Cannot save: all pages are deleted.');

    const buf = await f.file.arrayBuffer();
    const src = await PDFDocument.load(buf, { ignoreEncryption: true });
    const out = await PDFDocument.create();

    for (let i = 0; i < kept.length; i++) {
        setProgress(10 + (i / kept.length) * 85, `Page ${i+1}…`);
        const [page] = await out.copyPages(src, [kept[i].originalIndex]);
        const existing = page.getRotation().angle || 0;
        page.setRotation(degrees((existing + kept[i].rotation) % 360));
        out.addPage(page);
    }
    deliverPdf(await out.save(), `organized_${f.name}`);
}

// ---------- Compress ----------
async function processCompress() {
    const quality = parseFloat(document.getElementById('compress-quality').value);
    const renderScale = parseFloat(document.getElementById('compress-resolution').value);
    const mode = document.getElementById('compress-mode').value;
    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const originalSize = file.rawSize;

    if (mode === 'rewrite') {
        setProgress(40, 'Re-saving with object streams…');
        const src = await PDFDocument.load(buf, { ignoreEncryption: true });
        const out = await src.save({ useObjectStreams: true });
        const ratio = (1 - out.length / originalSize) * 100;
        showNotification(`Re-saved (${ratio > 0 ? '-' : '+'}${Math.abs(ratio).toFixed(1)}% size).`, 'info');
        deliverPdf(out, `compressed_${file.name}`);
        return;
    }

    const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
    const newPdf = await PDFDocument.create();

    for (let i = 1; i <= pdf.numPages; i++) {
        setProgress((i-1) / pdf.numPages * 90, `Rasterizing page ${i} of ${pdf.numPages}…`);
        const page = await pdf.getPage(i);
        // Use original page size in PDF points for the new page
        const pointVp = page.getViewport({ scale: 1.0 });
        const pageWidthPts = pointVp.width;
        const pageHeightPts = pointVp.height;

        // Render at higher scale for image quality, then embed
        const renderVp = page.getViewport({ scale: renderScale });
        const canvas = document.createElement('canvas');
        canvas.width = renderVp.width;
        canvas.height = renderVp.height;
        const ctx = canvas.getContext('2d');
        // White background to avoid transparent JPEG artifacts
        ctx.fillStyle = '#ffffff';
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        await page.render({ canvasContext: ctx, viewport: renderVp }).promise;

        const blob = await new Promise(res => canvas.toBlob(res, 'image/jpeg', quality));
        const imgBytes = await blob.arrayBuffer();
        const embedded = await newPdf.embedJpg(imgBytes);
        // CRITICAL: new page uses original page dimensions in points,
        // not the pixel dimensions of the rendered image.
        const newPage = newPdf.addPage([pageWidthPts, pageHeightPts]);
        newPage.drawImage(embedded, {
            x: 0, y: 0,
            width: pageWidthPts,
            height: pageHeightPts
        });
    }

    setProgress(95, 'Saving…');
    const out = await newPdf.save();
    const ratio = (1 - out.length / originalSize) * 100;
    showNotification(`Compressed: ${formatSize(originalSize)} → ${formatSize(out.length)} (${ratio > 0 ? '-' : '+'}${Math.abs(ratio).toFixed(1)}%)`, 'success', 6000);
    deliverPdf(out, `compressed_${file.name}`);
}

// ---------- PDF to Images ----------
async function processPdfToImg() {
    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
    const zip = new JSZip();
    const base = stripExt(file.name);
    const padLen = String(pdf.numPages).length;

    for (let i = 1; i <= pdf.numPages; i++) {
        setProgress((i-1) / pdf.numPages * 95, `Rendering page ${i} of ${pdf.numPages}…`);
        const page = await pdf.getPage(i);
        const vp = page.getViewport({ scale: 2.0 });
        const canvas = document.createElement('canvas');
        canvas.width = vp.width; canvas.height = vp.height;
        await page.render({ canvasContext: canvas.getContext('2d'), viewport: vp }).promise;
        const blob = await new Promise(r => canvas.toBlob(r, 'image/png'));
        zip.file(`${base}_page_${String(i).padStart(padLen,'0')}.png`, blob);
    }
    setProgress(95, 'Zipping…');
    const out = await zip.generateAsync({ type: 'blob' });
    deliverBlob(out, `${base}_images.zip`);
}

// ---------- Images to PDF ----------
async function processImgToPdf() {
    const sizeOpt = document.getElementById('img-page-size').value;
    const orientation = document.getElementById('img-orientation').value;
    const margin = Math.max(0, parseInt(document.getElementById('img-margin').value) || 0);
    const newPdf = await PDFDocument.create();

    const A4 = { w: 595.28, h: 841.89 };
    const Letter = { w: 612, h: 792 };

    for (let i = 0; i < files.length; i++) {
        setProgress(10 + (i / files.length) * 85, `Embedding ${files[i].name}…`);
        const bytes = await files[i].file.arrayBuffer();
        const type = files[i].file.type;
        let image;
        if (type === 'image/png') {
            image = await newPdf.embedPng(bytes);
        } else if (type === 'image/jpeg' || type === 'image/jpg') {
            image = await newPdf.embedJpg(bytes);
        } else if (type === 'image/webp') {
            // pdf-lib doesn't natively embed webp; convert via canvas to JPEG
            const blob = new Blob([bytes], { type });
            const url = URL.createObjectURL(blob);
            try {
                const img = await new Promise((res, rej) => {
                    const im = new Image();
                    im.onload = () => res(im);
                    im.onerror = rej;
                    im.src = url;
                });
                const c = document.createElement('canvas');
                c.width = img.naturalWidth; c.height = img.naturalHeight;
                c.getContext('2d').drawImage(img, 0, 0);
                const jpg = await new Promise(r => c.toBlob(r, 'image/jpeg', 0.92));
                image = await newPdf.embedJpg(await jpg.arrayBuffer());
            } finally {
                URL.revokeObjectURL(url);
            }
        } else {
            continue;
        }

        let pageW, pageH;
        if (sizeOpt === 'fit') {
            pageW = image.width; pageH = image.height;
        } else {
            const base = sizeOpt === 'A4' ? A4 : Letter;
            let usePortrait = base.w < base.h;
            if (orientation === 'portrait') usePortrait = true;
            else if (orientation === 'landscape') usePortrait = false;
            else usePortrait = image.height >= image.width; // auto
            pageW = usePortrait ? base.w : base.h;
            pageH = usePortrait ? base.h : base.w;
        }

        const page = newPdf.addPage([pageW, pageH]);
        if (sizeOpt === 'fit') {
            page.drawImage(image, { x: 0, y: 0, width: pageW, height: pageH });
        } else {
            const inner = { w: pageW - 2*margin, h: pageH - 2*margin };
            const scale = Math.min(inner.w / image.width, inner.h / image.height);
            const drawW = image.width * scale;
            const drawH = image.height * scale;
            page.drawImage(image, {
                x: (pageW - drawW) / 2,
                y: (pageH - drawH) / 2,
                width: drawW, height: drawH
            });
        }
    }
    setProgress(95, 'Saving…');
    const out = await newPdf.save();
    deliverPdf(out, 'images.pdf');
}

// ---------- Unlock ----------
async function processUnlock() {
    const file = files[0];
    const buf = await file.file.arrayBuffer();

    setProgress(20, 'Reading file…');

    // Strategy 1: re-save via pdf-lib using ignoreEncryption (works for many real-world PDFs)
    try {
        const doc = await PDFDocument.load(buf, { ignoreEncryption: true });
        setProgress(60, 'Re-saving without restrictions…');
        const out = await doc.save({ useObjectStreams: false });
        deliverPdf(out, `unlocked_${file.name}`);
        return;
    } catch (e1) {
        console.warn('Direct unlock failed:', e1);
    }

    // Strategy 2: render with pdf.js (supports password) and rebuild as image-based PDF
    const password = (document.getElementById('unlock-password')?.value || '').trim();
    setProgress(25, 'Trying with password…');
    let pdf;
    try {
        pdf = await pdfjsLib.getDocument({ data: buf, password: password || undefined }).promise;
    } catch (err) {
        if (err?.name === 'PasswordException') {
            throw new Error(password ? 'Incorrect password.' : 'This PDF requires a password.');
        }
        throw new Error('Could not open this PDF.');
    }

    const newPdf = await PDFDocument.create();
    for (let i = 1; i <= pdf.numPages; i++) {
        setProgress(25 + (i-1)/pdf.numPages * 70, `Rebuilding page ${i} of ${pdf.numPages}…`);
        const page = await pdf.getPage(i);
        const pointVp = page.getViewport({ scale: 1.0 });
        const renderVp = page.getViewport({ scale: 2.0 });
        const canvas = document.createElement('canvas');
        canvas.width = renderVp.width; canvas.height = renderVp.height;
        const ctx = canvas.getContext('2d');
        ctx.fillStyle = '#fff'; ctx.fillRect(0, 0, canvas.width, canvas.height);
        await page.render({ canvasContext: ctx, viewport: renderVp }).promise;
        const blob = await new Promise(r => canvas.toBlob(r, 'image/jpeg', 0.85));
        const img = await newPdf.embedJpg(await blob.arrayBuffer());
        const out = newPdf.addPage([pointVp.width, pointVp.height]);
        out.drawImage(img, { x: 0, y: 0, width: pointVp.width, height: pointVp.height });
    }
    showNotification('Unlocked via rasterization. Text selection may be lost.', 'info', 6000);
    deliverPdf(await newPdf.save(), `unlocked_${file.name}`);
}

// ---------- Watermark ----------
async function processWatermark() {
    const text = document.getElementById('watermark-text').value.trim();
    if (!text) throw new Error('Enter watermark text first.');
    const size = parseInt(document.getElementById('watermark-size').value);
    const opacity = parseFloat(document.getElementById('watermark-opacity').value);
    const position = document.getElementById('watermark-position').value;
    const color = document.getElementById('watermark-color').value;
    const { r, g, b } = hexToRgb(color);

    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const doc = await PDFDocument.load(buf, { ignoreEncryption: true });
    const font = await doc.embedFont(StandardFonts.HelveticaBold);
    const pages = doc.getPages();

    const textWidth = font.widthOfTextAtSize(text, size);
    const textHeight = font.heightAtSize(size, { descender: false });

    for (let i = 0; i < pages.length; i++) {
        setProgress(10 + (i / pages.length) * 85, `Stamping page ${i+1}…`);
        const page = pages[i];
        const { width, height } = page.getSize();

        let x, y, rotationDeg = 0;
        if (position === 'center' || position === 'diagonal') {
            const theta = position === 'diagonal' ? -45 : 0;
            rotationDeg = theta;
            const rad = theta * Math.PI / 180;
            const cos = Math.cos(rad), sin = Math.sin(rad);
            // Center the rotated text bbox over the page center.
            x = width/2 - (textWidth/2) * cos + (textHeight/2) * sin;
            y = height/2 - (textWidth/2) * sin - (textHeight/2) * cos;
        } else if (position === 'top') {
            x = (width - textWidth) / 2;
            y = height - 40 - textHeight;
        } else { // bottom
            x = (width - textWidth) / 2;
            y = 40;
        }

        page.drawText(text, {
            x, y, size,
            font,
            color: rgb(r, g, b),
            opacity,
            rotate: degrees(rotationDeg)
        });
    }

    deliverPdf(await doc.save(), `watermarked_${file.name}`);
}

function hexToRgb(hex) {
    const h = hex.replace('#','');
    return {
        r: parseInt(h.substring(0,2),16)/255,
        g: parseInt(h.substring(2,4),16)/255,
        b: parseInt(h.substring(4,6),16)/255
    };
}

// ---------- Page Numbers ----------
async function processPageNumbers() {
    const format = document.getElementById('pn-format').value;
    const position = document.getElementById('pn-position').value;
    const size = parseInt(document.getElementById('pn-size').value);
    const start = parseInt(document.getElementById('pn-start').value) || 1;
    const color = document.getElementById('pn-color').value;
    const skipFirst = document.getElementById('pn-skip-first').checked;
    const { r, g, b } = hexToRgb(color);

    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const doc = await PDFDocument.load(buf, { ignoreEncryption: true });
    const font = await doc.embedFont(StandardFonts.Helvetica);
    const pages = doc.getPages();
    const total = pages.length;
    const margin = Math.max(20, size * 1.5);

    for (let i = 0; i < total; i++) {
        if (skipFirst && i === 0) continue;
        setProgress(10 + (i / total) * 85, `Numbering page ${i+1}…`);
        const page = pages[i];
        const { width, height } = page.getSize();
        const num = (i + start) - (skipFirst ? 1 : 0);
        const visibleTotal = skipFirst ? total - 1 : total;
        const text = format
            .replace('total', String(visibleTotal))
            .replace('n', String(num))
            .replace('page-', 'Page ')
            .replace('/', ' / ');

        const tw = font.widthOfTextAtSize(text, size);
        let x, y;
        const [vert, horiz] = position.split('-');
        if (horiz === 'left') x = margin;
        else if (horiz === 'right') x = width - margin - tw;
        else x = (width - tw) / 2;
        if (vert === 'top') y = height - margin;
        else y = margin - size * 0.3;

        page.drawText(text, { x, y, size, font, color: rgb(r, g, b) });
    }

    deliverPdf(await doc.save(), `numbered_${file.name}`);
}

// ---------- Metadata ----------
async function processMetadata() {
    const title = document.getElementById('meta-title').value;
    const author = document.getElementById('meta-author').value;
    const subject = document.getElementById('meta-subject').value;
    const keywords = document.getElementById('meta-keywords').value;

    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const doc = await PDFDocument.load(buf, { ignoreEncryption: true });

    if (title) doc.setTitle(title);
    if (author) doc.setAuthor(author);
    if (subject) doc.setSubject(subject);
    if (keywords) doc.setKeywords(keywords.split(',').map(k => k.trim()).filter(Boolean));
    doc.setProducer('PDF Alchemy');
    doc.setCreator('PDF Alchemy v1.4.0');
    doc.setModificationDate(new Date());
    setProgress(80, 'Saving…');
    deliverPdf(await doc.save(), `metadata_${file.name}`);
}

// ---------- Extract Text ----------
async function processExtractText() {
    const file = files[0];
    const buf = await file.file.arrayBuffer();
    const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
    const parts = [];
    for (let i = 1; i <= pdf.numPages; i++) {
        setProgress((i-1) / pdf.numPages * 95, `Page ${i} of ${pdf.numPages}…`);
        const page = await pdf.getPage(i);
        const content = await page.getTextContent();
        let lastY = null;
        let pageText = '';
        for (const item of content.items) {
            if (lastY !== null && Math.abs(item.transform[5] - lastY) > 2) pageText += '\n';
            pageText += item.str;
            if (item.hasEOL) pageText += '\n';
            else pageText += ' ';
            lastY = item.transform[5];
        }
        parts.push(`=== Page ${i} ===\n\n${pageText.trim()}\n`);
    }
    const text = parts.join('\n');
    const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
    deliverBlob(blob, `${stripExt(file.name)}_text.txt`);
}

// Expose for inline handlers
window.switchTool = switchTool;
window.clearAll = clearAll;
window.processFiles = processFiles;
window.removeFile = removeFile;
window.previewFile = previewFile;
window.previewNav = previewNav;
window.closePreview = closePreview;
window.toggleSidebar = toggleSidebar;
window.rotatePage = rotatePage;
window.deletePage = deletePage;
window.restoreAllPages = restoreAllPages;
window.updateQualityLabel = updateQualityLabel;