/**
 * 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 { createProxy } from '../third_party/proxy';
import net from 'net';
import { utils } from '../../packages/playwright-core/lib/coreBundle';
const { SocksProxy } = utils;
// Certain browsers perform telemetry requests which we want to ignore.
const kConnectHostsToIgnore = new Set([
    'www.bing.com:443',
    'www.google.com:443',
]);
export class TestProxy {
    HOST;
    PORT;
    URL;
    connectHosts = [];
    requestUrls = [];
    wsUrls = [];
    _server;
    _sockets = new Set();
    _handlers = [];
    static async create(port) {
        const proxy = new TestProxy(port);
        await new Promise(f => proxy._server.listen(port, f));
        return proxy;
    }
    constructor(port) {
        this.PORT = port;
        this.URL = `http://localhost:${port}`;
        this.HOST = new URL(this.URL).host;
        this._server = createProxy();
        this._server.on('connection', socket => this._onSocket(socket));
    }
    async stop() {
        this.reset();
        for (const socket of this._sockets)
            socket.destroy();
        this._sockets.clear();
        await new Promise(x => this._server.close(x));
    }
    forwardTo(port, options) {
        this._prependHandler('request', (req) => {
            this.requestUrls.push(req.url);
            const url = new URL(req.url, `http://${req.headers.host}`);
            if (options?.preserveHostname)
                url.port = '' + port;
            else
                url.host = `127.0.0.1:${port}`;
            if (options?.removePrefix)
                url.pathname = url.pathname.replace(options.removePrefix, '');
            req.url = url.toString();
        });
        this._prependHandler('connect', (req) => {
            if (!options?.allowConnectRequests)
                return;
            if (kConnectHostsToIgnore.has(req.url))
                return;
            this.connectHosts.push(req.url);
            req.url = `127.0.0.1:${port}`;
        });
        this._prependHandler('upgrade', (req) => {
            this.wsUrls.push(req.url);
            const url = new URL(req.url, `http://${req.headers.host}`);
            if (options?.preserveHostname)
                url.port = '' + port;
            else
                url.host = `127.0.0.1:${port}`;
            if (options?.removePrefix)
                url.pathname = url.pathname.replace(options.removePrefix, '');
            if (url.protocol === 'ws:')
                url.protocol = 'http:';
            else if (url.protocol === 'wss:')
                url.protocol = 'https:';
            req.url = url.toString();
        });
    }
    setAuthHandler(handler) {
        this._server.authenticate = (req) => {
            try {
                return handler(req);
            }
            catch (e) {
                return false;
            }
        };
    }
    reset() {
        this.connectHosts = [];
        this.requestUrls = [];
        for (const { event, handler } of this._handlers)
            this._server.removeListener(event, handler);
        this._handlers = [];
        this._server.authenticate = undefined;
    }
    _prependHandler(event, handler) {
        this._handlers.push({ event, handler });
        this._server.prependListener(event, handler);
    }
    _onSocket(socket) {
        this._sockets.add(socket);
        // ECONNRESET and HPE_INVALID_EOF_STATE are legit errors given
        // that tab closing aborts outgoing connections to the server.
        socket.on('error', (error) => {
            if (error.code !== 'ECONNRESET' && error.code !== 'HPE_INVALID_EOF_STATE')
                throw error;
        });
        socket.once('close', () => this._sockets.delete(socket));
    }
}
export async function setupSocksForwardingServer({ port, forwardPort, allowedTargetPort }) {
    const connectHosts = [];
    const connections = new Map();
    const socksProxy = new SocksProxy();
    socksProxy.setPattern('*');
    socksProxy.addListener(SocksProxy.Events.SocksRequested, async (payload) => {
        if (!['127.0.0.1', 'fake-localhost-127-0-0-1.nip.io', 'localhost'].includes(payload.host) || payload.port !== allowedTargetPort) {
            socksProxy.sendSocketError({ uid: payload.uid, error: 'ECONNREFUSED' });
            return;
        }
        const target = new net.Socket();
        target.on('error', error => socksProxy.sendSocketError({ uid: payload.uid, error: error.toString() }));
        target.on('end', () => socksProxy.sendSocketEnd({ uid: payload.uid }));
        target.on('data', data => socksProxy.sendSocketData({ uid: payload.uid, data }));
        target.setKeepAlive(false);
        target.connect(forwardPort, '127.0.0.1');
        target.on('connect', () => {
            connections.set(payload.uid, target);
            if (!connectHosts.includes(`${payload.host}:${payload.port}`))
                connectHosts.push(`${payload.host}:${payload.port}`);
            socksProxy.socketConnected({ uid: payload.uid, host: target.localAddress, port: target.localPort });
        });
    });
    socksProxy.addListener(SocksProxy.Events.SocksData, async (payload) => {
        connections.get(payload.uid)?.write(payload.data);
    });
    socksProxy.addListener(SocksProxy.Events.SocksClosed, (payload) => {
        connections.get(payload.uid)?.destroy();
        connections.delete(payload.uid);
    });
    await socksProxy.listen(port, '127.0.0.1');
    return {
        closeProxyServer: () => socksProxy.close(),
        proxyServerAddr: `socks5://127.0.0.1:${port}`,
        connectHosts,
    };
}
//# sourceMappingURL=proxy.js.map