export const webFrameInit = () => {
  // Call webFrame method
  ipcRendererInternal.on('ELECTRON_INTERNAL_RENDERER_WEB_FRAME_METHOD', (
    _event, method: keyof WebFrameMethod, args: any[]
  ) => {
    // The TypeScript compiler cannot handle the sheer number of
    // call signatures here and simply gives up. Incorrect invocations
    // will be caught by "keyof WebFrameMethod" though.
    (webFrame[method] as any)(...args)
  })

  ipcRendererInternal.on('ELECTRON_INTERNAL_RENDERER_ASYNC_WEB_FRAME_METHOD', (
    event, requestId: number, method: keyof WebFrameMethod, args: any[]
  ) => {
    new Promise(resolve =>
      // The TypeScript compiler cannot handle the sheer number of
      // call signatures here and simply gives up. Incorrect invocations
      // will be caught by "keyof WebFrameMethod" though.
      (webFrame[method] as any)(...args, resolve)
    ).then(result => {
      return [null, result]
    }, error => {
      return [errorUtils.serialize(error)]
    }).then(responseArgs => {
      event.sender.send(`ELECTRON_INTERNAL_BROWSER_ASYNC_WEB_FRAME_RESPONSE_${requestId}`, ...responseArgs)
    })
  })
}

 return new Promise<T>((resolve, reject) => {
   const requestId = ++nextId
   ipcRendererInternal.once(`${command}_RESPONSE_${requestId}`, (
     _event, error: Electron.SerializedError, result: any
   ) => {
     if (error) {
       reject(errorUtils.deserialize(error))
     } else {
       resolve(result)
     }
   })
   ipcRendererInternal.send(command, requestId, ...args)
 })

export function invokeSync<T> (command: string, ...args: any[]): T {
  const [ error, result ] = ipcRendererInternal.sendSync(command, null, ...args)

  if (error) {
    throw errorUtils.deserialize(error)
  } else {
    return result
  }
}

export function registerEvents (webView: WebViewImpl, viewInstanceId: number) {
  ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`, function () {
    webView.guestInstanceId = undefined
    webView.reset()
    const domEvent = new Event('destroyed')
    webView.dispatchEvent(domEvent)
  })

  ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`, function (event, eventName, ...args) {
    dispatchEvent(webView, eventName, eventName, ...args)
  })

  ipcRendererInternal.on(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`, function (event, channel, ...args) {
    const domEvent = new Event('ipc-message') as IpcMessageEvent
    domEvent.channel = channel
    domEvent.args = args

    webView.dispatchEvent(domEvent)
  })
}

ipcRendererInternal.on('CHROME_TABS_EXECUTESCRIPT', function (
  event,
  senderWebContentsId: number,
  requestId: number,
  extensionId: string,
  url: string,
  code: string
) {
  const result = runContentScript.call(window, extensionId, url, code)
  ipcRendererInternal.sendToAll(senderWebContentsId, `CHROME_TABS_EXECUTESCRIPT_RESULT_${requestId}`, result)
})

export const handle = function <T extends IPCHandler> (channel: string, handler: T) {
  ipcRendererInternal.on(channel, (event, requestId, ...args) => {
    new Promise(resolve => resolve(handler(event, ...args))
    ).then(result => {
      return [null, result]
    }, error => {
      return [errorUtils.serialize(error)]
    }).then(responseArgs => {
      event.sender.send(`${channel}_RESPONSE_${requestId}`, ...responseArgs)
    })
  })
}

const { isParentDir } = require('@electron/internal/common/path-utils')

let absoluteAppPath: string
const getAppPath = function () {
  if (absoluteAppPath === undefined) {
    absoluteAppPath = fs.realpathSync(appPath!)
  }
  return absoluteAppPath
}

// Load the preload scripts.
for (const preloadScript of preloadScripts) {
  try {
    if (!isParentDir(getAppPath(), fs.realpathSync(preloadScript))) {
      throw new Error('Preload scripts outside of app path are not allowed')
    }
    require(preloadScript)
  } catch (error) {
    console.error(`Unable to load preload script: ${preloadScript}`)
    console.error(`${error}`)

    ipcRendererInternal.send('ELECTRON_BROWSER_PRELOAD_ERROR', preloadScript, errorUtils.serialize(error))
  }
}

// Warn about security issues
if (process.isMainFrame) {
  const { securityWarnings } = require('@electron/internal/renderer/security-warnings')
  securityWarnings(nodeIntegration)
}

export function deregisterEvents (viewInstanceId: number) {
  ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DESTROY_GUEST-${viewInstanceId}`)
  ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-${viewInstanceId}`)
  ipcRendererInternal.removeAllListeners(`ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE-${viewInstanceId}`)
}

 window.addEventListener('focus', () => {
   ipcRendererInternal.send('ELECTRON_GUEST_VIEW_MANAGER_FOCUS_CHANGE', true, guestInstanceId)
 })