import { type Span } from '@opentelemetry/api'
import {
  MULTIPLAYER_TRACE_DEBUG_PREFIX,
  MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX,
  MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX,
  ATTR_MULTIPLAYER_HTTP_REQUEST_BODY,
  ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS,
  ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY,
  ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS,
} from '@multiplayer-app/session-recorder-common'
import { logger } from '../utils'
import { type TracerReactNativeConfig } from '../types'

export interface HttpPayloadData {
  requestBody?: any
  responseBody?: any
  requestHeaders?: Record<string, string>
  responseHeaders?: Record<string, string>
}

export interface ProcessedHttpPayload {
  requestBody?: string
  responseBody?: string
  requestHeaders?: string
  responseHeaders?: string
}

/**
 * Checks if the trace should be processed based on trace ID prefixes
 */
export function shouldProcessTrace(traceId: string): boolean {
  return (
    traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
    traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX) ||
    traceId.startsWith(MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX)
  )
}

/**
 * Processes request and response body based on trace type and configuration
 */
export function processBody(
  payload: HttpPayloadData,
  config: TracerReactNativeConfig,
  span: Span,
): { requestBody?: string; responseBody?: string } {
  const { captureBody, masking } = config
  const traceId = span.spanContext().traceId

  if (!captureBody) {
    return {}
  }

  let { requestBody, responseBody } = payload

  if (requestBody !== undefined && requestBody !== null) {
    requestBody = JSON.parse(JSON.stringify(requestBody))
  }
  if (responseBody !== undefined && responseBody !== null) {
    responseBody = JSON.parse(JSON.stringify(responseBody))
  }

  // Apply masking for debug traces
  if (
    traceId.startsWith(MULTIPLAYER_TRACE_DEBUG_PREFIX) ||
    traceId.startsWith(MULTIPLAYER_TRACE_CONTINUOUS_DEBUG_PREFIX) ||
    traceId.startsWith(MULTIPLAYER_TRACE_SESSION_CACHE_PREFIX)
  ) {
    if (masking.isContentMaskingEnabled) {
      requestBody = requestBody && masking.maskBody?.(requestBody, span)
      responseBody = responseBody && masking.maskBody?.(responseBody, span)
    }
  }

  // Convert to string if needed
  if (typeof requestBody !== 'string') {
    requestBody = JSON.stringify(requestBody)
  }

  if (typeof responseBody !== 'string') {
    responseBody = JSON.stringify(responseBody)
  }

  return {
    requestBody: requestBody?.length ? requestBody : undefined,
    responseBody: responseBody?.length ? responseBody : undefined,
  }
}

/**
 * Processes request and response headers based on configuration
 */
export function processHeaders(
  payload: HttpPayloadData,
  config: TracerReactNativeConfig,
  span: Span,
): { requestHeaders?: string; responseHeaders?: string } {
  const { captureHeaders, masking } = config

  if (!captureHeaders) {
    return {}
  }

  let { requestHeaders = {}, responseHeaders = {} } = payload

  // Handle header filtering
  if (!masking.headersToInclude?.length && !masking.headersToExclude?.length) {
    // Add null checks to prevent JSON.parse error when headers is undefined
    if (requestHeaders !== undefined && requestHeaders !== null) {
      requestHeaders = JSON.parse(JSON.stringify(requestHeaders))
    }
    if (responseHeaders !== undefined && responseHeaders !== null) {
      responseHeaders = JSON.parse(JSON.stringify(responseHeaders))
    }
  } else {
    if (masking.headersToInclude) {
      const _requestHeaders: Record<string, string> = {}
      const _responseHeaders: Record<string, string> = {}

      for (const headerName of masking.headersToInclude) {
        if (requestHeaders[headerName]) {
          _requestHeaders[headerName] = requestHeaders[headerName]
        }
        if (responseHeaders[headerName]) {
          _responseHeaders[headerName] = responseHeaders[headerName]
        }
      }

      requestHeaders = _requestHeaders
      responseHeaders = _responseHeaders
    }

    if (masking.headersToExclude?.length) {
      for (const headerName of masking.headersToExclude) {
        delete requestHeaders[headerName]
        delete responseHeaders[headerName]
      }
    }
  }

  // Apply masking
  const maskedRequestHeaders =
    masking.maskHeaders?.(requestHeaders, span) || requestHeaders
  const maskedResponseHeaders =
    masking.maskHeaders?.(responseHeaders, span) || responseHeaders

  // Convert to string
  const requestHeadersStr =
    typeof maskedRequestHeaders === 'string'
      ? maskedRequestHeaders
      : JSON.stringify(maskedRequestHeaders)

  const responseHeadersStr =
    typeof maskedResponseHeaders === 'string'
      ? maskedResponseHeaders
      : JSON.stringify(maskedResponseHeaders)

  return {
    requestHeaders: requestHeadersStr?.length ? requestHeadersStr : undefined,
    responseHeaders: responseHeadersStr?.length
      ? responseHeadersStr
      : undefined,
  }
}

/**
 * Processes HTTP payload (body and headers) and sets span attributes
 */
export function processHttpPayload(
  payload: HttpPayloadData,
  config: TracerReactNativeConfig,
  span: Span,
): void {
  const traceId = span.spanContext().traceId

  if (!shouldProcessTrace(traceId)) {
    return
  }

  const { requestBody, responseBody } = processBody(payload, config, span)
  const { requestHeaders, responseHeaders } = processHeaders(
    payload,
    config,
    span,
  )

  // Set span attributes
  if (requestBody) {
    span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_BODY, requestBody)
  }

  if (responseBody) {
    span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_BODY, responseBody)
  }

  if (requestHeaders) {
    span.setAttribute(ATTR_MULTIPLAYER_HTTP_REQUEST_HEADERS, requestHeaders)
  }

  if (responseHeaders) {
    span.setAttribute(ATTR_MULTIPLAYER_HTTP_RESPONSE_HEADERS, responseHeaders)
  }
}

/**
 * Converts Headers object to plain object
 */
export function headersToObject(
  headers:
    | Headers
    | Record<string, string>
    | Record<string, string | string[]>
    | string[][]
    | undefined,
): Record<string, string> {
  const result: Record<string, string> = {}

  if (!headers) {
    return result
  }

  if (headers instanceof Headers) {
    headers.forEach((value: string, key: string) => {
      result[key] = value
    })
  } else if (Array.isArray(headers)) {
    // Handle array of [key, value] pairs
    for (const [key, value] of headers) {
      if (typeof key === 'string' && typeof value === 'string') {
        result[key] = value
      }
    }
  } else if (typeof headers === 'object' && !Array.isArray(headers)) {
    for (const [key, value] of Object.entries(headers)) {
      if (typeof key === 'string' && typeof value === 'string') {
        result[key] = value
      }
    }
  }

  return result
}

/**
 * Extracts response body as string from Response object
 */
export async function extractResponseBody(
  response: Response,
): Promise<string | null> {
  if (!response.body) {
    return null
  }

  try {
    if (response.body instanceof ReadableStream) {
      // Check if response body is already consumed
      if (response.bodyUsed) {
        return null
      }

      const responseClone = response.clone()
      return responseClone.text()
    } else {
      return JSON.stringify(response.body)
    }
  } catch (error) {
    // If cloning fails (body already consumed), return null

    logger.warn(
      'MULTIPLAYER_SESSION_RECORDER',
      'Failed to extract response body',
      error,
    )
    return null
  }
}

export const getExporterEndpoint = (exporterEndpoint: string): string => {
  const hasPath =
    exporterEndpoint &&
    (() => {
      try {
        const url = new URL(exporterEndpoint)
        return url.pathname !== '/' && url.pathname !== ''
      } catch {
        return false
      }
    })()

  if (hasPath) {
    return exporterEndpoint
  }

  const trimmedExporterEndpoint = new URL(exporterEndpoint).origin

  return `${trimmedExporterEndpoint}/v1/traces`
}