export function web_basic_api(hub, plugin_options) ::
  const yes = @=> true

  let hello = plugin_options.hello || 'mc'

  return @{}
    connect(tgt, options) ::
      let channel = this.createChannel(tgt, options)
      if null == channel.channel_id ::
        channel.channel_id = 'web_basic'

      return channel.init @ channel.channel_id

    createChannel(tgt, options) ::
      if null == options :: options = {}

      let [tgt_send, tgt_recv] = Array.isArray(tgt) ? tgt : [tgt, tgt]
      tgt_send = (tgt_send.postMessage || tgt_send.send).bind(tgt_send)

      let {codec} = options
      let args = @[]
        this.p2p || hub.p2p
        pkt => @ tgt_send(pkt), true
        codec

      let [recv, channel] = codec
        ? hub.router.codec_channel(...args)
        : hub.router.send_channel(...args)
      channel.channel_id = options.channel_id

      if tgt_recv.close ::
        channel.close = @=> @ tgt_recv.close(), true

      let subscribe = options.subscribe || _on_msg_evt
      subscribe @ tgt_recv, recv, options.accept || yes

      if 'function' === typeof tgt_recv.start ::
        tgt_recv.start()
      return channel


    mc_connect(opt, tgt1, tgt2) ::
      if 'string' === typeof opt ::
        opt = {client_id: opt}

      let mc = new MessageChannel()
      tgt1.postMessage @ {hello, mc_port: mc.port1, ...opt}, [mc.port1]
      if tgt2 && tgt2.postMessage ::
        tgt2.postMessage @ {hello, mc_port: mc.port2, ...opt}, [mc.port2]
      else ::
        return this.connect @ mc.port2, tgt2

    mc_server(host, options={}) ::
      let id_pre = options.channel_id || 'mcsv-'
      host.addEventListener @ 'message', evt => ::
        let {data} = evt
        if data && hello == data.hello ::
          if evt :: evt.stopPropagation()

          let chan = this.connect @
            data.mc_port || evt.ports[0],
            @{} ... options
                channel_id: `${id_pre}${data.client_id}`

          if options.on_mc_connection ::
            options.on_mc_connection(chan, data)


    p2p: plugin_options.p2p


  function _on_msg_evt(tgt_recv, fn_recv_pkt, fn_accept) ::
    tgt_recv.addEventListener @ 'message',
      evt => true === fn_accept(evt) && fn_recv_pkt(evt.data, evt)
      @{} passive: true