import okhttp3.internal.commonEquals
import okhttp3.internal.commonHashCode
import okhttp3.internal.commonToString

/**
 * An [RFC 7235][rfc_7235] challenge.
 *
 * [rfc_7235]: https://tools.ietf.org/html/rfc7235
 */
class Challenge(
  /** Returns the authentication scheme, like `Basic`. */
  @get:JvmName("scheme") val scheme: String,
  authParams: Map<String?, String>,
) {
  /**

    route: Route?,
    response: Response,
  ): Request? {
    val challenges = response.challenges()
    val request = response.request
    val url = request.url
    val proxyAuthorization = response.code == 407
    val proxy = route?.proxy ?: Proxy.NO_PROXY

    for (challenge in challenges) {
      if (!"Basic".equals(challenge.scheme, ignoreCase = true)) {
        continue
      }

  }

  @Test fun testDigestChallengeWithTokenFormOfAuthParam() {
    val headers =
      Headers.Builder()
        .add("WWW-Authenticate", "Digest realm=myrealm").build()
    val challenges = headers.parseChallenges("WWW-Authenticate")
    assertThat(challenges.size).isEqualTo(1)
    assertThat(challenges[0].scheme).isEqualTo("Digest")

    /**
     * Challenge
     */
    public byte[] challenge;

    /**
     * Server address
     */
    public UniAddress dc;


    /**
     * @param challenge
     * @param dc
     */
    public NtlmChallenge ( byte[] challenge, UniAddress dc ) {
        this.challenge = challenge;
        this.dc = dc;
    }


    @Override

 */
    public byte[] getAnsiHash( byte[] challenge ) {
        if( hashesExternal ) {
            return ansiHash;
        }
        switch (LM_COMPATIBILITY) {
        case 0:
        case 1:
            return getPreNTLMResponse( password, challenge );
        case 2:
            return getNTLMResponse( password, challenge );
        case 3:
        case 4:

        String target = "TARGET";
        byte[] challenge = new byte[] {
            0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8
        };

        Type2Message t2 = new Type2Message(this.context, flags, challenge, target);
        Type2Message parsed = new Type2Message(t2.toByteArray());
        assertArrayEquals(challenge, parsed.getChallenge());
        assertEquals(target, parsed.getTarget());
    }

 */
fun Headers.parseChallenges(headerName: String): List<Challenge> {
  val result = mutableListOf<Challenge>()
  for (h in 0 until size) {
    if (headerName.equals(name(h), ignoreCase = true)) {
      val header = Buffer().writeUtf8(value(h))
      try {
        header.readChallengeHeader(result)
      } catch (e: EOFException) {
        Platform.get().log("Unable to parse challenge", Platform.WARN, e)
      }
    }
  }

     * @param resp The response.
     * @param challenge The domain controller challenge.
     * @throws IOException If an IO error occurs.
     * @throws ServletException If an error occurs.
     */
    public NtlmPasswordAuthentication doAuthentication(
            HttpServletRequest req, HttpServletResponse resp, byte[] challenge)
                    throws IOException, ServletException {

public final class NtlmChallenge implements Serializable {

    public byte[] challenge;
    public UniAddress dc;

    NtlmChallenge( byte[] challenge, UniAddress dc ) {
        this.challenge = challenge;
        this.dc = dc;
    }

    public String toString() {
        return "NtlmChallenge[challenge=0x" +
                Hexdump.toHexString( challenge, 0, challenge.length * 2 ) +
                ",dc=" + dc.toString() + "]";
    }

     *            The user's password.
     * @param challenge
     *            The server challenge.
     * @param clientChallenge
     *            The client challenge (nonce).
     * @return the calculated response
     * @throws GeneralSecurityException
     */
    public static byte[] getLMv2Response ( String domain, String user, String password, byte[] challenge, byte[] clientChallenge )