import java.util.Collections.singletonMap
import java.util.Locale.US
import kotlin.text.Charsets.ISO_8859_1
import okhttp3.internal.unmodifiable

/**
 * 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>,
) {
  /**

/**
 * Represents an NTLM authentication challenge in SMB1 protocol.
 */
public final class NtlmChallenge implements Serializable {

    /**
     * The NTLM challenge bytes received from the server.
     */
    public byte[] challenge;
    /**
     * The domain controller address that issued the challenge.
     */
    public UniAddress dc;

    NtlmChallenge(final byte[] challenge, final UniAddress dc) {

        parse(material);
    }

    /**
     * Returns the challenge for this message.
     *
     * @return A <code>byte[]</code> containing the challenge.
     */
    public byte[] getChallenge() {
        return challenge;
    }

    /**
     * Sets the challenge for this message.
     *
     * @param challenge The challenge from the domain controller/server.
     */

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

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

    /**
     * Creates a new NTLM challenge with the specified parameters.
     * @param challenge the NTLM challenge bytes
     * @param dc the domain controller address
     */
    public NtlmChallenge(final byte[] challenge, final UniAddress dc) {

    }

    /**
     * Returns the challenge for this message.
     *
     * @return A <code>byte[]</code> containing the challenge.
     */
    public byte[] getChallenge() {
        return this.challenge;
    }

    /**
     * Sets the challenge for this message.
     *
     * @param challenge
     *            The challenge from the domain controller/server.
     */

    assertThat(challenges[0].realm).isNull()
    assertThat(challenges[0].authParams).isEqualTo(emptyMap<Any, Any>())
  }

  @Test fun basicChallenge() {
    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\"")
        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))

        // Arrange
        String password = "password";
        byte[] challenge = hex("1122334455667788");

        // Act
        byte[] r1 = NtlmUtil.getNTLMResponse(password, challenge);
        byte[] r2 = NtlmUtil.getNTLMResponse(NtlmUtil.getNTHash(password), challenge);

        // Assert
        assertArrayEquals(r2, r1);
        assertEquals(24, r1.length);
    }

     * @param password the password to hash
     * @param challenge the server challenge bytes
     * @return the calculated response
     * @throws GeneralSecurityException if a cryptographic error occurs
     */
    public static byte[] getNTLMResponse(final String password, final byte[] challenge) throws GeneralSecurityException {
        return getNTLMResponse(getNTHash(password), challenge);
    }

    /**

            return getPreNTLMResponse(password, challenge);
        }
    }

    /**
     * Computes the 24 byte Unicode password hash given the 8 byte server challenge.
     *
     * @param challenge the server challenge bytes
     * @return the Unicode password hash
     */
    public byte[] getUnicodeHash(final byte[] challenge) {
        if (hashesExternal) {
            return unicodeHash;
        }

    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
      }