import type { IpcMainEvent, WebContents } from 'electron/main'
import { app, ipcMain } from 'electron/main'

interface RendererProxyRequest {
  url: string
  method: string
  headers?: Record<string, string>
  body?: string
}

interface RendererProxyResponse {
  ok: boolean
  status: number
  statusText: string
  headers: Record<string, string>
  bodyText: string
  error?: string
}

let rendererWebContents: WebContents | null = null
let requestSequence = 0
const pendingRequests = new Map<
  string,
  {
    resolve: (value: RendererProxyResponse) => void
    reject: (error: Error) => void
    timeout: ReturnType<typeof setTimeout>
  }
>()
const rendererProxyRequestChannel = 'desktop:renderer-devtools-proxy:request'
const rendererProxyResponseChannel = 'desktop:renderer-devtools-proxy:response'
const rendererDevtoolsProxyEnabled = !app.isPackaged

if (rendererDevtoolsProxyEnabled) {
  ipcMain.on(rendererProxyResponseChannel, handleRendererProxyResponse)
}

export function registerRendererDevtoolsProxyTarget(webContents: WebContents): void {
  if (!rendererDevtoolsProxyEnabled) {
    return
  }

  rendererWebContents = webContents
  webContents.once('destroyed', () => {
    if (rendererWebContents === webContents) {
      rendererWebContents = null
    }
  })
}

export function canUseRendererDevtoolsProxy(): boolean {
  return (
    rendererDevtoolsProxyEnabled &&
    Boolean(rendererWebContents && !rendererWebContents.isDestroyed())
  )
}

export async function rendererDevtoolsFetch(
  request: RendererProxyRequest,
): Promise<RendererProxyResponse> {
  if (!rendererDevtoolsProxyEnabled) {
    throw new Error('renderer_devtools_proxy_unavailable')
  }

  if (!rendererWebContents || rendererWebContents.isDestroyed()) {
    throw new Error('renderer_devtools_proxy_unavailable')
  }

  const requestId = `renderer-proxy-${Date.now()}-${(requestSequence += 1)}`

  return await new Promise<RendererProxyResponse>((resolve, reject) => {
    const timeout = setTimeout(() => {
      pendingRequests.delete(requestId)
      reject(new Error('renderer_devtools_proxy_timeout'))
    }, 30_000)

    pendingRequests.set(requestId, {
      resolve,
      reject,
      timeout,
    })

    try {
      rendererWebContents?.send(rendererProxyRequestChannel, {
        requestId,
        request,
      })
    } catch (error) {
      clearTimeout(timeout)
      pendingRequests.delete(requestId)
      reject(error instanceof Error ? error : new Error('renderer_devtools_proxy_send_failed'))
    }
  })
}

function handleRendererProxyResponse(
  event: IpcMainEvent,
  payload: {
    requestId?: unknown
    response?: unknown
  },
): void {
  if (rendererWebContents && event.sender !== rendererWebContents) {
    return
  }

  const requestId = typeof payload?.requestId === 'string' ? payload.requestId : ''
  if (!requestId) {
    return
  }

  const pending = pendingRequests.get(requestId)
  if (!pending) {
    return
  }

  clearTimeout(pending.timeout)
  pendingRequests.delete(requestId)

  const response = payload.response
  if (!isRendererProxyResponse(response)) {
    pending.reject(new Error('renderer_devtools_proxy_invalid_response'))
    return
  }

  pending.resolve(response)
}

function isRendererProxyResponse(value: unknown): value is RendererProxyResponse {
  if (!value || typeof value !== 'object') {
    return false
  }

  const candidate = value as Partial<RendererProxyResponse>
  return (
    typeof candidate.ok === 'boolean' &&
    typeof candidate.status === 'number' &&
    typeof candidate.statusText === 'string' &&
    typeof candidate.bodyText === 'string' &&
    Boolean(candidate.headers && typeof candidate.headers === 'object')
  )
}