/**
 * Copyright (c) Microsoft Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import EventEmitter from 'events';
import { createGuid } from '@utils/crypto';
import { isUnderTest } from '@utils/debug';
import { SocksProxy } from '@utils/socksProxy';
import { rewriteErrorMessage } from '@isomorphic/stackTrace';
import { DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT } from '@isomorphic/time';
import { PlaywrightServer } from './remote/playwrightServer';
import { helper } from './server/helper';
import { createPlaywright } from './server/playwright';
import * as validatorPrimitives from './protocol/validatorPrimitives';
import { ProgressController } from './server/progress';
export class BrowserServerLauncherImpl {
    _browserName;
    constructor(browserName) {
        this._browserName = browserName;
    }
    async launchServer(options = {}) {
        const playwright = createPlaywright({ sdkLanguage: 'javascript', isServer: true });
        // 1. Pre-launch the browser
        const metadata = { id: '', startTime: 0, endTime: 0, type: 'Internal', method: '', params: {}, log: [], internal: true };
        const validatorContext = {
            tChannelImpl: (names, arg, path) => {
                throw new validatorPrimitives.ValidationError(`${path}: channels are not expected in launchServer`);
            },
            binary: 'buffer',
            isUnderTest,
        };
        let launchOptions = {
            ...options,
            ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
            ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
            env: options.env ? envObjectToArray(options.env) : undefined,
            timeout: options.timeout ?? DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT,
        };
        // 2. Optionally start a SOCKS proxy that forwards client-allowed network requests back to the connecting client.
        let socksProxy;
        let socksProxyPort;
        if (options.allowClientNetwork !== undefined) {
            socksProxy = new SocksProxy();
            socksProxy.setPattern(options.allowClientNetwork);
            socksProxyPort = await socksProxy.listen(0);
        }
        let browser;
        try {
            const controller = new ProgressController(metadata);
            browser = await controller.run(async (progress) => {
                if (options._userDataDir !== undefined) {
                    const validator = validatorPrimitives.scheme['BrowserTypeLaunchPersistentContextParams'];
                    launchOptions = validator({ ...launchOptions, userDataDir: options._userDataDir }, '', validatorContext);
                    const context = await playwright[this._browserName].launchPersistentContext(progress, options._userDataDir, { ...launchOptions, socksProxyPort });
                    return context._browser;
                }
                else {
                    const validator = validatorPrimitives.scheme['BrowserTypeLaunchParams'];
                    launchOptions = validator(launchOptions, '', validatorContext);
                    return await playwright[this._browserName].launch(progress, { ...launchOptions, socksProxyPort }, toProtocolLogger(options.logger));
                }
            });
        }
        catch (e) {
            await socksProxy?.close();
            const log = helper.formatBrowserLogs(metadata.log);
            rewriteErrorMessage(e, `${e.message} Failed to launch browser.${log}`);
            throw e;
        }
        const path = options.wsPath ? (options.wsPath.startsWith('/') ? options.wsPath : `/${options.wsPath}`) : `/${createGuid()}`;
        // 3. Start the server
        const server = new PlaywrightServer({ mode: options._sharedBrowser ? 'launchServerShared' : 'launchServer', path, maxConnections: Infinity, preLaunchedBrowser: browser, preLaunchedSocksProxy: socksProxy });
        const wsEndpoint = await server.listen(options.port, options.host);
        // 4. Return the BrowserServer interface
        const browserServer = new EventEmitter();
        browserServer.process = () => browser.options.browserProcess.process;
        browserServer.wsEndpoint = () => wsEndpoint;
        browserServer.close = () => browser.options.browserProcess.close();
        browserServer[Symbol.asyncDispose] = browserServer.close;
        browserServer.kill = () => browser.options.browserProcess.kill();
        browserServer._disconnectForTest = () => server.close();
        browserServer._userDataDirForTest = browser._userDataDirForTest;
        browser.options.browserProcess.onclose = (exitCode, signal) => {
            socksProxy?.close();
            server.close();
            browserServer.emit('close', exitCode, signal);
        };
        return browserServer;
    }
}
function toProtocolLogger(logger) {
    return logger ? (direction, message) => {
        if (logger.isEnabled('protocol', 'verbose'))
            logger.log('protocol', 'verbose', (direction === 'send' ? 'SEND ► ' : '◀ RECV ') + JSON.stringify(message), [], {});
    } : undefined;
}
function envObjectToArray(env) {
    const result = [];
    for (const name in env) {
        if (!Object.is(env[name], undefined))
            result.push({ name, value: String(env[name]) });
    }
    return result;
}
//# sourceMappingURL=browserServerImpl.js.map