import okhttp3.internal.unmodifiable

/**
 * Policy on when async requests are executed.
 *
 * Each dispatcher uses an [ExecutorService] to run calls internally. If you supply your own
 * executor, it should be able to run [the configured maximum][maxRequests] number of calls
 * concurrently.
 */
class Dispatcher() {
  /**
   * The maximum number of requests to execute concurrently. Above this requests queue in memory,

    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
    dispatcher.maxRequestsPerHost = 10

  }

  override fun dispatcherQueueStart(
    call: Call,
    dispatcher: Dispatcher,
  ) {
    logWithTime("dispatcherQueueStart: $call queuedCallsCount=${dispatcher.queuedCallsCount()}")
  }

  override fun dispatcherQueueEnd(
    call: Call,
    dispatcher: Dispatcher,
  ) {
    logWithTime("dispatcherQueueEnd: $call queuedCallsCount=${dispatcher.queuedCallsCount()}")
  }

  override fun proxySelectStart(

  }

  @Test
  fun dispatcher() {
    var dispatcher = Dispatcher()
    dispatcher = Dispatcher(Executors.newCachedThreadPool())
    val maxRequests: Int = dispatcher.maxRequests
    dispatcher.maxRequests = 0
    val maxRequestsPerHost: Int = dispatcher.maxRequestsPerHost
    dispatcher.maxRequestsPerHost = 0
    val executorService: ExecutorService = dispatcher.executorService

    }
  }

  override fun dispatcherQueueStart(
    call: Call,
    dispatcher: Dispatcher,
  ) = onEvent(DispatcherQueueStart(System.nanoTime(), call, dispatcher))

  override fun dispatcherQueueEnd(
    call: Call,
    dispatcher: Dispatcher,
  ) = onEvent(DispatcherQueueEnd(System.nanoTime(), call, dispatcher))

  override fun proxySelectStart(
    call: Call,
    url: HttpUrl,

      this.taskRunner = okHttpClient.taskRunner
    }

    /**
     * Sets the dispatcher used to set policy and execute asynchronous requests. Must not be null.
     */
    fun dispatcher(dispatcher: Dispatcher) =
      apply {
        this.dispatcher = dispatcher
      }

    /**
     * Sets the connection pool used to recycle HTTP and HTTPS connections.
     *

      call: Call,
      dispatcher: Dispatcher,
    ) {
      for (delegate in eventListeners) {
        delegate.dispatcherQueueStart(call, dispatcher)
      }
    }

    override fun dispatcherQueueEnd(
      call: Call,
      dispatcher: Dispatcher,
    ) {
      for (delegate in eventListeners) {
        delegate.dispatcherQueueEnd(call, dispatcher)
      }
    }

```

#### Dispatcher

By default MockWebServer uses a queue to specify a series of responses. Use a
Dispatcher (`import okhttp3.mockwebserver.Dispatcher`) to handle requests using another policy. One natural policy is to
dispatch on the request path.
You can, for example, filter the request instead of using `server.enqueue()`.

### Java
```java
final Dispatcher dispatcher = new Dispatcher() {

  }

  override fun dispatcherQueueStart(
    call: Call,
    dispatcher: Dispatcher,
  ) {
    logWithTime("dispatcherQueueStart: queuedCallsCount=${dispatcher.queuedCallsCount()}")
  }

  override fun dispatcherQueueEnd(
    call: Call,
    dispatcher: Dispatcher,
  ) {
    logWithTime("dispatcherQueueEnd: queuedCallsCount=${dispatcher.queuedCallsCount()}")
  }

  override fun proxySelectStart(
    call: Call,

    callStart()
    try {
      client.dispatcher.executed(this)
      return getResponseWithInterceptorChain()
    } finally {
      client.dispatcher.finished(this)
    }
  }

  override fun enqueue(responseCallback: Callback) {
    check(executed.compareAndSet(false, true)) { "Already Executed" }

    callStart()
    client.dispatcher.enqueue(AsyncCall(responseCallback))
  }