import logger from '@wdio/logger'
import { sleep } from '@wdio/utils'
import type { Options } from '@wdio/types'

import { type RequestInit as UndiciRequestInit } from 'undici'

import  { WebDriverResponseError, WebDriverRequestError } from './error.js'
import { RETRYABLE_STATUS_CODES, RETRYABLE_ERROR_CODES } from './constants.js'
import type { WebDriverResponse, RequestLibResponse, RequestOptions, RequestEventHandler } from './types.js'

import { isSuccessfulResponse } from '../utils.js'
import { DEFAULTS } from '../constants.js'
import pkg from '../../package.json' with { type: 'json' }

import './polyfill.js'

const ERRORS_TO_EXCLUDE_FROM_RETRY = [
    'detached shadow root',
    'move target out of bounds'
]

const DEFAULT_HEADERS = {
    'Content-Type': 'application/json; charset=utf-8',
    'Connection': 'keep-alive',
    'Accept': 'application/json',
    'User-Agent': 'webdriver/' + pkg.version
}

const log = logger('webdriver')

export abstract class WebDriverRequest {
    protected abstract fetch(url: URL, opts: RequestInit): Promise<Response>

    body?: Record<string, unknown>
    method: string
    endpoint: string
    isHubCommand: boolean
    requiresSessionId: boolean
    eventHandler: RequestEventHandler
    abortSignal?: AbortSignal
    constructor (
        method: string,
        endpoint: string,
        body?: Record<string, unknown>,
        abortSignal?: AbortSignal,
        isHubCommand: boolean = false,
        eventHandler: RequestEventHandler = {}
    ) {
        this.body = body
        this.method = method
        this.endpoint = endpoint
        this.isHubCommand = isHubCommand
        this.requiresSessionId = Boolean(this.endpoint.match(/:sessionId/))
        this.eventHandler = eventHandler
        this.abortSignal = abortSignal
    }

    async makeRequest (options: RequestOptions, sessionId?: string) {
        const { url, requestOptions } = await this.createOptions(options, sessionId)
        this.eventHandler.onRequest?.(requestOptions)
        return this._request(url, requestOptions, options.transformResponse, options.connectionRetryCount, 0)
    }

    async createOptions (options: RequestOptions, sessionId?: string, isBrowser: boolean = false): Promise<{ url: URL; requestOptions: RequestInit; }> {
        const timeout = options.connectionRetryTimeout || DEFAULTS.connectionRetryTimeout.default as number
        const requestOptions: RequestInit = {
            method: this.method,
            redirect: 'follow',
            signal: AbortSignal.any([
                AbortSignal.timeout(timeout),
                ...(this.abortSignal ? [this.abortSignal] : [])
            ])
        }

        const requestHeaders: HeadersInit = new Headers({
            ...DEFAULT_HEADERS,
            ...(typeof options.headers === 'object' ? options.headers : {})
        })

        const searchParams = isBrowser ? undefined : (typeof options.queryParams === 'object' ? options.queryParams : undefined)

        /**
         * only apply body property if existing
         */
        if (this.body && (Object.keys(this.body).length || this.method === 'POST')) {
            const contentLength = new TextEncoder().encode(JSON.stringify(this.body)).length
            requestOptions.body = this.body as unknown as BodyInit
            requestHeaders.set('Content-Length', `${contentLength}`)
        }

        /**
         * if we don't have a session id we set it here, unless we call commands that don't require session ids, for
         * example /sessions. The call to /sessions is not connected to a session itself and it therefore doesn't
         * require it
         */
        let endpoint = this.endpoint
        if (this.requiresSessionId) {
            if (!sessionId) {
                throw new Error('A sessionId is required for this command')
            }
            endpoint = endpoint.replace(':sessionId', sessionId)
        }

        const url = new URL(`${options.protocol}://${options.hostname}:${options.port}${this.isHubCommand ? this.endpoint : `${options.path || ''}/${endpoint}`.replace(/(\/){2,}/g, '/')}`)

        if (searchParams) {
            url.search = new URLSearchParams(searchParams).toString()
        }

        /**
         * send authentication credentials only when creating new session
         */
        if (this.endpoint === '/session' && options.user && options.key) {
            requestHeaders.set('Authorization', 'Basic ' + btoa(options.user + ':' + options.key))
        }

        requestOptions.headers = requestHeaders

        return {
            url,
            requestOptions: typeof options.transformRequest === 'function'
                ? options.transformRequest(requestOptions)
                : requestOptions
        }
    }

    protected async _libRequest (url: URL, opts: RequestInit): Promise<Options.RequestLibResponse> {
        try {

            const dispatcher = (opts as UndiciRequestInit).dispatcher

            const response = await this.fetch(url, {
                method: opts.method,
                body: JSON.stringify(opts.body),
                headers: opts.headers as Record<string, string>,
                signal: opts.signal,
                redirect: opts.redirect,
                ...(dispatcher ? { dispatcher } : {})
            })

            return {
                statusCode: response.status,
                body: await response.json() ?? {},
            } satisfies Options.RequestLibResponse
        } catch (err) {
            if (!(err instanceof Error)) {
                throw new WebDriverRequestError(
                    new Error(`Failed to fetch ${url.href}: ${(err as Error).message || err || 'Unknown error'}`),
                    url,
                    opts
                )
            }

            throw new WebDriverRequestError(err, url, opts)
        }
    }

    protected async _request (
        url: URL,
        fullRequestOptions: RequestInit,
        transformResponse?: (response: RequestLibResponse, requestOptions: RequestInit) => RequestLibResponse,
        totalRetryCount = 0,
        retryCount = 0
    ): Promise<WebDriverResponse> {
        log.info(`[${fullRequestOptions.method}] ${(url as URL).href}`)

        if (fullRequestOptions.body && Object.keys(fullRequestOptions.body).length) {
            this.eventHandler.onLogData?.(fullRequestOptions.body)
        }

        const { ...requestLibOptions } = fullRequestOptions
        const startTime = performance.now()
        let response = await this._libRequest(url!, requestLibOptions)
            .catch((err: WebDriverRequestError) => err)
        const durationMillisecond = performance.now() - startTime

        /**
         * handle retries for requests
         * @param {Error} error  error object that causes the retry
         * @param {string} msg   message that is being shown as warning to user
         */
        const retry = async (error: Error) => {
            /**
             * stop retrying if totalRetryCount was exceeded or there is no reason to
             * retry, e.g. if sessionId is invalid
             */
            if (retryCount >= totalRetryCount || error.message.includes('invalid session id')) {
                log.error(error.message)
                this.eventHandler.onResponse?.({ error })
                this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: false, error, retryCount })
                throw error
            }

            if (retryCount > 0) {
                /*
                 * Exponential backoff with a minimum of 500ms and a maximum of 10_000ms.
                 */
                await sleep(Math.min(10000, 250 * Math.pow(2, retryCount)))
            }

            ++retryCount

            this.eventHandler.onRetry?.({ error, retryCount })
            this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: false, error, retryCount })
            log.warn(error.message)
            log.info(`Retrying ${retryCount}/${totalRetryCount}`)
            return this._request(url, fullRequestOptions, transformResponse, totalRetryCount, retryCount)
        }

        /**
         * handle request errors
         */
        if (response instanceof Error) {
            const resError = response as WebDriverRequestError

            /**
             * retry failed requests, only if:
             * - the abort signal is not aborted
             * - the error code or status code is retryable
             */
            if (
                !(this.abortSignal && this.abortSignal.aborted) &&
                (
                    (resError.code && RETRYABLE_ERROR_CODES.includes(resError.code)) ||
                    (resError.statusCode && RETRYABLE_STATUS_CODES.includes(resError.statusCode))
                )
            ) {
                return retry(resError)
            }

            /**
             * throw if request error is unknown
             */
            this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: false, error: response, retryCount })
            throw response
        }

        if (typeof transformResponse === 'function') {
            response = transformResponse(response, fullRequestOptions) as RequestLibResponse
        }

        /**
         * Resolve only if successful response
         */
        if (isSuccessfulResponse(response.statusCode, response.body)) {
            this.eventHandler.onResponse?.({ result: response.body })
            this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: true, retryCount })
            return response.body as WebDriverResponse<unknown>
        }

        const error = new WebDriverResponseError(response, url, fullRequestOptions)

        /**
         * hub commands don't follow standard response formats
         * and can have empty bodies
         */
        if (this.isHubCommand) {
            /**
             * if body contains HTML the command was called on a node
             * directly without using a hub, therefore throw
             */
            if (typeof response.body === 'string' && response.body.startsWith('<!DOCTYPE html>')) {
                this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: false, error, retryCount })
                return Promise.reject(new Error('Command can only be called to a Selenium Hub'))
            }

            return { value: response.body || null }
        }

        /**
         * stop retrying as this will never be successful.
         * we will handle this at the elementErrorHandler
         */
        if (error.name === 'stale element reference') {
            log.warn('Request encountered a stale element - terminating request')
            this.eventHandler.onResponse?.({ error })
            this.eventHandler.onPerformance?.({ request: fullRequestOptions, durationMillisecond, success: false, error, retryCount })
            throw error
        }

        /**
         * some errors can be excluded from the request retry mechanism as
         * it likely does not changes anything and the error is handled within the command.
         */
        if (ERRORS_TO_EXCLUDE_FROM_RETRY.includes(error.name)) {
            throw error
        }

        return retry(error)
    }
}