/**
 * Attempts to connect to an instance of Chrome with an open remote-debugging
 * port. If none is found, launches a debuggable instance.
 */
async function getDebuggableChrome(flags: Flags) {
  return await launch({
    port: flags.port,
    chromeFlags: parseChromeFlags(flags.chromeFlags),
    logLevel: flags.logLevel
  });
}

export function launchChrome(url): [Promise<void>, IChromeProcess] {
    let resolveFinish: (code: number) => void;
    let rejectFinish: (err: Error) => void;
    let launchedChrome: LaunchedChrome;
    let res: IChromeProcess = {
        // crash/finish notification does not work with chrome-launcher
        finish: new Promise<number>((resolve, reject) => {
            resolveFinish = resolve;
            rejectFinish = reject;
        }),
        kill() {
            if (launchedChrome) launchedChrome.kill();
        }
    };

    return [
        chromeLauncher
            .launch({
                startingUrl: url,
                chromeFlags: ["--headless", "--disable-gpu"]
            })
            .then(chrome => {
                launchedChrome = chrome;
            })
            .catch(rejectFinish),
        res
    ];
}

/**
 * Launches Chrome with the specified options.
 *
 * @param {CreateOptions} options the options for Chrome.
 * @returns {Promise<LaunchedChrome>} The launched Chrome instance.
 */
async function launchChrome(options: CreateOptions): Promise<LaunchedChrome> {
  const chrome = await launch({
    port: options.port,
    chromePath: options.chromePath,
    chromeFlags: options.chromeFlags || DEFAULT_CHROME_FLAGS,
  });
  options.port = chrome.port;
  return chrome;
}

 private async startChrome(): Promise<Client> {
   this.chromeInstance = await launch({
     logLevel: this.options.debug ? 'info' : 'silent',
     port: this.options.cdp.port,
   })
   const target = await CDP.New({
     port: this.chromeInstance.port,
   })
   return await CDP({ target })
 }

 before(async () => {
   try {
     // Start Chrome and wait for it to start listening for connections.
     chrome = await chromeLauncher.launch({
       chromeFlags: [
         '--disable-gpu',
         '--headless',
       ],
     });
     port = chrome.port;
     await tcpPortUsed.waitUntilUsed(port);
   } catch (err) {
     await chrome.kill();
     throw err;
   }
 });

  private async startChrome(): Promise<Client> {
    const { port } = this.options.cdp
    this.chromeInstance = await launch({
      logLevel: this.options.debug ? 'info' : 'silent',
      chromeFlags: [
        // Do not render scroll bars
        '--hide-scrollbars',

        // The following options copied verbatim from https://github.com/GoogleChrome/chrome-launcher/blob/master/src/flags.ts

        // Disable built-in Google Translate service
        '--disable-translate',
        // Disable all chrome extensions entirely
        '--disable-extensions',
        // Disable various background network services, including extension updating,
        //   safe browsing service, upgrade detector, translate, UMA
        '--disable-background-networking',
        // Disable fetching safebrowsing lists, likely redundant due to disable-background-networking
        '--safebrowsing-disable-auto-update',
        // Disable syncing to a Google account
        '--disable-sync',
        // Disable reporting to UMA, but allows for collection
        '--metrics-recording-only',
        // Mute any audio
        '--mute-audio',
        // Skip first run wizards
        '--no-first-run',
      ],
      port,
    })
    const target = await CDP.New({
      port,
    })
    return await CDP({ target, port })
  }