import { configs } from './configs'
import { formDataToQuery } from '../utils/request-utils'
import { isFormData, isNullish, isObject, isString } from '../utils/type-utils'

function _tryReadXHRBody({
  body,
}: {
  body: any | null | undefined
  url: string | URL | RequestInfo
}): string | null {
  if (isNullish(body)) {
    return null
  }

  if (isString(body)) {
    return body
  }

  if (isFormData(body)) {
    return formDataToQuery(body)
  }

  if (isObject(body)) {
    try {
      return JSON.stringify({ ...body })
    } catch {
      return '[XHR] Failed to stringify response object'
    }
  }

  return `[XHR] Cannot read body of type ${Object.prototype.toString.call(body)}`
}

// Only patch XMLHttpRequest if not on web platform or if XMLHttpRequest is available
if (typeof XMLHttpRequest !== 'undefined') {
  ;(function (xhr) {
    const originalOpen = XMLHttpRequest.prototype.open

    xhr.open = function (
      method: string,
      url: string | URL,
      async = true,
      username?: string | null,
      password?: string | null,
    ) {
      const xhr = this as XMLHttpRequest
      const networkRequest: {
        requestHeaders?: any
        requestBody?: any
        responseHeaders?: any
        responseBody?: any
      } = {}

      // ts-expect-error
      const requestHeaders: Record<string, string> = {}
      const originalSetRequestHeader = xhr.setRequestHeader.bind(xhr)
      xhr.setRequestHeader = (header: string, value: string) => {
        requestHeaders[header] = value
        return originalSetRequestHeader(header, value)
      }
      if (configs.recordRequestHeaders) {
        networkRequest.requestHeaders = requestHeaders
      }

      const originalSend = xhr.send.bind(xhr)
      xhr.send = (body) => {
        if (configs.shouldRecordBody) {
          const requestBody = _tryReadXHRBody({ body, url })

          if (
            requestBody?.length &&
            requestBody.length <= configs.maxCapturingHttpPayloadSize
          ) {
            networkRequest.requestBody = requestBody
          }
        }
        return originalSend(body)
      }

      xhr.addEventListener('readystatechange', () => {
        if (xhr.readyState !== xhr.DONE) {
          return
        }

        // ts-expect-error
        const responseHeaders: Record<string, string> = {}
        const rawHeaders = xhr.getAllResponseHeaders() || ''
        const headers = rawHeaders
          .trim()
          .split(/[\r\n]+/)
          .filter(Boolean)

        headers.forEach((line) => {
          const parts = line.split(': ')
          const header = parts.shift()
          const value = parts.join(': ')
          if (header) {
            responseHeaders[header] = value
          }
        })
        if (configs.recordResponseHeaders) {
          networkRequest.responseHeaders = responseHeaders
        }
        if (configs.shouldRecordBody) {
          const responseBody = _tryReadXHRBody({ body: xhr.response, url })

          if (
            responseBody?.length &&
            responseBody.length <= configs.maxCapturingHttpPayloadSize
          ) {
            networkRequest.responseBody = responseBody
          }
        }
      })

      // @ts-expect-error
      xhr.networkRequest = networkRequest

      originalOpen.call(xhr, method, url as string, async, username, password)
    }
  })(XMLHttpRequest.prototype)
} else {
  console.info('XHR patch: XMLHttpRequest patching not available')
}