"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerShellHandlers = registerShellHandlers;
const electron_1 = require("electron");
const child_process_1 = require("child_process");
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const os = __importStar(require("os"));
const file_utils_1 = require("./file_utils");
function registerShellHandlers() {
    electron_1.ipcMain.handle('native:open-folder', async (event, folderPath) => {
        const cleanPath = (0, file_utils_1.expandPath)(folderPath);
        const error = await electron_1.shell.openPath(cleanPath);
        return { success: !error, error };
    });
    electron_1.ipcMain.handle('native:run-cmd', async (event, { cmd, timeout = 30000 }) => {
        const cleanCmd = (0, file_utils_1.expandPath)(cmd);
        return new Promise((resolve) => {
            (0, child_process_1.exec)(cleanCmd, { timeout }, (error, stdout, stderr) => {
                resolve({ success: !error, stdout: stdout.trim(), stderr: stderr.trim(), error: error ? error.message : null });
            });
        });
    });
    electron_1.ipcMain.handle('native:run-cmd-sync', async (event, { cmd }) => {
        const cleanCmd = (0, file_utils_1.expandPath)(cmd);
        try {
            const stdout = (0, child_process_1.execSync)(cleanCmd).toString();
            return { success: true, stdout: stdout.trim() };
        }
        catch (error) {
            return { success: false, error: error.message, stderr: error.stderr?.toString() };
        }
    });
    electron_1.ipcMain.handle('native:run-osascript', async (event, script) => {
        if (os.platform() !== 'darwin')
            return { success: false, error: 'AppleScript is only available on macOS' };
        // HARDENED: Write script to a temp .scpt file rather than passing inline via -e.
        // The old -e approach (`osascript -e "..."`) has two fatal flaws:
        //   1. It breaks on multi-line scripts.
        //   2. It breaks on paths containing spaces or special characters (quotes, parens, etc.)
        // Writing to a file sidesteps both — no shell escaping needed at all.
        // The .scpt file is deleted immediately after execution (success or failure).
        // Worst case on crash: a stale .scpt in /tmp, cleared on next OS reboot.
        //
        // LEGACY (removed): const cmd = `osascript -e "${script.replace(/"/g, '\\"')}"`;
        const tmp_script_path = path.join(os.tmpdir(), `ae_osa_${Date.now()}.scpt`);
        return new Promise((resolve) => {
            try {
                fs.writeFileSync(tmp_script_path, script.trim());
            }
            catch (e) {
                resolve({ success: false, error: `Failed to write AppleScript temp file: ${e.message}` });
                return;
            }
            (0, child_process_1.exec)(`osascript "${tmp_script_path}"`, (error, stdout, stderr) => {
                try {
                    fs.unlinkSync(tmp_script_path);
                }
                catch { }
                resolve({ success: !error, stdout: stdout.trim(), stderr: stderr.trim(), error: error ? error.message : null });
            });
        });
    });
    electron_1.ipcMain.handle('native:kill-processes', async (event, { process_name_li = [] }) => {
        console.log(`Native: Killing processes -> `, process_name_li);
        const results = [];
        for (const name of process_name_li) {
            const cmd = os.platform() === 'win32'
                ? `taskkill /F /IM ${name} /T`
                : `pkill -f ${name}`;
            try {
                (0, child_process_1.execSync)(cmd);
                results.push({ name, success: true });
            }
            catch (e) {
                results.push({ name, success: false, error: e.message });
            }
        }
        return { success: true, results };
    });
    electron_1.ipcMain.handle('native:open-local-file-v2', async (event, filePath) => {
        const cleanPath = (0, file_utils_1.expandPath)(filePath);
        const error = await electron_1.shell.openPath(cleanPath);
        return { success: !error, error };
    });
    electron_1.ipcMain.handle('native:launch-presentation', async (event, { path: rawPath, app: appType = 'default' }) => {
        const cleanedPath = (0, file_utils_1.expandPath)(rawPath);
        console.log(`Native: Launching Presentation -> ${cleanedPath} (App: ${appType})`);
        if (os.platform() === 'linux') {
            const cmd = `libreoffice --impress "${cleanedPath}"`;
            return new Promise((resolve) => {
                (0, child_process_1.exec)(cmd, (err, stdout, stderr) => {
                    if (err)
                        resolve({ success: false, error: err.message });
                    else
                        resolve({ success: true, stdout, stderr });
                });
            });
        }
        if (os.platform() === 'darwin') {
            let script = '';
            if (appType === 'keynote') {
                script = `
tell application "Keynote"
  activate
  open (POSIX file "${cleanedPath}")
  delay 1
  start (front document)
end tell
        `.trim();
            }
            else if (appType === 'powerpoint') {
                script = `
tell application "Microsoft PowerPoint"
  activate
  open (POSIX file "${cleanedPath}")
  delay 1
  run slide show of active presentation
end tell
        `.trim();
            }
            if (script) {
                const tmp_script_path = path.join(os.tmpdir(), `ae_launch_${Date.now()}.scpt`);
                return new Promise((resolve) => {
                    try {
                        fs.writeFileSync(tmp_script_path, script);
                    }
                    catch (e) {
                        resolve({ success: false, error: `Failed to write AppleScript temp file: ${e.message}` });
                        return;
                    }
                    (0, child_process_1.exec)(`osascript "${tmp_script_path}"`, (err) => {
                        try {
                            fs.unlinkSync(tmp_script_path);
                        }
                        catch { }
                        if (err)
                            resolve({ success: false, error: err.message });
                        else
                            resolve({ success: true });
                    });
                });
            }
        }
        const error = await electron_1.shell.openPath(cleanedPath);
        return { success: !error, error };
    });
    electron_1.ipcMain.handle('native:control-presentation', async (event, { app, action }) => {
        if (os.platform() !== 'darwin')
            return { success: false, error: 'Presentation control is only available on macOS' };
        let script = '';
        if (app === 'powerpoint') {
            switch (action) {
                case 'next':
                    script = 'tell application "Microsoft PowerPoint" to next slide of slide show view of active presentation';
                    break;
                case 'prev':
                    script = 'tell application "Microsoft PowerPoint" to previous slide of slide show view of active presentation';
                    break;
                case 'start':
                    script = 'tell application "Microsoft PowerPoint" to run slide show of active presentation';
                    break;
                case 'stop':
                    script = 'tell application "Microsoft PowerPoint" to stop slide show of active presentation';
                    break;
            }
        }
        else if (app === 'keynote') {
            switch (action) {
                case 'next':
                    script = 'tell application "Keynote" to show next';
                    break;
                case 'prev':
                    script = 'tell application "Keynote" to show previous';
                    break;
                case 'start':
                    script = 'tell application "Keynote" to start (front document)';
                    break;
                case 'stop':
                    script = 'tell application "Keynote" to stop';
                    break;
            }
        }
        if (!script)
            return { success: false, error: `Unsupported app or action: ${app}/${action}` };
        return new Promise((resolve) => {
            (0, child_process_1.exec)(`osascript -e "${script.replace(/"/g, '\\"')}"`, (error, stdout, stderr) => {
                resolve({ success: !error, stdout: stdout.trim(), stderr: stderr.trim(), error: error ? error.message : null });
            });
        });
    });
    electron_1.ipcMain.handle('native:list-tools', async () => {
        return [
            {
                name: 'open_folder',
                description: 'Opens a directory in the OS file explorer (Finder/Files/Explorer).',
                params: { path: 'string' }
            },
            {
                name: 'run_cmd',
                description: 'Executes an asynchronous shell command with a timeout.',
                params: { cmd: 'string', timeout: 'number (optional)' }
            },
            {
                name: 'run_cmd_sync',
                description: 'Executes a synchronous shell command.',
                params: { cmd: 'string' }
            },
            {
                name: 'run_osascript',
                description: 'Executes a raw AppleScript string (macOS only).',
                params: { script: 'string' }
            },
            {
                name: 'kill_processes',
                description: 'Forcefully terminates processes by name.',
                params: { process_name_li: 'string[]' }
            },
            {
                name: 'open_local_file_v2',
                description: 'Opens a local file using the default OS handler.',
                params: { filePath: 'string' }
            },
            {
                name: 'launch_presentation',
                description: 'Phase 5: Specialized launcher for PowerPoint, Keynote, and LibreOffice with auto-focus.',
                params: { path: 'string', app: 'default|powerpoint|keynote' }
            },
            {
                name: 'control_presentation',
                description: 'Phase 5: Remote navigation for active slideshows.',
                params: { app: 'powerpoint|keynote', action: 'next|prev|start|stop' }
            },
            {
                name: 'check_cache',
                description: 'Checks if a file exists in the local organized cache.',
                params: { cache_root: 'string', hash: 'string', hash_prefix_length: 'number' }
            },
            {
                name: 'download_to_cache',
                description: 'Downloads a file from the API directly into the native cache.',
                params: { url: 'string', cache_root: 'string', hash: 'string', api_key: 'string', account_id: 'string' }
            },
            {
                name: 'launch_from_cache',
                description: 'Atomic operation: Copies file from cache to temp with original name and launches via specialized handler.',
                params: { cache_root: 'string', hash: 'string', temp_root: 'string', filename: 'string' }
            },
            {
                name: 'get_device_info',
                description: 'Returns hardware and OS metadata (CPUs, RAM, IP addresses, Hostname).',
                params: {}
            }
        ];
    });
}
//# sourceMappingURL=shell_handlers.js.map