import okio.DeflaterSink

private val EMPTY_DEFLATE_BLOCK = "000000ffff".decodeHex()
private const val LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION = 4

class MessageDeflater(
  private val noContextTakeover: Boolean,
) : Closeable {
  private val deflatedBytes = Buffer()

  private val deflater =
    Deflater(
      Deflater.DEFAULT_COMPRESSION,
      // nowrap (omits zlib header):
      true,
    )

import java.io.IOException
import java.util.zip.Inflater
import okio.Buffer
import okio.InflaterSource

private const val OCTETS_TO_ADD_BEFORE_INFLATION = 0x0000ffff

class MessageInflater(
  private val noContextTakeover: Boolean,
) : Closeable {
  private val deflatedBytes = Buffer()

  private val inflater =
    Inflater(
      // nowrap (omits zlib header):
      true,
    )

 */
class WebSocketWriter(
  private val isClient: Boolean,
  val sink: BufferedSink,
  val random: Random,
  private val perMessageDeflate: Boolean,
  private val noContextTakeover: Boolean,
  private val minimumDeflateSize: Long,
) : Closeable {
  /** This holds outbound data for compression and masking. */
  private val messageBuffer = Buffer()

      sink = data,
      random = random,
      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )
  private val clientWriter =
    WebSocketWriter(
      isClient = true,
      sink = data,
      random = random,
      perMessageDeflate = false,
      noContextTakeover = false,
      minimumDeflateSize = 0L,
    )

  @Test fun serverTextMessage() {

      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = false,
      noContextTakeover = false,
    )
  private val serverReaderWithCompression =
    WebSocketReader(
      isClient = false,
      source = data,
      frameCallback = callback.asFrameCallback(),
      perMessageDeflate = true,
      noContextTakeover = false,
    )
  private val clientReader =
    WebSocketReader(
      isClient = true,

        WebSocketWriter(
          isClient = streams.client,
          sink = streams.sink,
          random = random,
          perMessageDeflate = extensions.perMessageDeflate,
          noContextTakeover = extensions.noContextTakeover(streams.client),
          minimumDeflateSize = minimumDeflateSize,
        )
      this.writerTask = WriterTask()
      if (pingIntervalMillis != 0L) {

   * Typically this indicates that the client will need to close the web socket with code 1010.
   */
  @JvmField val unknownValues: Boolean = false,
) {
  fun noContextTakeover(clientOriginated: Boolean): Boolean {
    return if (clientOriginated) {
      clientNoContextTakeover // Client is deflating.
    } else {
      serverNoContextTakeover // Server is deflating.
    }
  }

 */
class WebSocketReader(
  private val isClient: Boolean,
  val source: BufferedSource,
  private val frameCallback: FrameCallback,
  private val perMessageDeflate: Boolean,
  private val noContextTakeover: Boolean,
) : Closeable {
  private var closed = false

  // Stateful data about the current frame.
  private var opcode = 0
  private var frameLength = 0L
  private var isFinalFrame = false