import javax.security.cert.X509Certificate

/** An [SSLSession] that delegates all calls.  */
abstract class DelegatingSSLSession(protected val delegate: SSLSession?) : SSLSession {
  override fun getId(): ByteArray {
    return delegate!!.id
  }

  override fun getSessionContext(): SSLSessionContext {
    return delegate!!.sessionContext
  }

  override fun getCreationTime(): Long {
    return delegate!!.creationTime

          }
        }
      }
    }

    /** Returns a new request body that transmits this. */
    @JvmOverloads
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toRequestBody(
      contentType: MediaType? = null,
      offset: Int = 0,
      byteCount: Int = size,
    ): RequestBody = commonToRequestBody(contentType, offset, byteCount)

    throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
  }
  return bytes
}

internal fun ResponseBody.commonClose() = source().closeQuietly()

internal fun ByteArray.commonToResponseBody(contentType: MediaType?): ResponseBody {
  return Buffer()
    .write(this)
    .asResponseBody(contentType, size.toLong())
}

  /** Lazily initialized on first use. */
  private var messageInflater: MessageInflater? = null

  // Masks are only a concern for server writers.
  private val maskKey: ByteArray? = if (isClient) null else ByteArray(4)
  private val maskCursor: Buffer.UnsafeCursor? = if (isClient) null else Buffer.UnsafeCursor()

  interface FrameCallback {
    @Throws(IOException::class)
    fun onReadMessage(text: String)

 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import okhttp3.MediaType
import okhttp3.RequestBody
import okio.BufferedSink
import okio.ByteString

fun ByteArray.commonToRequestBody(
  contentType: MediaType?,
  offset: Int,
  byteCount: Int,
): RequestBody {
  checkOffsetAndCount(size.toLong(), offset.toLong(), byteCount.toLong())
  return object : RequestBody() {

    val s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    for (i in s.indices) {
      assertRoundTrip(s.substring(0, i).encodeUtf8())
    }
    val random = Random(123456789L)
    val buf = ByteArray(4096)
    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)

  override fun getCipherSuite(): String {
    throw UnsupportedOperationException()
  }

  override fun getCreationTime(): Long {
    throw UnsupportedOperationException()
  }

  override fun getId(): ByteArray {
    throw UnsupportedOperationException()
  }

  override fun getLastAccessedTime(): Long {
    throw UnsupportedOperationException()
  }

  override fun getLocalCertificates(): Array<Certificate> {

    return source.readByte().toInt() != 0
  }

  fun readBigInteger(): BigInteger {
    if (bytesLeft == 0L) throw ProtocolException("unexpected length: $bytesLeft at $this")
    val byteArray = source.readByteArray(bytesLeft)
    return BigInteger(byteArray)
  }

  fun readLong(): Long {
    if (bytesLeft !in 1..8) throw ProtocolException("unexpected length: $bytesLeft at $this")

      val ttl = buf.readInt().toLong() and 0xffffffffL // ttl
      val length = buf.readShort().toInt() and 0xffff

      if (type == TYPE_A || type == TYPE_AAAA) {
        val bytes = ByteArray(length)
        buf.read(bytes)
        result.add(InetAddress.getByAddress(bytes))
      } else {
        buf.skip(length.toLong())
      }
    }

    return result
  }

      return buffer.asResponseBody(finalContentType, buffer.size)
    }

    /** Returns a new response body that transmits this byte array. */
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toResponseBody(contentType: MediaType? = null): ResponseBody = commonToResponseBody(contentType)

    /** Returns a new response body that transmits this byte string. */
    @JvmStatic
    @JvmName("create")