import fs from 'node:fs'
import path from 'node:path'
import cp, { type ChildProcess } from 'node:child_process'

import getPort from 'get-port'
import waitPort from 'wait-port'
import logger from '@wdio/logger'
import split2 from 'split2'
import { deepmerge } from 'deepmerge-ts'

import { start as startSafaridriver, type SafaridriverOptions as SafaridriverParameters } from 'safaridriver'
import { start as startGeckodriver, type GeckodriverParameters } from 'geckodriver'
import { start as startEdgedriver, findEdgePath, type EdgedriverParameters } from 'edgedriver'
import type { InstallOptions } from '@puppeteer/browsers'

import type { Capabilities } from '@wdio/types'

import { parseParams, setupPuppeteerBrowser, setupChromedriver, getCacheDir, generateDefaultPrefs } from './utils.js'
import { isChrome, isFirefox, isEdge, isSafari, isAppiumCapability } from '../utils.js'
import { SUPPORTED_BROWSERNAMES } from '../constants.js'

export type ChromedriverParameters = (
    Partial<InstallOptions> &
    Omit<EdgedriverParameters, 'port' | 'edgeDriverVersion' | 'customEdgeDriverPath'> &
    Pick<GeckodriverParameters, 'spawnOpts'>
)
declare global {
    namespace WebdriverIO {
        interface ChromedriverOptions extends ChromedriverParameters {}
        interface GeckodriverOptions extends Omit<GeckodriverParameters, 'port'> {}
        interface EdgedriverOptions extends Omit<EdgedriverParameters, 'port'> {}
        interface SafaridriverOptions extends Omit<SafaridriverParameters, 'port'> {}
    }
}

const log = logger('@wdio/utils')
const DRIVER_WAIT_TIMEOUT = 10 * 1000 // 10s
const DRIVER_RETRY_INTERVAL = 100

export async function startWebDriver (options: Capabilities.RemoteConfig) {
    /**
     * in case we are running unit tests, just return
     */
    if (process.env.WDIO_SKIP_DRIVER_SETUP) {
        options.hostname = 'localhost'
        options.port = 4321
        return
    }

    let driverProcess: ChildProcess
    let driver = ''
    const start = Date.now()
    const caps = (options.capabilities as Capabilities.W3CCapabilities).alwaysMatch || options.capabilities as WebdriverIO.Capabilities

    /**
     * session might be a mobile session so don't do anything
     */
    if (isAppiumCapability(caps)) {
        return
    }

    if (!caps.browserName) {
        throw new Error(
            'No "browserName" defined in capabilities nor hostname or port found!\n' +
            'If you like to run a local browser session make sure to pick from one of ' +
            `the following browser names: ${Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity)}`
        )
    }

    const port = await getPort()
    const cacheDir = getCacheDir(options, caps)
    if (isChrome(caps.browserName)) {
        /**
         * Chrome
         */
        const chromedriverOptions = caps['wdio:chromedriverOptions'] || ({} as WebdriverIO.ChromedriverOptions)
        /**
         * support for custom chromedriver path via environment variable like
         * other drivers do as well
         */
        const chromedriverBinary = chromedriverOptions.binary || process.env.CHROMEDRIVER_PATH
        const { executablePath: chromeExecuteablePath, browserVersion } = await setupPuppeteerBrowser(cacheDir, caps)
        const { executablePath: chromedriverExcecuteablePath } = chromedriverBinary
            ? { executablePath: chromedriverBinary }
            : await setupChromedriver(cacheDir, browserVersion)

        const prefs = generateDefaultPrefs(caps)
        caps['goog:chromeOptions'] = deepmerge(
            { binary: chromeExecuteablePath },
            prefs,
            caps['goog:chromeOptions'] || {}
        )
        chromedriverOptions.allowedOrigins = chromedriverOptions.allowedOrigins || ['*']
        chromedriverOptions.allowedIps = chromedriverOptions.allowedIps || ['0.0.0.0']
        const driverParams = parseParams({ port, ...chromedriverOptions })
        /**
         * Set NODE_OPTIONS empty to avoid passing it to the chromedriver process so that Electron doesn't crash
         */
        driverProcess = cp.spawn(chromedriverExcecuteablePath, driverParams, {
            env: { ...process.env, NODE_OPTIONS: '' },
            ...(chromedriverOptions.spawnOpts || {})
        })
        driver = `Chromedriver v${browserVersion} with params ${driverParams.join(' ')}`
    } else if (isSafari(caps.browserName)) {
        const safaridriverOptions = caps['wdio:safaridriverOptions'] || ({} as WebdriverIO.SafaridriverOptions)
        /**
         * Safari
         */
        driver = 'SafariDriver'
        driverProcess = startSafaridriver({
            useTechnologyPreview: /preview/i.test(caps.browserName),
            ...safaridriverOptions,
            port
        })
    } else if (isFirefox(caps.browserName)) {
        /**
         * Firefox
         */
        const { executablePath } = await setupPuppeteerBrowser(cacheDir, caps)
        caps['moz:firefoxOptions'] = deepmerge(
            { binary: executablePath },
            caps['moz:firefoxOptions'] || {}
        )

        /**
         * the "binary" parameter refers to the driver binary in the WebdriverIO.GeckodriverOptions and
         * to the Firefox binary in the driver option
         */
        delete caps.browserVersion
        const { binary, ...geckodriverOptions } = caps['wdio:geckodriverOptions'] || ({} as WebdriverIO.GeckodriverOptions)
        if (binary) {
            geckodriverOptions.customGeckoDriverPath = binary
        }

        driver = 'GeckoDriver'
        driverProcess = await startGeckodriver({ ...geckodriverOptions, cacheDir, port, allowHosts: ['localhost'] })
    } else if (isEdge(caps.browserName)) {
        /**
         * Microsoft Edge
         */
        const { binary, ...edgedriverOptions } = caps['wdio:edgedriverOptions'] || ({} as WebdriverIO.EdgedriverOptions)
        if (binary) {
            edgedriverOptions.customEdgeDriverPath = binary
        }

        driver = 'EdgeDriver'
        driverProcess = await startEdgedriver({ ...edgedriverOptions, cacheDir, port, allowedIps: ['0.0.0.0'] }).catch((err) => {
            log.warn(`Couldn't start EdgeDriver: ${err.message}, retry ...`)
            return startEdgedriver({ ...edgedriverOptions, cacheDir, port })
        })

        /**
         * Microsoft Edge is very particular when it comes to browser names
         */
        caps.browserName = 'MicrosoftEdge'

        /**
         * on Linux set the path to the Edge binary if not already set
         */
        if (!caps['ms:edgeOptions']?.binary) {
            caps['ms:edgeOptions'] = caps['ms:edgeOptions'] || {}
            caps['ms:edgeOptions'].binary = findEdgePath()
            log.info(`Found Edge binary at ${caps['ms:edgeOptions'].binary}`)
        }
    } else {
        throw new Error(
            `Unknown browser name "${caps.browserName}". Make sure to pick from one of the following ` +
            Object.values(SUPPORTED_BROWSERNAMES).flat(Infinity)
        )
    }

    const logIdentifier = driver.split(' ').shift()?.toLowerCase() || 'driver'
    if (options.outputDir) {
        const logFileName = process.env.WDIO_WORKER_ID
            ? `wdio-${process.env.WDIO_WORKER_ID}-${logIdentifier}.log`
            : `wdio-${logIdentifier}-${port}.log`
        const logFile = path.resolve(options.outputDir, logFileName)
        const logStream = fs.createWriteStream(logFile, { flags: 'w' })
        driverProcess.stdout?.pipe(logStream)
        driverProcess.stderr?.pipe(logStream)
    } else {
        const driverLog = logger(logIdentifier)
        driverProcess.stdout?.pipe(split2()).on('data', driverLog.info.bind(driverLog))
        driverProcess.stderr?.pipe(split2()).on('data', driverLog.warn.bind(driverLog))
    }

    await waitPort({ port, output: 'silent', timeout: DRIVER_WAIT_TIMEOUT, interval: DRIVER_RETRY_INTERVAL })
        .catch((e) => { throw new Error(`Timed out to connect to ${driver}: ${e.message}`) })

    options.hostname = 'localhost'
    options.port = port
    log.info(`Started ${driver} in ${Date.now() - start}ms on port ${port}`)
    return driverProcess
}