import * as assert from 'assert';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import * as sinon from 'sinon';
import { hostNodeRuntime, resolveNodeRuntime } from '../../interactive/nodeExecutable';
import { nodeEnvironment, prepareNodeRuntime } from '../../interactive/launcher';

suite('Interactive Node runtime', () => {
    let root: string;
    setup(() => { root = fs.mkdtempSync(path.join(os.tmpdir(), 'r-node-runtime-')); });
    teardown(() => { fs.rmSync(root, { recursive: true, force: true }); });

    test('uses the current extension host executable without a PATH lookup', () => {
        const environment = sinon.stub(process.env, 'PATH').value(root);
        const executable = sinon.stub(process, 'execPath').value(path.join(root, 'Code Helper (Plugin)'));
        try {
            assert.deepStrictEqual(hostNodeRuntime(), { executable: process.execPath, electron: !!process.versions.electron });
            assert.deepStrictEqual(resolveNodeRuntime('', root), hostNodeRuntime());
            assert.deepStrictEqual(resolveNodeRuntime('  ', root), hostNodeRuntime());
            // A reload after an editor update must select the new host, not a cached path.
            executable.value(path.join(root, 'updated-server', 'node'));
            assert.strictEqual(hostNodeRuntime().executable, process.execPath);
        } finally { executable.restore(); environment.restore(); }
    });
    test('resolves explicit names and quoted or relative paths without changing the automatic default', () => {
        const directory = path.join(root, 'custom Node'); fs.mkdirSync(directory);
        const name = process.platform === 'win32' ? 'node.exe' : 'node';
        const executable = path.join(directory, name);
        fs.writeFileSync(executable, '', { mode: 0o700 });
        const environment = sinon.stub(process.env, 'PATH').value(directory);
        try {
            assert.deepStrictEqual(resolveNodeRuntime('', root), hostNodeRuntime());
            const commands = [name, `"${executable}"`, path.join('.', 'custom Node', name)];
            const homeRelative = path.relative(os.homedir(), executable);
            // Windows can place the temp directory on a different drive from home.
            if (!path.isAbsolute(homeRelative)) { commands.push(`~/${homeRelative}`); }
            for (const command of commands) {
                assert.deepStrictEqual(resolveNodeRuntime(command, root), { executable, electron: false });
            }
            for (const command of [path.join(root, 'missing-node'), directory]) {
                assert.throws(() => resolveNodeRuntime(command, root), /r\.interactive\.nodePath.*remote server/);
            }
        } finally { environment.restore(); }
    });
    test('scopes Electron Node mode to its launch environment and removes debugger injection', () => {
        const environment = { ELECTRON_RUN_AS_NODE: '1', VSCODE_INSPECTOR_OPTIONS: '{}', NODE_OPTIONS: '--require missing', PATH: root };
        assert.deepStrictEqual(nodeEnvironment({ executable: 'Code', electron: true }, environment), { PATH: root, ELECTRON_RUN_AS_NODE: '1' });
        assert.deepStrictEqual(nodeEnvironment({ executable: 'node', electron: false }, environment), { PATH: root });
        assert.strictEqual(environment.NODE_OPTIONS, '--require missing');
    });
    test('reports a removed host runtime before creating session storage', async () => {
        await assert.rejects(prepareNodeRuntime(root, { executable: path.join(root, 'removed-host'), electron: true }), /Reload VS Code.*VS Code Server/);
        assert.deepStrictEqual(fs.readdirSync(root), []);
    });
    test('probes the Node version in Electron mode instead of its application version', async function () {
        if (process.platform === 'win32') { this.skip(); }
        const executable = path.join(root, 'Code Helper');
        const runtime = { executable, electron: true };
        const script = (version: string): string => `#!/bin/sh\n[ "$ELECTRON_RUN_AS_NODE" = 1 ] && [ "$1" = -p ] && [ "$2" = process.versions.node ] || exit 1\nprintf '${version}\\n'\n`;
        fs.writeFileSync(executable, script('24.0.0'), { mode: 0o700 });
        assert.deepStrictEqual(await prepareNodeRuntime(root, runtime), runtime);
        for (const version of ['16.0.0', 'not node']) {
            fs.writeFileSync(executable, script(version));
            await assert.rejects(prepareNodeRuntime(root, runtime), /requires Node.js 18 or newer/);
        }
    });
    test('validates explicit standalone Node without Electron mode and reports how to repair an override', async function () {
        if (process.platform === 'win32') { this.skip(); }
        const executable = path.join(root, 'standalone Node');
        const script = (version: string): string => `#!/bin/sh\n[ -z "$ELECTRON_RUN_AS_NODE" ] && [ "$1" = -p ] && [ "$2" = process.versions.node ] || exit 1\nprintf '${version}\\n'\n`;
        fs.writeFileSync(executable, script('24.0.0'), { mode: 0o700 });
        const runtime = resolveNodeRuntime(executable, root);
        assert.deepStrictEqual(await prepareNodeRuntime(root, runtime), { executable, electron: false });
        for (const version of ['16.0.0', 'not node']) {
            fs.writeFileSync(executable, script(version));
            await assert.rejects(prepareNodeRuntime(root, runtime), /requires Node.js 18 or newer.*r\.interactive\.nodePath/);
        }
        fs.unlinkSync(executable);
        await assert.rejects(prepareNodeRuntime(root, runtime), /Cannot run the Node.js runtime.*r\.interactive\.nodePath/);
    });
});