/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import * as fs from 'node:fs/promises';
import * as path from 'node:path';
import { createDebugLogger } from '@hoptrendy/hopcode-core';
const debugLogger = createDebugLogger('CLIPBOARD_UTILS');
let cachedClipboardModule = null;
let clipboardLoadAttempted = false;
async function getClipboardModule() {
    if (clipboardLoadAttempted)
        return cachedClipboardModule;
    clipboardLoadAttempted = true;
    try {
        const modName = '@teddyzhu/clipboard';
        cachedClipboardModule = await import(modName);
        return cachedClipboardModule;
    }
    catch (_e) {
        debugLogger.error('Failed to load @teddyzhu/clipboard native module. Clipboard image features will be unavailable.');
        return null;
    }
}
/**
 * Checks if the system clipboard contains an image
 * @returns true if clipboard contains an image
 */
export async function clipboardHasImage() {
    try {
        const mod = await getClipboardModule();
        if (!mod)
            return false;
        const clipboard = new mod.ClipboardManager();
        return clipboard.hasFormat('image');
    }
    catch (error) {
        debugLogger.error('Error checking clipboard for image:', error);
        return false;
    }
}
/**
 * Saves the image from clipboard to a temporary file
 * @param targetDir The target directory to create temp files within
 * @returns The path to the saved image file, or null if no image or error
 */
export async function saveClipboardImage(targetDir) {
    try {
        const mod = await getClipboardModule();
        if (!mod)
            return null;
        const clipboard = new mod.ClipboardManager();
        if (!clipboard.hasFormat('image')) {
            return null;
        }
        // Create a temporary directory for clipboard images within the target directory
        // This avoids security restrictions on paths outside the target directory
        const baseDir = targetDir || process.cwd();
        const tempDir = path.join(baseDir, 'clipboard');
        await fs.mkdir(tempDir, { recursive: true });
        // Generate a unique filename with timestamp
        const timestamp = new Date().getTime();
        const tempFilePath = path.join(tempDir, `clipboard-${timestamp}.png`);
        const imageData = clipboard.getImageData();
        // Use data buffer from the API
        const buffer = imageData.data;
        if (!buffer) {
            return null;
        }
        await fs.writeFile(tempFilePath, buffer);
        return tempFilePath;
    }
    catch (error) {
        debugLogger.error('Error saving clipboard image:', error);
        return null;
    }
}
/**
 * Cleans up old temporary clipboard image files using LRU strategy
 * Keeps maximum 100 images, when exceeding removes 50 oldest files to reduce cleanup frequency
 * @param targetDir The target directory where temp files are stored
 */
export async function cleanupOldClipboardImages(targetDir) {
    try {
        const baseDir = targetDir || process.cwd();
        const tempDir = path.join(baseDir, 'clipboard');
        const files = await fs.readdir(tempDir);
        const MAX_IMAGES = 100;
        const CLEANUP_COUNT = 50;
        // Filter clipboard image files and get their stats
        const imageFiles = [];
        for (const file of files) {
            if (file.startsWith('clipboard-') &&
                (file.endsWith('.png') ||
                    file.endsWith('.jpg') ||
                    file.endsWith('.webp') ||
                    file.endsWith('.heic') ||
                    file.endsWith('.heif') ||
                    file.endsWith('.tiff') ||
                    file.endsWith('.gif') ||
                    file.endsWith('.bmp'))) {
                const filePath = path.join(tempDir, file);
                const stats = await fs.stat(filePath);
                imageFiles.push({
                    name: file,
                    path: filePath,
                    atime: stats.atimeMs,
                });
            }
        }
        // If exceeds limit, remove CLEANUP_COUNT oldest files to reduce cleanup frequency
        if (imageFiles.length > MAX_IMAGES) {
            // Sort by access time (oldest first)
            imageFiles.sort((a, b) => a.atime - b.atime);
            // Remove CLEANUP_COUNT oldest files (or all excess files if less than CLEANUP_COUNT)
            const removeCount = Math.min(CLEANUP_COUNT, imageFiles.length - MAX_IMAGES + CLEANUP_COUNT);
            const filesToRemove = imageFiles.slice(0, removeCount);
            for (const file of filesToRemove) {
                await fs.unlink(file.path);
            }
        }
    }
    catch {
        // Ignore errors in cleanup
    }
}
//# sourceMappingURL=clipboardUtils.js.map