import com.vanniktech.maven.publish.JavadocJar
import com.vanniktech.maven.publish.KotlinJvm

plugins {
  kotlin("jvm")
  id("org.jetbrains.dokka")
  id("com.vanniktech.maven.publish.base")
  id("binary-compatibility-validator")
}

tasks.jar {
  manifest {
    attributes("Automatic-Module-Name" to "okhttp3.mockwebserver")
  }
}

dependencies {
  api(projects.okhttp)
  api(projects.mockwebserver3)
  api(libs.junit)

    events.add(Open(eventSource, response))
    drainCancelQueue(eventSource)
  }

  override fun onEvent(
    eventSource: EventSource,
    id: String?,
    type: String?,
    data: String,
  ) {
    get().log("[ES] onEvent", Platform.INFO, null)
    events.add(Event(id, type, data))
    drainCancelQueue(eventSource)
  }

  override fun onClosed(eventSource: EventSource) {

    )

    /**
     * The peer tells us to stop creating streams. It is safe to replay streams with
     * `ID > lastGoodStreamId` on a new connection.  In- flight streams with
     * `ID <= lastGoodStreamId` can only be replayed on a new connection if they are idempotent.
     *
     * @param lastGoodStreamId the last stream ID the peer processed before sending this message. If
     *     [lastGoodStreamId] is zero, the peer processed no frames.

  val abortsOnUnrecognizedName: Boolean,
  val alpnProtocols: List<String>,
  val ellipticCurves: List<Int>,
  val handshakeFormat: String,
  val hexHandshakeBytes: String,
  val highestProtocol: Int,
  val id: Int,
  val isGrade0: Boolean,
  val lowestProtocol: Int,
  val maxDhBits: Int,
  val maxRsaBits: Int,
  val minDhBits: Int,
  val minEcdsaBits: Int,
  val minRsaBits: Int,
  val name: String,

   * a part of the response to `streamId`. The `promisedStreamId` has a priority of one greater than
   * `streamId`.
   *
   * @param streamId client-initiated stream ID.  Must be an odd number.
   * @param promisedStreamId server-initiated stream ID.  Must be an even number.
   * @param requestHeaders minimally includes `:method`, `:scheme`, `:authority`, and `:path`.
   */
  @Throws(IOException::class)
  fun pushPromise(

    val config = "--name=OpenSC\nlibrary=/Library/OpenSC/lib/opensc-pkcs11.so\nslot=$slot\n"

    // May fail with ProviderException with root cause like
    // sun.security.pkcs11.wrapper.PKCS11Exception: CKR_SLOT_ID_INVALID
    val pkcs11 = Security.getProvider("SunPKCS11").configure(config)
    Security.addProvider(pkcs11)

    val callbackHandler = ConsoleCallbackHandler

    val builderList: List<KeyStore.Builder> =

    }

    private fun extensions(): MutableList<Extension> {
      val result = mutableListOf<Extension>()

      if (maxIntermediateCas != -1) {
        result +=
          Extension(
            id = BASIC_CONSTRAINTS,
            critical = true,
            value =
              BasicConstraints(
                ca = true,
                maxIntermediateCas = maxIntermediateCas.toLong(),
              ),

      Adapters.BOOLEAN.optional(defaultValue = false),
      extensionValue,
      decompose = {
        listOf(
          it.id,
          it.critical,
          it.value,
        )
      },
      construct = {
        Extension(
          id = it[0] as String,
          critical = it[1] as Boolean,
          value = it[2],
        )
      },
    )

  /**
   * ```

This is necessary for bookkeeping when creating new streams. Correct framing requires that stream IDs are sequential on the socket, so we need to bundle assigning the ID with sending the `SYN_STREAM` frame.

## Connection Pool

  )
}

fun historicOkHttp(version: String): Client {
  val enabled =
    FileSystem.RESOURCES.read("okhttp_$version.txt".toPath()) {
      this.readUtf8().lines().filter { it.isNotBlank() }.map {
        SuiteId(id = null, name = it.trim())
      }
    }
  return Client(
    userAgent = "OkHttp",
    version = version,
    enabled = enabled,
  )
}

fun currentVm(ianaSuites: IanaSuites): Client {