*
 */
package mockwebserver3.internal

import okio.Buffer
import okio.Sink

/**
 * A sink that executes [trigger] after [triggerByteCount] bytes are written, and then skips all
 * subsequent bytes.
 */
internal class TriggerSink(
  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(

    TestByteSink sink = new TestByteSink();

    assertFalse(sink.wasStreamOpened() || sink.wasStreamClosed());

    assertEquals(bytes.length, source.copyTo(sink));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

    assertArrayEquals(bytes, sink.getBytes());
  }

  return object : RequestBody() {
    override fun contentType() = contentType

    override fun contentLength() = byteCount.toLong()

    override fun writeTo(sink: BufferedSink) {
      sink.write(this@commonToRequestBody, offset, byteCount)
    }
  }
}

@Suppress("unused")
fun RequestBody.commonContentLength(): Long = -1L

@Suppress("unused")

/** A duplex request body that keeps the provided sinks so they can be written to later.  */
class AsyncRequestBody : RequestBody() {
  private val requestBodySinks: BlockingQueue<BufferedSink> = LinkedBlockingQueue()

  override fun contentType(): MediaType? = null

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

      @Override public MediaType contentType() {
        return MEDIA_TYPE_MARKDOWN;
      }

      @Override public void writeTo(BufferedSink sink) throws IOException {
        sink.writeUtf8("Numbers\n");
        sink.writeUtf8("-------\n");
        for (int i = 2; i <= 997; i++) {
          sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
        }
      }

      private String factor(int n) {

      val source = this.source!!
      val sink = this.sink!!
      val tunnelCodec =
        Http1ExchangeCodec(
          // No client for CONNECT tunnels:
          client = null,
          carrier = this,
          source = source,
          sink = sink,
        )
      source.timeout().timeout(readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)

  public void testAsOutputStream() throws Exception {
    PrimitiveSink sink = mock(PrimitiveSink.class);
    OutputStream out = Funnels.asOutputStream(sink);
    byte[] bytes = {1, 2, 3, 4};
    out.write(255);
    out.write(bytes);
    out.write(bytes, 1, 2);
    verify(sink).putByte((byte) 255);
    verify(sink).putBytes(bytes);
    verify(sink).putBytes(bytes, 1, 2);
  }

  public void testSerialization() {

    TestCharSink sink = new TestCharSink();

    assertFalse(sink.wasStreamOpened() || sink.wasStreamClosed());

    assertEquals(STRING.length(), source.copyTo(sink));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

    assertEquals(STRING, sink.getString());
  }

    val pipe = Pipe(1024)
    val sink = pipe.sink.buffer()
    val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)
    sink.writeUtf8("abcdefghij")
    Thread.sleep(500)
    sink.writeUtf8("klmnopqrst")
    sink.close()
    assertThat<ByteString>(future1.get())

        .method("POST", AsyncRequestBody())
        .build()
    val call = client.newCall(request)
    call.execute().use { response ->
      val sink = (request.body as AsyncRequestBody?)!!.takeSink()
      sink.writeUtf8("hey\n")
      sink.writeUtf8("whats going on\n")
      sink.close()
    }
    body.awaitSuccess()
  }

  @Test
  fun requestBodyEndsAfterResponseBody() {
    enableProtocol(Protocol.HTTP_2)