package okhttp3.recipes.kt

import java.io.IOException
import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class PerCallSettings {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build()

    // Copy to customize OkHttp for this request.

import okio.buffer
import okio.fakefilesystem.FakeFileSystem

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =
      Request
        .Builder()
        .url("https://httpbin.org/anything")

    }
  }

  override fun equals(other: Any?): Boolean =
    other is AndroidCertificateChainCleaner &&
      other.trustManager === this.trustManager

  override fun hashCode(): Int = System.identityHashCode(trustManager)

  companion object {
    @SuppressSignatureCheck
    fun buildIfSupported(trustManager: X509TrustManager): AndroidCertificateChainCleaner? {

/**
 * Most websites serve cookies in the blessed format. Eagerly create the parser to ensure such
 * cookies are on the fast path.
 */
private val STANDARD_DATE_FORMAT =
  object : ThreadLocal<DateFormat>() {
    override fun initialValue(): DateFormat {
      // Date format specified by RFC 7231 section 7.1.1.1.
      return SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US).apply {
        isLenient = false
        timeZone = UTC

    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent() {

    }
    return try {
      toVerify.verify(signingCert.publicKey)
      true
    } catch (verifyFailed: GeneralSecurityException) {
      false
    }
  }

  override fun hashCode(): Int = trustRootIndex.hashCode()

  override fun equals(other: Any?): Boolean =
    if (other === this) {
      true
    } else {
      other is BasicCertificateChainCleaner && other.trustRootIndex == trustRootIndex
    }

   * timeout. Because networks can fail during an exchange, it is possible that the remote server
   * accepted the request before the failure.
   */
  fun onFailure(
    call: Call,
    e: IOException,
  )

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may

  delegate: SSLSocketFactory,
) : DelegatingSSLSocketFactory(delegate) {
  override fun configureSocket(sslSocket: SSLSocket): SSLSocket = TlsFallbackScsvDisabledSSLSocket(sslSocket)

  private class TlsFallbackScsvDisabledSSLSocket(
    socket: SSLSocket,
  ) : DelegatingSSLSocket(socket) {
    override fun setEnabledCipherSuites(suites: Array<String>) {
      val enabledCipherSuites = mutableListOf<String>()

  @Container
  val mockServer: MockServerContainer = MockServerContainer(MOCKSERVER_IMAGE)

  val client =
    OkHttpClient
      .Builder()
      .trustMockServer()
      .build()

  @Test
  fun testRequest() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request()
            .withPath("/person")

  private val publicSuffixDatabase = PublicSuffixDatabase.get()

  val pathForTests = okHttpRoot / "okhttp/src/jvmMain/resources" / PUBLIC_SUFFIX_RESOURCE

  @Before
  fun setUp() {
    beforePublicSuffixTest()
  }

  @Test
  fun allPublicSuffixes() {
    val buffer = Buffer()
    FileSystem.SYSTEM.read(pathForTests) {
      val length = readInt()
      buffer.write(this, length.toLong())
    }