"use strict"

import MessagePack from "what-the-pack"
import pako from "pako"
import uuidv4 from "uuid/v4"

const { encode, decode } = MessagePack.initialize(2 ** 22)

const buffer = new Map()

self.onmessage = (event) => {
  if (event.data.method == "send" || event.data.method == "broadcast") {
    let message = event.data.message
    const compressed = typeof message == "object"
    const uuid = uuidv4()

    message = encode(message)

    if (compressed) {
      message = pako.deflate(message)
    }

    for (let offset = 0; offset < message.length; offset += 2 ** 10) {
      event.data.message = {
        uuid,
        message: message.subarray(offset, offset + 2 ** 10),
        slice: offset / 2 ** 10,
        length: Math.ceil(message.length / 2 ** 10),
        compressed,
      }

      self.postMessage(event.data)
    }
  } else if (event.data.method == "received") {
    let message = event.data.message.message

    if (event.data.message.length > 1) {
      let messages = buffer.get(event.data.peer.id)
      if (!messages) {
        messages = new Map()
        buffer.set(event.data.peer.id, messages)
      }

      let slices = messages.get(event.data.message.uuid)
      if (!slices) {
        slices = []
        messages.set(event.data.message.uuid, slices)
      }

      slices.push(event.data.message)

      if (slices.length < slices[slices.length - 1].length) {
        return
      }

      message = new Uint8Array(
        slices.reduce((acc, s) => acc + s.message.length, 0),
      )

      slices.sort((a, b) => a.slice - b.slice)

      let offset = 0

      for (const slice of slices) {
        message.set(slice.message, offset)
        offset += slice.message.length
      }
    }

    if (event.data.message.compressed) {
      message = pako.inflate(message)
    }

    message = decode(MessagePack.Buffer.from(message))

    event.data.message = message

    self.postMessage(event.data)
  }
}