import java.util.concurrent.ConcurrentLinkedDeque
import java.util.concurrent.TimeUnit
import okhttp3.CallEvent.CallStart
import okhttp3.CallEvent.Canceled
import org.junit.jupiter.api.Assertions.fail

open class EventRecorder(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) {

    eventRecorder.takeEvent(CallStart::class.java, 0L)
    eventRecorder.takeEvent(ConnectionAcquired::class.java, applicationInterceptorDelay)
    eventRecorder.takeEvent(RequestHeadersStart::class.java, networkInterceptorDelay)
    eventRecorder.takeEvent(RequestHeadersEnd::class.java, 0L)
    eventRecorder.takeEvent(RequestBodyStart::class.java, 0L)

    object : WebSocketListener() {
    }
  val dispatcher = Dispatcher(executor)
  val eventRecorder = EventRecorder()
  var client =
    clientTestRule
      .newClientBuilder()
      .dns { throw UnknownHostException() }
      .dispatcher(dispatcher)
      .eventListenerFactory(clientTestRule.wrap(eventRecorder))
      .build()

  @BeforeEach
  fun setUp() {
    dispatcher.maxRequests = 20

    // In the process we made one successful connection attempt.
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectStart::class }).hasSize(2)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectFailed::class }).hasSize(1)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectEnd::class }).hasSize(1)
  }

  @Test
  fun reachesIpv6WhenIpv4IsDown() {

  val call: Call,
  val eventRecorder: EventRecorder,
) {
  private val eventListenerAdapter =
    EventListenerAdapter()
      .apply {
        listeners += ::onEvent
      }

  val eventListener: EventListener
    get() = eventListenerAdapter

  var eventCount = 0

  private fun onEvent(callEvent: CallEvent) {
    if (eventCount++ == 0) {
      eventRecorder.logEvent(callEvent)

  @StartStop
  private val server = MockWebServer()

  private var eventRecorder = EventRecorder()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventRecorder))
      .build()

  fun executeAndCheckUpgrade(request: Request) {
    val socketHandler =

  @RegisterExtension
  @JvmField
  var clientTestRule = OkHttpClientTestRule()

  private val eventRecorder = EventRecorder()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(eventRecorder))
      .build()

  @StartStop
  private val server = MockWebServer()

  @BeforeEach

  private val server = MockWebServer()

  private lateinit var dns: Dns
  private val cacheFs = FakeFileSystem()
  private val eventRecorder = EventRecorder()
  private val bootstrapClient =
    OkHttpClient
      .Builder()
      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
      .eventListener(eventRecorder.eventListener)
      .build()

  @BeforeEach
  fun setUp() {
    server.protocols = bootstrapClient.protocols

  val handshakeCertificates = platform.localhostHandshakeCertificates()

  private lateinit var server: MockWebServer
  private lateinit var client: OkHttpClient

  val eventRecorder = EventRecorder()

  @BeforeEach
  fun setUp() {
    if (connectionType == H2) {
      platform.assumeHttp2Support()
    }

    serverListener.assertClosed(1000, "goodbye")
  }

  @Test
  fun webSocketsDontTriggerEventListener() {
    val eventRecorder = EventRecorder()
    client =
      client
        .newBuilder()
        .eventListenerFactory(clientTestRule.wrap(eventRecorder))
        .build()
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)