/*
 * The MIT License
 * Copyright (c) 2012 Microsoft Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package microsoft.exchange.webservices.data.autodiscover;

import microsoft.exchange.webservices.data.autodiscover.configuration.ConfigurationSettingsBase;
import microsoft.exchange.webservices.data.autodiscover.configuration.outlook.OutlookConfigurationSettings;
import microsoft.exchange.webservices.data.autodiscover.enumeration.AutodiscoverEndpoints;
import microsoft.exchange.webservices.data.autodiscover.enumeration.AutodiscoverErrorCode;
import microsoft.exchange.webservices.data.autodiscover.exception.AutodiscoverLocalException;
import microsoft.exchange.webservices.data.autodiscover.exception.AutodiscoverRemoteException;
import microsoft.exchange.webservices.data.autodiscover.request.AutodiscoverRequest;
import microsoft.exchange.webservices.data.autodiscover.request.GetDomainSettingsRequest;
import microsoft.exchange.webservices.data.autodiscover.request.GetUserSettingsRequest;
import microsoft.exchange.webservices.data.autodiscover.response.GetDomainSettingsResponse;
import microsoft.exchange.webservices.data.autodiscover.response.GetDomainSettingsResponseCollection;
import microsoft.exchange.webservices.data.autodiscover.response.GetUserSettingsResponse;
import microsoft.exchange.webservices.data.autodiscover.response.GetUserSettingsResponseCollection;
import microsoft.exchange.webservices.data.core.EwsUtilities;
import microsoft.exchange.webservices.data.core.EwsXmlReader;
import microsoft.exchange.webservices.data.core.ExchangeServiceBase;
import microsoft.exchange.webservices.data.core.request.HttpClientWebRequest;
import microsoft.exchange.webservices.data.core.request.HttpWebRequest;
import microsoft.exchange.webservices.data.credential.WSSecurityBasedCredentials;
import microsoft.exchange.webservices.data.autodiscover.enumeration.DomainSettingName;
import microsoft.exchange.webservices.data.core.enumeration.misc.ExchangeVersion;
import microsoft.exchange.webservices.data.core.enumeration.misc.TraceFlags;
import microsoft.exchange.webservices.data.autodiscover.enumeration.UserSettingName;
import microsoft.exchange.webservices.data.core.exception.misc.ArgumentException;
import microsoft.exchange.webservices.data.core.exception.http.EWSHttpException;
import microsoft.exchange.webservices.data.core.exception.misc.FormatException;
import microsoft.exchange.webservices.data.autodiscover.exception.MaximumRedirectionHopsExceededException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceLocalException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceValidationException;
import microsoft.exchange.webservices.data.core.exception.service.local.ServiceVersionException;
import microsoft.exchange.webservices.data.misc.OutParam;
import microsoft.exchange.webservices.data.security.XmlNodeType;

import javax.xml.stream.XMLStreamException;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.List;

/**
 * Represents a binding to the Exchange Autodiscover Service.
 */
public class AutodiscoverService extends ExchangeServiceBase
    implements IAutodiscoverRedirectionUrl, IFunctionDelegate {

  // region Private members
  /**
   * The domain.
   */
  private String domain;

  /**
   * The is external.
   */
  private Boolean isExternal = true;

  /**
   * The url.
   */
  private URI url;

  /**
   * The redirection url validation callback.
   */
  private IAutodiscoverRedirectionUrl
      redirectionUrlValidationCallback;

  /**
   * The dns client.
   */
  private AutodiscoverDnsClient dnsClient;

  /**
   * The dns server address.
   */
  private String dnsServerAddress;

  /**
   * The enable scp lookup.
   */
  private boolean enableScpLookup = true;

  // Autodiscover legacy path
  /**
   * The Constant AutodiscoverLegacyPath.
   */
  private static final String AutodiscoverLegacyPath =
      "/autodiscover/autodiscover.xml";

  // Autodiscover legacy HTTPS Url
  /**
   * The Constant AutodiscoverLegacyHttpsUrl.
   */
  private static final String AutodiscoverLegacyHttpsUrl = "https://%s" +
      AutodiscoverLegacyPath;
  // Autodiscover legacy HTTP Url
  /**
   * The Constant AutodiscoverLegacyHttpUrl.
   */
  private static final String AutodiscoverLegacyHttpUrl = "http://%s" +
      AutodiscoverLegacyPath;
  // Autodiscover SOAP HTTPS Url
  /**
   * The Constant AutodiscoverSoapHttpsUrl.
   */
  private static final String AutodiscoverSoapHttpsUrl =
      "https://%s/autodiscover/autodiscover.svc";
  // Autodiscover SOAP WS-Security HTTPS Url
  /**
   * The Constant AutodiscoverSoapWsSecurityHttpsUrl.
   */
  private static final String AutodiscoverSoapWsSecurityHttpsUrl =
      AutodiscoverSoapHttpsUrl +
          "/wssecurity";

  /**
   * Autodiscover SOAP WS-Security symmetrickey HTTPS Url
   */
  private static final String AutodiscoverSoapWsSecuritySymmetricKeyHttpsUrl =
      AutodiscoverSoapHttpsUrl + "/wssecurity/symmetrickey";

  /**
   * Autodiscover SOAP WS-Security x509cert HTTPS Url
   */
  private static final String AutodiscoverSoapWsSecurityX509CertHttpsUrl =
      AutodiscoverSoapHttpsUrl + "/wssecurity/x509cert";


  // Autodiscover request namespace
  /**
   * The Constant AutodiscoverRequestNamespace.
   */
  private static final String AutodiscoverRequestNamespace =
      "http://schemas.microsoft.com/exchange/autodiscover/" +
          "outlook/requestschema/2006";
  // Maximum number of Url (or address) redirections that will be followed by
  // an Autodiscover call
  /**
   * The Constant AutodiscoverMaxRedirections.
   */
  protected static final int AutodiscoverMaxRedirections = 10;
  // HTTP header indicating that SOAP Autodiscover service is enabled.
  /**
   * The Constant AutodiscoverSoapEnabledHeaderName.
   */
  private static final String AutodiscoverSoapEnabledHeaderName =
      "X-SOAP-Enabled";
  // HTTP header indicating that WS-Security Autodiscover service is enabled.
  /**
   * The Constant AutodiscoverWsSecurityEnabledHeaderName.
   */
  private static final String AutodiscoverWsSecurityEnabledHeaderName =
      "X-WSSecurity-Enabled";


  /**
   * HTTP header indicating that WS-Security/SymmetricKey Autodiscover service is enabled.
   */

  private static final String AutodiscoverWsSecuritySymmetricKeyEnabledHeaderName =
      "X-WSSecurity-SymmetricKey-Enabled";


  /**
   * HTTP header indicating that WS-Security/X509Cert Autodiscover service is enabled.
   */

  private static final String AutodiscoverWsSecurityX509CertEnabledHeaderName =
      "X-WSSecurity-X509Cert-Enabled";


  // Minimum request version for Autodiscover SOAP service.
  /**
   * The Constant MinimumRequestVersionForAutoDiscoverSoapService.
   */
  private static final ExchangeVersion
      MinimumRequestVersionForAutoDiscoverSoapService =
      ExchangeVersion.Exchange2010;

  /**
   * Default implementation of AutodiscoverRedirectionUrlValidationCallback.
   * Always returns true indicating that the URL can be used.
   *
   * @param redirectionUrl the redirection url
   * @return Returns true.
   * @throws AutodiscoverLocalException the autodiscover local exception
   */
  private boolean defaultAutodiscoverRedirectionUrlValidationCallback(
      String redirectionUrl) throws AutodiscoverLocalException {
    throw new AutodiscoverLocalException(String.format(
        "Autodiscover blocked a potentially insecure redirection to %s. To allow Autodiscover to follow the "
        + "redirection, use the AutodiscoverUrl(string, AutodiscoverRedirectionUrlValidationCallback) "
        + "overload.", redirectionUrl));
  }

  // Legacy Autodiscover

  /**
   * Calls the Autodiscover service to get configuration settings at the
   * specified URL.
   *
   * @param <TSettings>  the generic type
   * @param cls          the cls
   * @param emailAddress the email address
   * @param url          the url
   * @return The requested configuration settings. (TSettings The type of the
   * settings to retrieve)
   * @throws Exception the exception
   */
  private <TSettings extends ConfigurationSettingsBase>
  TSettings getLegacyUserSettingsAtUrl(
      Class<TSettings> cls, String emailAddress, URI url)
      throws Exception {
    this
        .traceMessage(TraceFlags.AutodiscoverConfiguration,
                      String.format("Trying to call Autodiscover for %s on %s.", emailAddress, url));

    TSettings settings = cls.newInstance();

    HttpWebRequest request = null;
    try {
      request = this.prepareHttpWebRequestForUrl(url);

      this.traceHttpRequestHeaders(
          TraceFlags.AutodiscoverRequestHttpHeaders,
          request);
      // OutputStreamWriter out = new
      // OutputStreamWriter(request.getOutputStream());
      OutputStream urlOutStream = request.getOutputStream();

      // If tracing is enabled, we generate the request in-memory so that we
      // can pass it along to the ITraceListener. Then we copy the stream to
      // the request stream.
      if (this.isTraceEnabledFor(TraceFlags.AutodiscoverRequest)) {
        ByteArrayOutputStream memoryStream = new ByteArrayOutputStream();

        PrintWriter writer = new PrintWriter(memoryStream);
        this.writeLegacyAutodiscoverRequest(emailAddress, settings, writer);
        writer.flush();

        this.traceXml(TraceFlags.AutodiscoverRequest, memoryStream);
        // out.write(memoryStream.toString());
        // out.close();
        memoryStream.writeTo(urlOutStream);
        urlOutStream.flush();
        urlOutStream.close();
        memoryStream.close();
      } else {
        PrintWriter writer = new PrintWriter(urlOutStream);
        this.writeLegacyAutodiscoverRequest(emailAddress, settings, writer);

      /*  Flush Start */
        writer.flush();
        urlOutStream.flush();
        urlOutStream.close();
      /* Flush End */
      }
      request.executeRequest();
      request.getResponseCode();
      URI redirectUrl;
      OutParam<URI> outParam = new OutParam<URI>();
      if (this.tryGetRedirectionResponse(request, outParam)) {
        redirectUrl = outParam.getParam();
        settings.makeRedirectionResponse(redirectUrl);
        return settings;
      }
      InputStream serviceResponseStream = request.getInputStream();
      // If tracing is enabled, we read the entire response into a
      // MemoryStream so that we
      // can pass it along to the ITraceListener. Then we parse the response
      // from the
      // MemoryStream.
      if (this.isTraceEnabledFor(TraceFlags.AutodiscoverResponse)) {
        ByteArrayOutputStream memoryStream = new ByteArrayOutputStream();

        while (true) {
          int data = serviceResponseStream.read();
          if (-1 == data) {
            break;
          } else {
            memoryStream.write(data);
          }
        }
        memoryStream.flush();

        this.traceResponse(request, memoryStream);
        ByteArrayInputStream memoryStreamIn = new ByteArrayInputStream(
            memoryStream.toByteArray());
        EwsXmlReader reader = new EwsXmlReader(memoryStreamIn);
        reader.read(new XmlNodeType(XmlNodeType.START_DOCUMENT));
        settings.loadFromXml(reader);

      } else {
        EwsXmlReader reader = new EwsXmlReader(serviceResponseStream);
        reader.read(new XmlNodeType(XmlNodeType.START_DOCUMENT));
        settings.loadFromXml(reader);
      }

      serviceResponseStream.close();
    } finally {
      if (request != null) {
        try {
          request.close();
        } catch (Exception e2) {
          // Ignore exception while closing the request.
        }
      }
    }

    return settings;
  }

  /**
   * Writes the autodiscover request.
   *
   * @param emailAddress the email address
   * @param settings     the settings
   * @param writer       the writer
   * @throws java.io.IOException Signals that an I/O exception has occurred.
   */
  private void writeLegacyAutodiscoverRequest(String emailAddress,
      ConfigurationSettingsBase settings, PrintWriter writer)
      throws IOException {
    writer.write(String.format("<Autodiscover xmlns=\"%s\">", AutodiscoverRequestNamespace));
    writer.write("<Request>");
    writer.write(String.format("<EMailAddress>%s</EMailAddress>",
        emailAddress));
    writer.write(
        String.format("<AcceptableResponseSchema>%s</AcceptableResponseSchema>", settings.getNamespace()));
    writer.write("</Request>");
    writer.write("</Autodiscover>");
  }

  /**
   * Gets a redirection URL to an SSL-enabled Autodiscover service from the
   * standard non-SSL Autodiscover URL.
   *
   * @param domainName the domain name
   * @return A valid SSL-enabled redirection URL. (May be null)
   * @throws EWSHttpException the EWS http exception
   * @throws XMLStreamException the XML stream exception
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws ServiceLocalException the service local exception
   * @throws URISyntaxException the uRI syntax exception
   */
  private URI getRedirectUrl(String domainName)
      throws EWSHttpException, XMLStreamException, IOException, ServiceLocalException, URISyntaxException {
    String url = String.format(AutodiscoverLegacyHttpUrl, "autodiscover." + domainName);

    traceMessage(TraceFlags.AutodiscoverConfiguration,
                 String.format("Trying to get Autodiscover redirection URL from %s.", url));

    HttpWebRequest request = null;

    try {
      request = new HttpClientWebRequest(httpClient, httpContext);
      request.setProxy(getWebProxy());

      try {
        request.setUrl(URI.create(url).toURL());
      } catch (MalformedURLException e) {
        String strErr = String.format("Incorrect format : %s", url);
        throw new ServiceLocalException(strErr);
      }

      request.setRequestMethod("GET");
      request.setAllowAutoRedirect(false);

      // Do NOT allow authentication as this single request will be made over plain HTTP.
      request.setAllowAuthentication(false);

      prepareCredentials(request);

      request.prepareConnection();
      try {
        request.executeRequest();
      } catch (IOException e) {
        traceMessage(TraceFlags.AutodiscoverConfiguration, "No Autodiscover redirection URL was returned.");
        return null;
      }

      OutParam<URI> outParam = new OutParam<URI>();
      if (tryGetRedirectionResponse(request, outParam)) {
        return outParam.getParam();
      }
    } finally {
      if (request != null) {
        try {
          request.close();
        } catch (Exception e) {
          // Ignore exception when closing the request
        }
      }
    }

    traceMessage(TraceFlags.AutodiscoverConfiguration, "No Autodiscover redirection URL was returned.");
    return null;
  }

  /**
   * Tries the get redirection response.
   *
   * @param request     the request
   * @param redirectUrl the redirect URL
   * @return true if a valid redirection URL was found
   * @throws XMLStreamException the XML stream exception
   * @throws IOException signals that an I/O exception has occurred.
   * @throws EWSHttpException the EWS http exception
   */
  private boolean tryGetRedirectionResponse(HttpWebRequest request,
      OutParam<URI> redirectUrl) throws XMLStreamException, IOException,
      EWSHttpException {
    // redirectUrl = null;
    if (AutodiscoverRequest.isRedirectionResponse(request)) {
      // Get the redirect location and verify that it's valid.
      String location = request.getResponseHeaderField("Location");

      if (!(location == null || location.isEmpty())) {
        try {
          redirectUrl.setParam(new URI(location));

          // Check if URL is SSL and that the path matches.
          if ((redirectUrl.getParam().getScheme().toLowerCase()
              .equals("https")) &&
              (redirectUrl.getParam().getPath()
                  .equalsIgnoreCase(
                      AutodiscoverLegacyPath))) {
            this.traceMessage(TraceFlags.AutodiscoverConfiguration,
                String.format("Redirection URL found: '%s'",
                    redirectUrl.getParam().toString()));

            return true;
          }
        } catch (URISyntaxException ex) {
          this
              .traceMessage(
                  TraceFlags.AutodiscoverConfiguration,
                  String
                      .format(
                          "Invalid redirection URL " +
                              "was returned: '%s'",
                          location));
          return false;
        }
      }
    }
    return false;
  }

  /**
   * Calls the legacy Autodiscover service to retrieve configuration settings.
   *
   * @param <TSettings>  the generic type
   * @param cls          the cls
   * @param emailAddress The email address to retrieve configuration settings for.
   * @return The requested configuration settings.
   * @throws Exception the exception
   */
  protected <TSettings extends ConfigurationSettingsBase>
  TSettings getLegacyUserSettings(
      Class<TSettings> cls, String emailAddress) throws Exception {
                /*int currentHop = 1;
                return this.internalGetConfigurationSettings(cls, emailAddress,
                                currentHop);*/

    // If Url is specified, call service directly.
    if (this.url != null) {
      // this.Uri is intended for Autodiscover SOAP service, convert to Legacy endpoint URL.
      URI autodiscoverUrl = new URI(this.url.toString() + AutodiscoverLegacyPath);
      return this.getLegacyUserSettingsAtUrl(cls, emailAddress, autodiscoverUrl);
    }

    // If Domain is specified, figure out the endpoint Url and call service.
    else if (!(this.domain == null || this.domain.isEmpty())) {
      URI autodiscoverUrl = new URI(String.format(AutodiscoverLegacyHttpsUrl, this.domain));
      return this.getLegacyUserSettingsAtUrl(cls,
          emailAddress, autodiscoverUrl);
    } else {
      // No Url or Domain specified, need to
      //figure out which endpoint to use.
      int currentHop = 1;
      OutParam<Integer> outParam = new OutParam<Integer>();
      outParam.setParam(currentHop);
      List<String> redirectionEmailAddresses = new ArrayList<String>();
      return this.internalGetLegacyUserSettings(
          cls,
          emailAddress,
          redirectionEmailAddresses,
          outParam);
    }
  }

  /**
   * Calls the Autodiscover service to retrieve configuration settings.
   *
   * @param <TSettings>  the generic type
   * @param cls          the cls
   * @param emailAddress The email address to retrieve configuration settings for.
   * @param currentHop   Current number of redirection urls/addresses attempted so far.
   * @return The requested configuration settings.
   * @throws Exception the exception
   */
  private <TSettings extends ConfigurationSettingsBase>
  TSettings internalGetLegacyUserSettings(
      Class<TSettings> cls,
      String emailAddress,
      List<String> redirectionEmailAddresses,
      OutParam<Integer> currentHop)
      throws Exception {
    String domainName = EwsUtilities.domainFromEmailAddress(emailAddress);

    int scpUrlCount;
    OutParam<Integer> outParamInt = new OutParam<Integer>();
    List<URI> urls = this.getAutodiscoverServiceUrls(domainName, outParamInt);
    scpUrlCount = outParamInt.getParam();
    if (urls.size() == 0) {
      throw new ServiceValidationException(
          "This Autodiscover request requires that either the Domain or Url be specified.");
    }

    // Assume caller is not inside the Intranet, regardless of whether SCP
    // Urls
    // were returned or not. SCP Urls are only relevent if one of them
    // returns
    // valid Autodiscover settings.
    this.isExternal = true;

    int currentUrlIndex = 0;

    // Used to save exception for later reporting.
    Exception delayedException = null;
    TSettings settings;

    do {
      URI autodiscoverUrl = urls.get(currentUrlIndex);
      boolean isScpUrl = currentUrlIndex < scpUrlCount;

      try {
        settings = this.getLegacyUserSettingsAtUrl(cls,
            emailAddress, autodiscoverUrl);

        switch (settings.getResponseType()) {
          case Success:
            // Not external if Autodiscover endpoint found via SCP
            // returned the settings.
            if (isScpUrl) {
              this.isExternal = false;
            }
            this.url = autodiscoverUrl;
            return settings;
          case RedirectUrl:
            if (currentHop.getParam() < AutodiscoverMaxRedirections) {
              currentHop.setParam(currentHop.getParam() + 1);

              this
                  .traceMessage(
                      TraceFlags.AutodiscoverResponse,
                      String
                          .format(
                              "Autodiscover " +
                                  "service " +
                                  "returned " +
                                  "redirection URL '%s'.",
                              settings
                                  .getRedirectTarget()));

              urls.add(currentUrlIndex, new URI(
                  settings.getRedirectTarget()));

              break;
            } else {
              throw new MaximumRedirectionHopsExceededException();
            }
          case RedirectAddress:
            if (currentHop.getParam() < AutodiscoverMaxRedirections) {
              currentHop.setParam(currentHop.getParam() + 1);

              this
                  .traceMessage(
                      TraceFlags.AutodiscoverResponse,
                      String
                          .format(
                              "Autodiscover " +
                                  "service " +
                                  "returned " +
                                  "redirection email " +
                                  "address '%s'.",
                              settings
                                  .getRedirectTarget()));
              // Bug E14:255576 If this email address was already tried, we may have a loop
              // in SCP lookups. Disable consideration of SCP records.
              this.disableScpLookupIfDuplicateRedirection(
                  settings.getRedirectTarget(),
                  redirectionEmailAddresses);

              return this.internalGetLegacyUserSettings(cls,
                  settings.getRedirectTarget(),
                  redirectionEmailAddresses,
                  currentHop);
            } else {
              throw new MaximumRedirectionHopsExceededException();
            }
          case Error:
            // Don't treat errors from an SCP-based Autodiscover service
            // to be conclusive.
            // We'll try the next one and record the error for later.
            if (isScpUrl) {
              this
                  .traceMessage(
                      TraceFlags.AutodiscoverConfiguration,
                      "Error returned by " +
                          "Autodiscover service " +
                          "found via SCP, treating " +
                          "as inconclusive.");

              delayedException = new AutodiscoverRemoteException(
                  "The Autodiscover service returned an error.", settings.getError());
              currentUrlIndex++;
            } else {
              throw new AutodiscoverRemoteException("The Autodiscover service returned an error.", settings.getError());
            }
            break;
          default:
            EwsUtilities
                .ewsAssert(false, "Autodiscover.GetConfigurationSettings",
                           "An unexpected error has occured. This code path should never be reached.");
            break;
        }
      } catch (XMLStreamException ex) {
        this.traceMessage(TraceFlags.AutodiscoverConfiguration, String
            .format("%s failed: XML parsing error: %s", url, ex
                .getMessage()));

        // The content at the URL wasn't a valid response, let's try the
        // next.
        currentUrlIndex++;
      } catch (IOException ex) {
        this.traceMessage(
            TraceFlags.AutodiscoverConfiguration,
            String.format("%s failed: I/O error: %s",
                url, ex.getMessage()));

        // The content at the URL wasn't a valid response, let's try the next.
        currentUrlIndex++;
      } catch (Exception ex) {
        HttpWebRequest response = null;
        URI redirectUrl;
        OutParam<URI> outParam1 = new OutParam<URI>();
        if ((response != null) &&
            this.tryGetRedirectionResponse(response, outParam1)) {
          redirectUrl = outParam1.getParam();
          this.traceMessage(TraceFlags.AutodiscoverConfiguration,
              String.format(
                  "Host returned a redirection to url %s",
                  redirectUrl.toString()));

          currentHop.setParam(currentHop.getParam() + 1);
          urls.add(currentUrlIndex, redirectUrl);
        } else {
          if (response != null) {
            this.processHttpErrorResponse(response, ex);

          }

          this.traceMessage(TraceFlags.AutodiscoverConfiguration,
              String.format("%s failed: %s (%s)", url, ex
                  .getClass().getName(), ex.getMessage()));

          // The url did not work, let's try the next.
          currentUrlIndex++;
        }
      }
    } while (currentUrlIndex < urls.size());

    // If we got this far it's because none of the URLs we tried have
    // worked. As a next-to-last chance, use GetRedirectUrl to
    // try to get a redirection URL using an HTTP GET on a non-SSL
    // Autodiscover endpoint. If successful, use this
    // redirection URL to get the configuration settings for this email
    // address. (This will be a common scenario for
    // DataCenter deployments).
    URI redirectionUrl = this.getRedirectUrl(domainName);
    OutParam<TSettings> outParam = new OutParam<TSettings>();
    if ((redirectionUrl != null)
        && this.tryLastChanceHostRedirection(cls, emailAddress,
        redirectionUrl, outParam)) {
      settings = outParam.getParam();
      return settings;
    } else {
      // Getting a redirection URL from an HTTP GET failed too. As a last
      // chance, try to get an appropriate SRV Record
      // using DnsQuery. If successful, use this redirection URL to get
      // the configuration settings for this email address.
      redirectionUrl = this.getRedirectionUrlFromDnsSrvRecord(domainName);
      if ((redirectionUrl != null)
          && this.tryLastChanceHostRedirection(cls, emailAddress,
          redirectionUrl, outParam)) {
        return outParam.getParam();
      }

      // If there was an earlier exception, throw it.
      if (delayedException != null) {
        throw delayedException;
      }

      throw new AutodiscoverLocalException("The Autodiscover service couldn't be located.");
    }
  }

  /**
   * Get an autodiscover SRV record in DNS and construct autodiscover URL.
   *
   * @param domainName Name of the domain.
   * @return Autodiscover URL (may be null if lookup failed)
   * @throws Exception the exception
   */
  protected URI getRedirectionUrlFromDnsSrvRecord(String domainName)
      throws Exception {

    this
        .traceMessage(
            TraceFlags.AutodiscoverConfiguration,
            String
                .format(
                    "Trying to get Autodiscover host " +
                        "from DNS SRV record for %s.",
                    domainName));

    String hostname = this.dnsClient
        .findAutodiscoverHostFromSrv(domainName);
    if (!(hostname == null || hostname.isEmpty())) {
      this
          .traceMessage(TraceFlags.AutodiscoverConfiguration,
              String.format(
                  "Autodiscover host %s was returned.",
                  hostname));

      return new URI(String.format(AutodiscoverLegacyHttpsUrl,
          hostname));
    } else {
      this.traceMessage(TraceFlags.AutodiscoverConfiguration,
          "No matching Autodiscover DNS SRV records were found.");

      return null;
    }
  }

  /**
   * Tries to get Autodiscover settings using redirection Url.
   *
   * @param <TSettings>    the generic type
   * @param cls            the cls
   * @param emailAddress   The email address.
   * @param redirectionUrl Redirection Url.
   * @param settings       The settings.
   * @return boolean The boolean.
   * @throws AutodiscoverLocalException  the autodiscover local exception
   * @throws AutodiscoverRemoteException the autodiscover remote exception
   * @throws Exception                   the exception
   */
  private <TSettings extends ConfigurationSettingsBase> boolean
  tryLastChanceHostRedirection(
      Class<TSettings> cls, String emailAddress, URI redirectionUrl,
      OutParam<TSettings> settings) throws AutodiscoverLocalException,
      AutodiscoverRemoteException, Exception {
    List<String> redirectionEmailAddresses = new ArrayList<String>();

    // Bug 60274: Performing a non-SSL HTTP GET to retrieve a redirection
    // URL is potentially unsafe. We allow the caller
    // to specify delegate to be called to determine whether we are allowed
    // to use the redirection URL.
    if (this
        .callRedirectionUrlValidationCallback(redirectionUrl.toString())) {
      for (int currentHop = 0; currentHop < AutodiscoverService.AutodiscoverMaxRedirections; currentHop++) {
        try {
          settings.setParam(this.getLegacyUserSettingsAtUrl(cls,
              emailAddress, redirectionUrl));

          switch (settings.getParam().getResponseType()) {
            case Success:
              return true;
            case Error:
              throw new AutodiscoverRemoteException("The Autodiscover service returned an error.", settings.getParam()
                  .getError());
            case RedirectAddress:
              // If this email address was already tried,
              //we may have a loop
              // in SCP lookups. Disable consideration of SCP records.
              this.disableScpLookupIfDuplicateRedirection(settings.getParam().getRedirectTarget(),
                  redirectionEmailAddresses);
              OutParam<Integer> outParam = new OutParam<Integer>();
              outParam.setParam(currentHop);
              settings.setParam(
                  this.internalGetLegacyUserSettings(cls,
                      emailAddress,
                      redirectionEmailAddresses,
                      outParam));
              currentHop = outParam.getParam();
              return true;
            case RedirectUrl:
              try {
                redirectionUrl = new URI(settings.getParam()
                    .getRedirectTarget());
              } catch (URISyntaxException ex) {
                this
                    .traceMessage(
                        TraceFlags.
                            AutodiscoverConfiguration,
                        String
                            .format(
                                "Service " +
                                    "returned " +
                                    "invalid " +
                                    "redirection " +
                                    "URL %s",
                                settings
                                    .getParam()
                                    .getRedirectTarget()));
                return false;
              }
              break;
            default:
              String failureMessage = String.format(
                  "Autodiscover call at %s failed with error %s, target %s",
                  redirectionUrl,
                  settings.getParam().getResponseType(),
                  settings.getParam().getRedirectTarget());
              this.traceMessage(
                  TraceFlags.AutodiscoverConfiguration, failureMessage);

              return false;
          }
        } catch (XMLStreamException ex) {
          // If the response is malformed, it wasn't a valid
          // Autodiscover endpoint.
          this
              .traceMessage(TraceFlags.AutodiscoverConfiguration,
                  String.format(
                      "%s failed: XML parsing error: %s",
                      redirectionUrl.toString(), ex
                          .getMessage()));
          return false;
        } catch (IOException ex) {
          this.traceMessage(
              TraceFlags.AutodiscoverConfiguration,
              String.format("%s failed: I/O error: %s",
                  redirectionUrl, ex.getMessage()));
          return false;
        } catch (Exception ex) {
          // TODO: BUG response is always null
          HttpWebRequest response = null;
          OutParam<URI> outParam = new OutParam<URI>();
          if ((response != null)
              && this.tryGetRedirectionResponse(response,
              outParam)) {
            redirectionUrl = outParam.getParam();
            this
                .traceMessage(
                    TraceFlags.AutodiscoverConfiguration,
                    String
                        .format(
                            "Host returned a " +
                                "redirection" +
                                " to url %s",
                            redirectionUrl));

          } else {
            if (response != null) {
              this.processHttpErrorResponse(response, ex);
            }

            this
                .traceMessage(
                    TraceFlags.AutodiscoverConfiguration,
                    String.format("%s failed: %s (%s)",
                        url, ex.getClass().getName(),
                        ex.getMessage()));
            return false;
          }
        }
      }
    }

    return false;
  }

  /**
   * Disables SCP lookup if duplicate email address redirection.
   *
   * @param emailAddress              The email address to use.
   * @param redirectionEmailAddresses The list of prior redirection email addresses.
   */
  private void disableScpLookupIfDuplicateRedirection(
      String emailAddress,
      List<String> redirectionEmailAddresses) {
    // SMTP addresses are case-insensitive so entries are converted to lower-case.
    emailAddress = emailAddress.toLowerCase();

    if (redirectionEmailAddresses.contains(emailAddress)) {
      this.enableScpLookup = false;
    } else {
      redirectionEmailAddresses.add(emailAddress);
    }
  }

  /**
   * Gets user settings from Autodiscover legacy endpoint.
   *
   * @param emailAddress      The email address to use.
   * @param requestedSettings The requested settings.
   * @return GetUserSettingsResponse
   * @throws Exception on error
   */
  protected GetUserSettingsResponse internalGetLegacyUserSettings(
      String emailAddress,
      List<UserSettingName> requestedSettings) throws Exception {
    // Cannot call legacy Autodiscover service with WindowsLive and other WSSecurity-based credential
    if ((this.getCredentials() != null) && (this.getCredentials() instanceof WSSecurityBasedCredentials)) {
      throw new AutodiscoverLocalException(
          "WindowsLiveCredentials can't be used with this Autodiscover endpoint.");
    }

    OutlookConfigurationSettings settings = this.getLegacyUserSettings(
        OutlookConfigurationSettings.class,
        emailAddress);



    return settings.convertSettings(emailAddress, requestedSettings);
  }

  /**
   * Calls the SOAP Autodiscover service
   * for user settings for a single SMTP address.
   *
   * @param smtpAddress       SMTP address.
   * @param requestedSettings The requested settings.
   * @return GetUserSettingsResponse
   * @throws Exception on error
   */
  protected GetUserSettingsResponse internalGetSoapUserSettings(
      String smtpAddress,
      List<UserSettingName> requestedSettings) throws Exception {
    List<String> smtpAddresses = new ArrayList<String>();
    smtpAddresses.add(smtpAddress);

    List<String> redirectionEmailAddresses = new ArrayList<String>();
    redirectionEmailAddresses.add(smtpAddress.toLowerCase());

    for (int currentHop = 0; currentHop < AutodiscoverService.AutodiscoverMaxRedirections; currentHop++) {
      GetUserSettingsResponse response = this.getUserSettings(smtpAddresses,
          requestedSettings).getTResponseAtIndex(0);

      switch (response.getErrorCode()) {
        case RedirectAddress:
          this.traceMessage(
              TraceFlags.AutodiscoverResponse,
              String.format("Autodiscover service returned redirection email address '%s'.",
                  response.getRedirectTarget()));

          smtpAddresses.clear();
          smtpAddresses.add(response.getRedirectTarget().
              toLowerCase());
          this.url = null;
          this.domain = null;

          // If this email address was already tried,
          //we may have a loop
          // in SCP lookups. Disable consideration of SCP records.
          this.disableScpLookupIfDuplicateRedirection(response.getRedirectTarget(),
              redirectionEmailAddresses);
          break;

        case RedirectUrl:
          this.traceMessage(
              TraceFlags.AutodiscoverResponse,
              String.format("Autodiscover service returned redirection URL '%s'.",
                  response.getRedirectTarget()));

          //this.url = new URI(response.getRedirectTarget());
          this.url = this.getCredentials().adjustUrl(new URI(response.getRedirectTarget()));
          break;

        case NoError:
        default:
          return response;
      }
    }

    throw new AutodiscoverLocalException("The Autodiscover service couldn't be located.");
  }

  /**
   * Gets the user settings using Autodiscover SOAP service.
   *
   * @param smtpAddresses The SMTP addresses of the users.
   * @param settings      The settings.
   * @return GetUserSettingsResponseCollection Object.
   * @throws Exception the exception
   */
  protected GetUserSettingsResponseCollection getUserSettings(
      final List<String> smtpAddresses, List<UserSettingName> settings)
      throws Exception {
    EwsUtilities.validateParam(smtpAddresses, "smtpAddresses");
    EwsUtilities.validateParam(settings, "settings");

    return this.getSettings(
        GetUserSettingsResponseCollection.class, UserSettingName.class,
        smtpAddresses, settings, null, this,
        new IFuncDelegate<String>() {
          public String func() throws FormatException {
            return EwsUtilities
                .domainFromEmailAddress(smtpAddresses.get(0));
          }
        });
  }

  /**
   * Gets user or domain settings using Autodiscover SOAP service.
   *
   * @param <TGetSettingsResponseCollection> the generic type
   * @param <TSettingName>                   the generic type
   * @param cls                              the cls
   * @param cls1                             the cls1
   * @param identities                       Either the domains or the SMTP addresses of the users.
   * @param settings                         The settings.
   * @param requestedVersion                 Requested version of the Exchange service.
   * @param getSettingsMethod                The method to use.
   * @param getDomainMethod                  The method to calculate the domain value.
   * @return TGetSettingsResponse Collection.
   * @throws Exception the exception
   */
  private <TGetSettingsResponseCollection, TSettingName>
  TGetSettingsResponseCollection getSettings(
      Class<TGetSettingsResponseCollection> cls,
      Class<TSettingName> cls1,
      List<String> identities,
      List<TSettingName> settings,
      ExchangeVersion requestedVersion,
      IFunctionDelegate<List<String>, List<TSettingName>,
          TGetSettingsResponseCollection> getSettingsMethod,
      IFuncDelegate<String> getDomainMethod) throws Exception {
    TGetSettingsResponseCollection response;

    // Autodiscover service only exists in E14 or later.
    if (this.getRequestedServerVersion().compareTo(
        MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
      throw new ServiceVersionException(String.format(
          "The Autodiscover service only supports %s or a later version.",
          MinimumRequestVersionForAutoDiscoverSoapService));
    }

    // If Url is specified, call service directly.
    if (this.url != null) {
      URI autodiscoverUrl = this.url;
      response = getSettingsMethod.func(identities, settings,
          requestedVersion, this.url);
      this.url = autodiscoverUrl;
      return response;
    }
    // If Domain is specified, determine endpoint Url and call service.
    else if (!(this.domain == null || this.domain.isEmpty())) {
      URI autodiscoverUrl = this.getAutodiscoverEndpointUrl(this.domain);
      response = getSettingsMethod.func(identities, settings,
          requestedVersion,
          autodiscoverUrl);

      // If we got this far, response was successful, set Url.
      this.url = autodiscoverUrl;
      return response;
    }
    // No Url or Domain specified, need to figure out which endpoint(s) to
    // try.
    else {
      // Assume caller is not inside the Intranet, regardless of whether
      // SCP Urls
      // were returned or not. SCP Urls are only relevent if one of them
      // returns
      // valid Autodiscover settings.
      this.isExternal = true;

      URI autodiscoverUrl;

      String domainName = getDomainMethod.func();
      int scpHostCount;
      OutParam<Integer> outParam = new OutParam<Integer>();
      List<String> hosts = this.getAutodiscoverServiceHosts(domainName,
          outParam);
      scpHostCount = outParam.getParam();
      if (hosts.size() == 0) {
        throw new ServiceValidationException(
            "This Autodiscover request requires that either the Domain or Url be specified.");
      }

      for (int currentHostIndex = 0; currentHostIndex < hosts.size(); currentHostIndex++) {
        String host = hosts.get(currentHostIndex);
        boolean isScpHost = currentHostIndex < scpHostCount;
        OutParam<URI> outParams = new OutParam<URI>();
        if (this.tryGetAutodiscoverEndpointUrl(host, outParams)) {
          autodiscoverUrl = outParams.getParam();
          response = getSettingsMethod.func(identities, settings,
              requestedVersion,
              autodiscoverUrl);

          // If we got this far, the response was successful, set Url.
          this.url = autodiscoverUrl;

          // Not external if Autodiscover endpoint found via SCP
          // returned the settings.
          if (isScpHost) {
            this.isExternal = false;
          }

          return response;
        }
      }

      // Next-to-last chance: try unauthenticated GET over HTTP to be
      // redirected to appropriate service endpoint.
      autodiscoverUrl = this.getRedirectUrl(domainName);
      OutParam<URI> outParamUrl = new OutParam<URI>();
      if ((autodiscoverUrl != null) &&
          this
              .callRedirectionUrlValidationCallback(
                  autodiscoverUrl.toString()) &&
          this.tryGetAutodiscoverEndpointUrl(autodiscoverUrl
              .getHost(), outParamUrl)) {
        autodiscoverUrl = outParamUrl.getParam();
        response = getSettingsMethod.func(identities, settings,
            requestedVersion,
            autodiscoverUrl);

        // If we got this far, the response was successful, set Url.
        this.url = autodiscoverUrl;

        return response;
      }

      // Last Chance: try to read autodiscover SRV Record from DNS. If we
      // find one, use
      // the hostname returned to construct an Autodiscover endpoint URL.
      autodiscoverUrl = this
          .getRedirectionUrlFromDnsSrvRecord(domainName);
      if ((autodiscoverUrl != null) &&
          this
              .callRedirectionUrlValidationCallback(
                  autodiscoverUrl.toString()) &&
          this.tryGetAutodiscoverEndpointUrl(autodiscoverUrl
              .getHost(), outParamUrl)) {
        autodiscoverUrl = outParamUrl.getParam();
        response = getSettingsMethod.func(identities, settings,
            requestedVersion,
            autodiscoverUrl);

        // If we got this far, the response was successful, set Url.
        this.url = autodiscoverUrl;

        return response;
      } else {
        throw new AutodiscoverLocalException("The Autodiscover service couldn't be located.");
      }
    }
  }

  /**
   * Gets settings for one or more users.
   *
   * @param smtpAddresses    The SMTP addresses of the users.
   * @param settings         The settings.
   * @param requestedVersion Requested version of the Exchange service.
   * @param autodiscoverUrl  The autodiscover URL.
   * @return GetUserSettingsResponse collection.
   * @throws ServiceLocalException the service local exception
   * @throws Exception             the exception
   */
  private GetUserSettingsResponseCollection internalGetUserSettings(
      List<String> smtpAddresses, List<UserSettingName> settings,
      ExchangeVersion requestedVersion,
      URI autodiscoverUrl) throws ServiceLocalException, Exception {
    // The response to GetUserSettings can be a redirection. Execute
    // GetUserSettings until we get back
    // a valid response or we've followed too many redirections.
    for (int currentHop = 0; currentHop < AutodiscoverService.AutodiscoverMaxRedirections; currentHop++) {
      GetUserSettingsRequest request = new GetUserSettingsRequest(this,
          autodiscoverUrl);
      request.setSmtpAddresses(smtpAddresses);
      request.setSettings(settings);
      GetUserSettingsResponseCollection response = request.execute();

      // Did we get redirected?
      if (response.getErrorCode() == AutodiscoverErrorCode.RedirectUrl
          && response.getRedirectionUrl() != null) {
        this.traceMessage(
            TraceFlags.AutodiscoverConfiguration,
            String.format("Request to %s returned redirection to %s",
                autodiscoverUrl.toString(), response.getRedirectionUrl()));

        autodiscoverUrl = response.getRedirectionUrl();
      } else {
        return response;
      }
    }

    this.traceMessage(TraceFlags.AutodiscoverConfiguration, String.format(
        "Maximum number of redirection hops %d exceeded",
        AutodiscoverMaxRedirections));

    throw new MaximumRedirectionHopsExceededException();
  }

  /**
   * Gets the domain settings using Autodiscover SOAP service.
   *
   * @param domains          The domains.
   * @param settings         The settings.
   * @param requestedVersion Requested version of the Exchange service.
   * @return GetDomainSettingsResponse collection.
   * @throws Exception the exception
   */
  protected GetDomainSettingsResponseCollection getDomainSettings(
      final List<String> domains, List<DomainSettingName> settings,
      ExchangeVersion requestedVersion)
      throws Exception {
    EwsUtilities.validateParam(domains, "domains");
    EwsUtilities.validateParam(settings, "settings");

    return this.getSettings(
        GetDomainSettingsResponseCollection.class,
        DomainSettingName.class, domains, settings,
        requestedVersion, this,
        new IFuncDelegate<String>() {
          public String func() {
            return domains.get(0);
          }
        });
  }

  /**
   * Gets settings for one or more domains.
   *
   * @param domains          The domains.
   * @param settings         The settings.
   * @param requestedVersion Requested version of the Exchange service.
   * @param autodiscoverUrl  The autodiscover URL.
   * @return GetDomainSettingsResponse Collection.
   * @throws ServiceLocalException the service local exception
   * @throws Exception             the exception
   */
  private GetDomainSettingsResponseCollection internalGetDomainSettings(
      List<String> domains, List<DomainSettingName> settings,
      ExchangeVersion requestedVersion,
      URI autodiscoverUrl) throws ServiceLocalException, Exception {
    // The response to GetDomainSettings can be a redirection. Execute
    // GetDomainSettings until we get back
    // a valid response or we've followed too many redirections.
    for (int currentHop = 0; currentHop < AutodiscoverService.AutodiscoverMaxRedirections; currentHop++) {
      GetDomainSettingsRequest request = new GetDomainSettingsRequest(
          this, autodiscoverUrl);
      request.setDomains(domains);
      request.setSettings(settings);
      request.setRequestedVersion(requestedVersion);
      GetDomainSettingsResponseCollection response = request.execute();

      // Did we get redirected?
      if (response.getErrorCode() == AutodiscoverErrorCode.RedirectUrl
          && response.getRedirectionUrl() != null) {
        autodiscoverUrl = response.getRedirectionUrl();
      } else {
        return response;
      }
    }

    this.traceMessage(TraceFlags.AutodiscoverConfiguration, String.format(
        "Maximum number of redirection hops %d exceeded",
        AutodiscoverMaxRedirections));

    throw new MaximumRedirectionHopsExceededException();
  }

  /**
   * Gets the autodiscover endpoint URL.
   *
   * @param host The host.
   * @return URI The URI.
   * @throws Exception the exception
   */
  private URI getAutodiscoverEndpointUrl(String host) throws Exception {
    URI autodiscoverUrl = null;
    OutParam<URI> outParam = new OutParam<URI>();
    if (this.tryGetAutodiscoverEndpointUrl(host, outParam)) {
      return autodiscoverUrl;
    } else {
      throw new AutodiscoverLocalException(
          "No appropriate Autodiscover SOAP or WS-Security endpoint is available.");
    }
  }

  /**
   * Tries the get Autodiscover Service endpoint URL.
   *
   * @param host The host.
   * @param url  the url
   * @return boolean The boolean.
   * @throws Exception the exception
   */
  private boolean tryGetAutodiscoverEndpointUrl(String host,
      OutParam<URI> url)
      throws Exception {
    EnumSet<AutodiscoverEndpoints> endpoints;
    OutParam<EnumSet<AutodiscoverEndpoints>> outParam =
        new OutParam<EnumSet<AutodiscoverEndpoints>>();
    if (this.tryGetEnabledEndpointsForHost(host, outParam)) {
      endpoints = outParam.getParam();
      url
          .setParam(new URI(String.format(AutodiscoverSoapHttpsUrl,
              host)));

      // Make sure that at least one of the non-legacy endpoints is
      // available.
      if ((!endpoints.contains(AutodiscoverEndpoints.Soap)) &&
          (!endpoints.contains(
              AutodiscoverEndpoints.WsSecurity))
        // (endpoints .contains( AutodiscoverEndpoints.WSSecuritySymmetricKey) ) &&
        //(endpoints .contains( AutodiscoverEndpoints.WSSecurityX509Cert))
          ) {
        this
            .traceMessage(
                TraceFlags.AutodiscoverConfiguration,
                String
                    .format(
                        "No Autodiscover endpoints " +
                            "are available  for host %s",
                        host));

        return false;
      }

      // If we have WLID credential, make sure that we have a WS-Security
      // endpoint
                        /*
                        if (this.getCredentials() instanceof WindowsLiveCredentials) {
                                if (endpoints.contains(AutodiscoverEndpoints.WsSecurity)) {
                                        this
                                                        .traceMessage(
                                                                        TraceFlags.AutodiscoverConfiguration,
                                                                        String
                                                                                        .format(
                                                                                                        "No Autodiscover " +
                                                                                                        "WS-Security " +
                                                                                                        "endpoint is available" +
                                                                                                        " for host %s",
                                                                                                        host));

                                        return false;
                                } else {
                                        url.setParam(new URI(String.format(
                                                        AutodiscoverSoapWsSecurityHttpsUrl, host)));
                                }
                        }
                           else if (this.getCredentials() instanceof PartnerTokenCredentials)
                {
                    if (endpoints.contains( AutodiscoverEndpoints.WSSecuritySymmetricKey))
                    {
                        this.traceMessage(
                            TraceFlags.AutodiscoverConfiguration,
                            String.format("No Autodiscover WS-Security/SymmetricKey endpoint is available for host {0}", host));

                        return false;
                    }
                    else
                    {
                        url.setParam( new URI(String.format(AutodiscoverSoapWsSecuritySymmetricKeyHttpsUrl, host)));
                    }
                }
                else if (this.getCredentials()instanceof X509CertificateCredentials)
                {
                    if ((endpoints.contains(AutodiscoverEndpoints.WSSecurityX509Cert))
                    {
                        this.traceMessage(
                            TraceFlags.AutodiscoverConfiguration,
                            String.format("No Autodiscover WS-Security/X509Cert endpoint is available for host {0}", host));

                        return false;
                    }
                    else
                    {
                        url.setParam( new URI(String.format(AutodiscoverSoapWsSecurityX509CertHttpsUrl, host)));
                    }
                }
                                  */
      return true;


    } else {
      this
          .traceMessage(
              TraceFlags.AutodiscoverConfiguration,
              String
                  .format(
                      "No Autodiscover endpoints " +
                          "are available for host %s",
                      host));

      return false;
    }
  }

  /**
   * Gets the list of autodiscover service URLs.
   *
   * @param domainName   Domain name.
   * @param scpHostCount Count of hosts found via SCP lookup.
   * @return List of Autodiscover URLs.
   * @throws java.net.URISyntaxException the URI Syntax exception
   */
  protected List<URI> getAutodiscoverServiceUrls(String domainName,
      OutParam<Integer> scpHostCount) throws URISyntaxException {
    List<URI> urls;

    urls = new ArrayList<URI>();

    scpHostCount.setParam(urls.size());

    // As a fallback, add autodiscover URLs base on the domain name.
    urls.add(new URI(String.format(AutodiscoverLegacyHttpsUrl,
        domainName)));
    urls.add(new URI(String.format(AutodiscoverLegacyHttpsUrl,
        "autodiscover." + domainName)));

    return urls;
  }

  /**
   * Gets the list of autodiscover service hosts.
   *
   * @param domainName Domain name.
   * @param outParam   the out param
   * @return List of hosts.
   * @throws java.net.URISyntaxException the uRI syntax exception
   * @throws ClassNotFoundException      the class not found exception
   */
  protected List<String> getAutodiscoverServiceHosts(String domainName,
      OutParam<Integer> outParam) throws URISyntaxException,
      ClassNotFoundException {

    List<URI> urls = this.getAutodiscoverServiceUrls(domainName, outParam);
    List<String> lst = new ArrayList<String>();
    for (URI url : urls) {
      lst.add(url.getHost());
    }
    return lst;
  }

  /**
   * Gets the enabled autodiscover endpoints on a specific host.
   *
   * @param host      The host.
   * @param endpoints Endpoints found for host.
   * @return Flags indicating which endpoints are enabled.
   * @throws Exception the exception
   */
  private boolean tryGetEnabledEndpointsForHost(String host,
      OutParam<EnumSet<AutodiscoverEndpoints>> endpoints) throws Exception {
    this.traceMessage(TraceFlags.AutodiscoverConfiguration, String.format(
        "Determining which endpoints are enabled for host %s", host));

    // We may get redirected to another host. And therefore need to limit the number of redirections we'll
    // tolerate.
    for (int currentHop = 0; currentHop < AutodiscoverMaxRedirections; currentHop++) {
      URI autoDiscoverUrl = new URI(String.format(AutodiscoverLegacyHttpsUrl, host));

      endpoints.setParam(EnumSet.of(AutodiscoverEndpoints.None));

      HttpWebRequest request = null;
      try {
        request = new HttpClientWebRequest(httpClient, httpContext);
        request.setProxy(getWebProxy());

        try {
          request.setUrl(autoDiscoverUrl.toURL());
        } catch (MalformedURLException e) {
          String strErr = String.format("Incorrect format : %s", url);
          throw new ServiceLocalException(strErr);
        }

        request.setRequestMethod("GET");
        request.setAllowAutoRedirect(false);
        request.setPreAuthenticate(false);
        request.setUseDefaultCredentials(this.getUseDefaultCredentials());

        prepareCredentials(request);

        request.prepareConnection();
        try {
          request.executeRequest();
        } catch (IOException e) {
          return false;
        }

        OutParam<URI> outParam = new OutParam<URI>();
        if (this.tryGetRedirectionResponse(request, outParam)) {
          URI redirectUrl = outParam.getParam();
          this.traceMessage(TraceFlags.AutodiscoverConfiguration,
              String.format("Host returned redirection to host '%s'", redirectUrl.getHost()));

          host = redirectUrl.getHost();
        } else {
          endpoints.setParam(this.getEndpointsFromHttpWebResponse(request));

          this.traceMessage(TraceFlags.AutodiscoverConfiguration,
              String.format("Host returned enabled endpoint flags: %s", endpoints.getParam().toString()));

          return true;
        }
      } finally {
        if (request != null) {
          try {
            request.close();
          } catch (Exception e) {
            // Connection can't be closed. We'll ignore this...
          }
        }
      }
    }

    this.traceMessage(TraceFlags.AutodiscoverConfiguration,
        String.format("Maximum number of redirection hops %d exceeded", AutodiscoverMaxRedirections));

    throw new MaximumRedirectionHopsExceededException();
  }

  /**
   * Gets the endpoints from HTTP web response.
   *
   * @param request the request
   * @return Endpoints enabled.
   * @throws EWSHttpException the EWS http exception
   */
  private EnumSet<AutodiscoverEndpoints> getEndpointsFromHttpWebResponse(
      HttpWebRequest request) throws EWSHttpException {
    EnumSet<AutodiscoverEndpoints> endpoints = EnumSet
        .noneOf(AutodiscoverEndpoints.class);
    endpoints.add(AutodiscoverEndpoints.Legacy);

    if (!(request.getResponseHeaders().get(
        AutodiscoverSoapEnabledHeaderName) == null || request
        .getResponseHeaders().get(AutodiscoverSoapEnabledHeaderName)
        .isEmpty())) {
      endpoints.add(AutodiscoverEndpoints.Soap);
    }
    if (!(request.getResponseHeaders().get(
        AutodiscoverWsSecurityEnabledHeaderName) == null || request
        .getResponseHeaders().get(
            AutodiscoverWsSecurityEnabledHeaderName).isEmpty())) {
      endpoints.add(AutodiscoverEndpoints.WsSecurity);
    }
                
                /* if (! (request.getResponseHeaders().get(
                                 AutodiscoverWsSecuritySymmetricKeyEnabledHeaderName) !=null || request
                                 .getResponseHeaders().get(
                                 AutodiscoverWsSecuritySymmetricKeyEnabledHeaderName).isEmpty()))
         {
             endpoints .add( AutodiscoverEndpoints.WSSecuritySymmetricKey);
         }
         if (!(request.getResponseHeaders().get(
                         AutodiscoverWsSecurityX509CertEnabledHeaderName)!=null ||
                         request.getResponseHeaders().get(
                                 AutodiscoverWsSecurityX509CertEnabledHeaderName).isEmpty()))
                         
         {
             endpoints .add(AutodiscoverEndpoints.WSSecurityX509Cert);
         }*/

    return endpoints;
  }

  /**
   * Traces the response.
   *
   * @param request      the request
   * @param memoryStream the memory stream
   * @throws XMLStreamException the XML stream exception
   * @throws IOException signals that an I/O exception has occurred.
   * @throws EWSHttpException the EWS http exception
   */
  public void traceResponse(HttpWebRequest request, ByteArrayOutputStream memoryStream) throws XMLStreamException,
      IOException, EWSHttpException {
    this.processHttpResponseHeaders(
        TraceFlags.AutodiscoverResponseHttpHeaders, request);
    String contentType = request.getResponseContentType();
    if (!(contentType == null || contentType.isEmpty())) {
      contentType = contentType.toLowerCase();
      if (contentType.toLowerCase().startsWith("text/") ||
          contentType.toLowerCase().
              startsWith("application/soap")) {
        this.traceXml(TraceFlags.AutodiscoverResponse, memoryStream);
      } else {
        this.traceMessage(TraceFlags.AutodiscoverResponse,
            "Non-textual response");
      }
    }
  }

  /**
   * Creates an HttpWebRequest instance and initializes it with the
   * appropriate parameters, based on the configuration of this service
   * object.
   *
   * @param url The URL that the HttpWebRequest should target
   * @return HttpWebRequest The HttpWebRequest
   * @throws ServiceLocalException       the service local exception
   * @throws java.net.URISyntaxException the uRI syntax exception
   */
  public HttpWebRequest prepareHttpWebRequestForUrl(URI url)
      throws ServiceLocalException, URISyntaxException {
    return this.prepareHttpWebRequestForUrl(url, false,
        // acceptGzipEncoding
        false); // allowAutoRedirect
  }

  /**
   * Calls the redirection URL validation callback. If the redirection URL
   * validation callback is null, use the default callback which does not
   * allow following any redirections.
   *
   * @param redirectionUrl The redirection URL.
   * @return True if redirection should be followed.
   * @throws AutodiscoverLocalException the autodiscover local exception
   */
  private boolean callRedirectionUrlValidationCallback(String redirectionUrl)
      throws AutodiscoverLocalException {
    IAutodiscoverRedirectionUrl callback =
        (this.redirectionUrlValidationCallback == null) ? this
            : this.redirectionUrlValidationCallback;
    return callback
        .autodiscoverRedirectionUrlValidationCallback(redirectionUrl);
  }

  /**
   * Processes an HTTP error response.
   *
   * @param httpWebResponse The HTTP web response.
   * @throws Exception the exception
   */
  @Override public void processHttpErrorResponse(HttpWebRequest httpWebResponse, Exception webException) throws Exception {
    this.internalProcessHttpErrorResponse(
        httpWebResponse,
        webException,
        TraceFlags.AutodiscoverResponseHttpHeaders,
        TraceFlags.AutodiscoverResponse);
  }

  /*
   * (non-Javadoc)
   *
   * @see microsoft.exchange.webservices.AutodiscoverRedirectionUrlInterface#
   * autodiscoverRedirectionUrlValidationCallback(java.lang.String)
   */
  public boolean autodiscoverRedirectionUrlValidationCallback(
      String redirectionUrl) throws AutodiscoverLocalException {
    return defaultAutodiscoverRedirectionUrlValidationCallback(
        redirectionUrl);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService() throws ArgumentException {
    this(ExchangeVersion.Exchange2010);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param requestedServerVersion The requested server version
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(ExchangeVersion requestedServerVersion)
      throws ArgumentException {
    this(null, null, requestedServerVersion);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param domain The domain that will be used to determine the URL of the service
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(String domain) throws ArgumentException {
    this(null, domain);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param domain                 The domain that will be used to determine the URL of the service
   * @param requestedServerVersion The requested server version
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(String domain,
      ExchangeVersion requestedServerVersion) throws ArgumentException {
    this(null, domain, requestedServerVersion);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param url The URL of the service
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(URI url) throws ArgumentException {
    this(url, url.getHost());
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param url                    The URL of the service
   * @param requestedServerVersion The requested server version
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(URI url,
      ExchangeVersion requestedServerVersion) throws ArgumentException {
    this(url, url.getHost(), requestedServerVersion);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param url    The URL of the service
   * @param domain The domain that will be used to determine the URL of the service
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(URI url, String domain)
      throws ArgumentException {
    super();
    EwsUtilities.validateDomainNameAllowNull(domain, "domain");
    this.url = url;
    this.domain = domain;
    this.dnsClient = new AutodiscoverDnsClient(this);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param url                    The URL of the service.
   * @param domain                 The domain that will be used to determine the URL of the
   *                               service.
   * @param requestedServerVersion The requested server version.
   * @throws ArgumentException on validation error
   */
  public AutodiscoverService(URI url, String domain,
      ExchangeVersion requestedServerVersion) throws ArgumentException {
    super(requestedServerVersion);
    EwsUtilities.validateDomainNameAllowNull(domain, "domain");

    this.url = url;
    this.domain = domain;
    this.dnsClient = new AutodiscoverDnsClient(this);
  }

  /**
   * Initializes a new instance of the AutodiscoverService class.
   *
   * @param service                The other service.
   * @param requestedServerVersion The requested server version.
   */
  public AutodiscoverService(ExchangeServiceBase service,
      ExchangeVersion requestedServerVersion) {
    super(service, requestedServerVersion);
    this.dnsClient = new AutodiscoverDnsClient(this);
  }

  /**
   * Initializes a new instance of the "AutodiscoverService" class.
   *
   * @param service The service.
   */
  public AutodiscoverService(ExchangeServiceBase service) {
    super(service, service.getRequestedServerVersion());
  }

  /**
   * Retrieves the specified settings for single SMTP address.
   * <p>This method will run the entire Autodiscover "discovery"
   * algorithm and will follow address and URL redirections.</p>

   * @param userSmtpAddress  The SMTP addresses of the user.
   * @param userSettingNames The user setting names.
   * @return A UserResponse object containing the requested settings for the
   * specified user.
   * @throws Exception on error
   */
  public GetUserSettingsResponse getUserSettings(String userSmtpAddress,
      UserSettingName... userSettingNames) throws Exception {
    List<UserSettingName> requestedSettings = new ArrayList<UserSettingName>();
    requestedSettings.addAll(Arrays.asList(userSettingNames));

    if (userSmtpAddress == null || userSmtpAddress.isEmpty()) {
      throw new ServiceValidationException("A valid SMTP address must be specified.");
    }

    if (requestedSettings.size() == 0) {
      throw new ServiceValidationException("At least one setting must be requested.");
    }

    if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
      return this.internalGetLegacyUserSettings(userSmtpAddress,
          requestedSettings);
    } else {
      return this.internalGetSoapUserSettings(userSmtpAddress,
          requestedSettings);
    }

  }

  /**
   * Retrieves the specified settings for a set of users.
   *
   * @param userSmtpAddresses the user smtp addresses
   * @param userSettingNames  The user setting names.
   * @return A GetUserSettingsResponseCollection object containing the
   * response for each individual user.
   * @throws Exception the exception
   */
  public GetUserSettingsResponseCollection getUsersSettings(
      Iterable<String> userSmtpAddresses,
      UserSettingName... userSettingNames) throws Exception {
    if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
      throw new ServiceVersionException(
          String.format("The Autodiscover service only supports %s or a later version.",
              MinimumRequestVersionForAutoDiscoverSoapService));
    }
    List<String> smtpAddresses = new ArrayList<String>();
    smtpAddresses.addAll((Collection<? extends String>) userSmtpAddresses);
    List<UserSettingName> settings = new ArrayList<UserSettingName>();
    settings.addAll(Arrays.asList(userSettingNames));
    return this.getUserSettings(smtpAddresses, settings);
  }

  /**
   * Retrieves the specified settings for a domain.
   *
   * @param domain             The domain.
   * @param requestedVersion   Requested version of the Exchange service.
   * @param domainSettingNames The domain setting names.
   * @return A DomainResponse object containing the requested settings for the
   * specified domain.
   * @throws Exception the exception
   */
  public GetDomainSettingsResponse getDomainSettings(String domain,
      ExchangeVersion requestedVersion,
      DomainSettingName... domainSettingNames) throws Exception {
    List<String> domains = new ArrayList<String>(1);
    domains.add(domain);

    List<DomainSettingName> settings = new ArrayList<DomainSettingName>();
    settings.addAll(Arrays.asList(domainSettingNames));

    return this.getDomainSettings(domains, settings, requestedVersion).
        getTResponseAtIndex(0);
  }

  /**
   * Retrieves the specified settings for a set of domains.
   *
   * @param domains            the domains
   * @param requestedVersion   Requested version of the Exchange service.
   * @param domainSettingNames The domain setting names.
   * @return A GetDomainSettingsResponseCollection object containing the
   * response for each individual domain.
   * @throws Exception the exception
   */
  public GetDomainSettingsResponseCollection getDomainSettings(
      Iterable<String> domains, ExchangeVersion requestedVersion,
      DomainSettingName... domainSettingNames)
      throws Exception {
    List<DomainSettingName> settings = new ArrayList<DomainSettingName>();
    settings.addAll(Arrays.asList(domainSettingNames));

    List<String> domainslst = new ArrayList<String>();
    domainslst.addAll((Collection<? extends String>) domains);

    return this.getDomainSettings(domainslst, settings, requestedVersion);
  }

  /**
   * Gets the domain this service is bound to. When this property is
   * set, the domain name is used to automatically determine the Autodiscover service URL.
   *
   * @return the domain
   */
  public String getDomain() {
    return this.domain;
  }

  /**
   * Sets the domain this service is bound to. When this property is
   * set, the domain
   * name is used to automatically determine the Autodiscover service URL.
   *
   * @param value the new domain
   * @throws ArgumentException on validation error
   */
  public void setDomain(String value) throws ArgumentException {
    EwsUtilities.validateDomainNameAllowNull(value, "Domain");

    // If Domain property is set to non-null value, Url property is nulled.
    if (value != null) {
      this.url = null;
    }
    this.domain = value;
  }

  /**
   * Gets the url this service is bound to.
   *
   * @return the url
   */
  public URI getUrl() {
    return this.url;
  }

  /**
   * Sets the url this service is bound to.
   *
   * @param value the new url
   */
  public void setUrl(URI value) {
    // If Url property is set to non-null value, Domain property is set to
    // host portion of Url.
    if (value != null) {
      this.domain = value.getHost();
    }
    this.url = value;
  }

  public Boolean isExternal() {
    return this.isExternal;
  }

  protected void setIsExternal(Boolean value) {
    this.isExternal = value;
  }


  /**
   * Gets the redirection url validation callback.
   *
   * @return the redirection url validation callback
   */
  public IAutodiscoverRedirectionUrl
  getRedirectionUrlValidationCallback() {
    return this.redirectionUrlValidationCallback;
  }

  /**
   * Sets the redirection url validation callback.
   *
   * @param value the new redirection url validation callback
   */
  public void setRedirectionUrlValidationCallback(
      IAutodiscoverRedirectionUrl value) {
    this.redirectionUrlValidationCallback = value;
  }

  /**
   * Gets the dns server address.
   *
   * @return the dns server address
   */
  protected String getDnsServerAddress() {
    return this.dnsServerAddress;
  }

  /**
   * Sets the dns server address.
   *
   * @param value the new dns server address
   */
  protected void setDnsServerAddress(String value) {
    this.dnsServerAddress = value;
  }

  /**
   * Gets a value indicating whether the AutodiscoverService should
   * perform SCP (ServiceConnectionPoint) record lookup when determining
   * the Autodiscover service URL.
   *
   * @return the enable scp lookup
   */
  public boolean getEnableScpLookup() {
    return this.enableScpLookup;
  }

  /**
   * Sets the enable scp lookup.
   *
   * @param value the new enable scp lookup
   */
  public void setEnableScpLookup(boolean value) {
    this.enableScpLookup = value;
  }

  /*
   * (non-Javadoc)
   *
   * @see
   * microsoft.exchange.webservices.FuncDelegateInterface#func(java.util.List,
   * java.util.List, java.net.URI)
   */
  @Override
  public Object func(List arg1, List arg2, ExchangeVersion arg3, URI arg4)
      throws ServiceLocalException, Exception {
    if (arg2.get(0).getClass().equals(DomainSettingName.class)) {
      return internalGetDomainSettings(arg1, arg2, arg3, arg4);
    } else if (arg2.get(0).getClass().equals(UserSettingName.class)) {
      return internalGetUserSettings(arg1, arg2, arg3, arg4);
    } else {
      return null;
    }
  }

}