open class HttpEventListener public constructor(
  callId: Long,
  url: HttpUrl,
  private val callStartNanos: Long
) : EventListener() {

  private var client = ""

  private val df = SimpleDateFormat("yyyy-MM-dd HH:mm:ss::SSS", Locale.US)

  private val sbLog: StringBuilder = StringBuilder(url.toString())
      .append(" callId is:$callId").append(":\n")

  private val netLog: NetLogRealmObj = NetLogRealmObj().apply {
    startTime = df.format(Date())
    api = url.toString()
    this.callId = callId.toString()
  }

  private fun recordEventLog(httpEvent: String) {
    val elapseNanos = System.nanoTime() - callStartNanos
    val usedTimeNano = elapseNanos / 1000000000.0
    val time = String.format(Locale.US, "%.3f", usedTimeNano)
    val timeAndEvent = "$time-$httpEvent"
    sbLog
        .append(timeAndEvent)
        .append(";\n")
    if (httpCallIsEndOrFailed(httpEvent)) {
      Log.i("HttpEventListener", sbLog.toString())
      totalTimeUsed += usedTimeNano
      Log.i("HttpEventListener", "TotalTimeUsed : $totalTimeUsed")
    }
  }

  private fun httpCallIsEndOrFailed(httpEvent: String) =
      httpEvent == "callEnd" || httpEvent.contains("callFailed")

  override fun callStart(call: Call) {
    super.callStart(call)
    recordEventLog("callStart:$client:::${call.request()}")
    netLog.method = call.request().method()
  }

  override fun dnsStart(call: Call, domainName: String) {
    super.dnsStart(call, domainName)
    recordEventLog("dnsStart:$domainName")
  }

  override fun dnsEnd(call: Call, domainName: String, inetAddressList: List<InetAddress>) {
    super.dnsEnd(call, domainName, inetAddressList)
    if (inetAddressList.isNotEmpty()) {
      recordEventLog("dnsEnd:$inetAddressList")
      inetAddressList.forEach {
        netLog.ip += it.toString()
      }
    } else {
      recordEventLog("dnsEnd:No IP get!!!")
    }
  }

  override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
    super.connectStart(call, inetSocketAddress, proxy)
    recordEventLog(
        "connectStart: InetSocketAddress is: $inetSocketAddress Proxy is $proxy"
    )
  }

  override fun secureConnectStart(call: Call) {
    super.secureConnectStart(call)
    recordEventLog("secureConnectStart: ${call.request()}")
  }

  override fun secureConnectEnd(call: Call, handshake: Handshake?) {
    super.secureConnectEnd(call, handshake)
    recordEventLog(
        "secureConnectEnd: tlsVersion is :${handshake?.tlsVersion()
            ?: "unknown"}"
    )
  }

  override fun connectEnd(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?
  ) {
    super.connectEnd(call, inetSocketAddress, proxy, protocol)
    recordEventLog("connectEnd: Ip is:$inetSocketAddress")
  }

  override fun connectFailed(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
    ioe: IOException
  ) {
    super.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
    recordEventLog("connectFailed: $inetSocketAddress")
  }

  override fun connectionAcquired(call: Call, connection: Connection) {
    super.connectionAcquired(call, connection)
    recordEventLog("connectionAcquired: $connection")
  }

  override fun connectionReleased(call: Call, connection: Connection) {
    super.connectionReleased(call, connection)
    recordEventLog("connectionReleased:$connection")
  }

  override fun requestHeadersStart(call: Call) {
    super.requestHeadersStart(call)
    recordEventLog("requestHeadersStart")
  }

  override fun requestHeadersEnd(call: Call, request: Request) {
    super.requestHeadersEnd(call, request)
    recordEventLog("requestHeadersEnd")
  }

  override fun requestBodyStart(call: Call) {
    super.requestBodyStart(call)
    recordEventLog("requestBodyStart")
  }

  override fun requestBodyEnd(call: Call, byteCount: Long) {
    super.requestBodyEnd(call, byteCount)
    recordEventLog("requestBodyEnd: and the byteCount is $byteCount")
  }

  override fun responseHeadersStart(call: Call) {
    super.responseHeadersStart(call)
    recordEventLog("responseHeadersStart:${call.request()}")
  }

  override fun responseHeadersEnd(call: Call, response: Response) {
    super.responseHeadersEnd(call, response)
    recordEventLog("responseHeadersEnd:${call.request()}")
  }

  override fun requestFailed(call: Call, ioe: IOException) {
    super.requestFailed(call, ioe)
    recordEventLog("requestFailed:$ioe}")
  }

  override fun responseBodyStart(call: Call) {
    super.responseBodyStart(call)
    recordEventLog("responseBodyStart")
  }

  override fun responseBodyEnd(call: Call, byteCount: Long) {
    super.responseBodyEnd(call, byteCount)
    recordEventLog(
        "responseBodyEnd: and the responseBody byte count is ${byteCount / 1000.0}" +
            " KB"
    )
  }

  override fun responseFailed(call: Call, ioe: IOException) {
    super.responseFailed(call, ioe)
    recordEventLog("responseFailed:$ioe")
  }

  override fun callEnd(call: Call) {
    super.callEnd(call)
    recordEventLog("callEnd")
  }

  override fun callFailed(call: Call, ioe: IOException) {
    super.callFailed(call, ioe)
    recordEventLog("callFailed: $ioe")
  }

  companion object {
    private val nextCallId = AtomicLong(1L)

    private var totalTimeUsed = 0.toDouble()

    @JvmField
    val FACTORY: Factory = Factory { call ->
        val callId = nextCallId.getAndIncrement()
        HttpEventListener(callId, call.request().url(), System.nanoTime())
    }

    @JvmField
    val NoneFactory: Factory = Factory { NONE }
  }
}

  /**
   * Returns true if this connection can carry a stream allocation to `address`. If non-null
   * `route` is the resolved route for a connection.
   */
  internal fun isEligible(address: Address, routes: List<Route>?): Boolean {
    assertThreadHoldsLock()

    // If this connection is not accepting new exchanges, we're done.
    if (calls.size >= allocationLimit || noNewExchanges) return false

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host == this.route().address.url.host) {
      return true // This connection is a perfect match.
    }

    // At this point we don't have a hostname match. But we still be able to carry the request if
    // our connection coalescing requirements are met. See also:
    // https://hpbn.co/optimizing-application-delivery/#eliminate-domain-sharding
    // https://daniel.haxx.se/blog/2016/08/18/http2-connection-coalescing/

    // 1. This connection must be HTTP/2.
    if (http2Connection == null) return false

    // 2. The routes must share an IP address.
    if (routes == null || !routeMatchesAny(routes)) return false

    // 3. This connection's server certificate's must cover the new host.
    if (address.hostnameVerifier !== OkHostnameVerifier) return false
    if (!supportsUrl(address.url)) return false

    // 4. Certificate pinning must match the host.
    try {
      address.certificatePinner!!.check(address.url.host, handshake()!!.peerCertificates)
    } catch (_: SSLPeerUnverifiedException) {
      return false
    }

    return true // The caller's address can be carried by this connection.
  }

  internal fun equalsNonHost(that: Address): Boolean {
    return this.dns == that.dns &&
        this.proxyAuthenticator == that.proxyAuthenticator &&
        this.protocols == that.protocols &&
        this.connectionSpecs == that.connectionSpecs &&
        this.proxySelector == that.proxySelector &&
        this.proxy == that.proxy &&
        this.sslSocketFactory == that.sslSocketFactory &&
        this.hostnameVerifier == that.hostnameVerifier &&
        this.certificatePinner == that.certificatePinner &&
        this.url.port == that.url.port
  }