/**
   * Reads the SOAP fault.
   *
   * @param reader The reader.
   * @return SOAP fault details.
   */
  private SoapFaultDetails readSoapFault(EwsXmlReader reader) {
    SoapFaultDetails soapFaultDetails = null;

    try {

      reader.read();
      if (reader.getNodeType().getNodeType() == XmlNodeType.START_DOCUMENT) {
        reader.read();
      }
      if (!reader.isStartElement()
          || (!reader.getLocalName().equals(XmlElementNames.SOAPEnvelopeElementName))) {
        return null;
      }

      // Get the namespace URI from the envelope element and use it for
      // the rest of the parsing.
      // If it's not 1.1 or 1.2, we can't continue.
      XmlNamespace soapNamespace = EwsUtilities.getNamespaceFromUri(reader.getNamespaceUri());
      if (soapNamespace == XmlNamespace.NotSpecified) {
        return null;
      }

      reader.read();

      // Skip SOAP header.
      if (reader.isStartElement(soapNamespace, XmlElementNames.SOAPHeaderElementName)) {
        do {
          reader.read();
        } while (!reader.isEndElement(soapNamespace, XmlElementNames.SOAPHeaderElementName));

        // Queue up the next read
        reader.read();
      }

      // Parse the fault element contained within the SOAP body.
      if (reader.isStartElement(soapNamespace, XmlElementNames.SOAPBodyElementName)) {
        do {
          reader.read();

          // Parse Fault element
          if (reader.isStartElement(soapNamespace, XmlElementNames.SOAPFaultElementName)) {
            soapFaultDetails = SoapFaultDetails.parse(reader, soapNamespace);
          }
        } while (!reader.isEndElement(soapNamespace, XmlElementNames.SOAPBodyElementName));
      }

      reader.readEndElement(soapNamespace, XmlElementNames.SOAPEnvelopeElementName);
    } catch (Exception e) {
      // If response doesn't contain a valid SOAP fault, just ignore
      // exception and
      // return null for SOAP fault details.
      e.printStackTrace();
    }

    return soapFaultDetails;
  }
  /**
   * Parses the detail node.
   *
   * @param reader the reader
   * @throws ServiceXmlDeserializationException the service xml deserialization exception
   * @throws javax.xml.stream.XMLStreamException the xML stream exception
   * @throws Exception the exception
   */
  private void parseDetailNode(EwsXmlReader reader)
      throws ServiceXmlDeserializationException, XMLStreamException, Exception, Exception {
    do {
      reader.read();
      if (reader.getNodeType().equals(new XmlNodeType(XmlNodeType.START_ELEMENT))) {
        String localName = reader.getLocalName();
        if (localName.equals(XmlElementNames.EwsResponseCodeElementName)) {
          try {
            this.setResponseCode(reader.readElementValue(ServiceError.class));
          } catch (Exception e) {
            e.printStackTrace();

            // ServiceError couldn't be mapped to enum value, treat
            // as an ISE
            this.setResponseCode(ServiceError.ErrorInternalServerError);
          }

        } else if (localName.equals(XmlElementNames.EwsMessageElementName)) {
          this.setMessage(reader.readElementValue());
        } else if (localName.equals(XmlElementNames.EwsLineElementName)) {
          this.setLineNumber(reader.readElementValue(Integer.class));
        } else if (localName.equals(XmlElementNames.EwsPositionElementName)) {
          this.setPositionWithinLine(reader.readElementValue(Integer.class));
        } else if (localName.equals(XmlElementNames.EwsErrorCodeElementName)) {
          try {
            this.setErrorCode(reader.readElementValue(ServiceError.class));
          } catch (Exception e) {
            e.printStackTrace();

            // ServiceError couldn't be mapped to enum value, treat
            // as an ISE
            this.setErrorCode(ServiceError.ErrorInternalServerError);
          }

        } else if (localName.equals(XmlElementNames.EwsExceptionTypeElementName)) {
          try {
            this.setExceptionType(reader.readElementValue());
          } catch (Exception e) {
            e.printStackTrace();
            this.setExceptionType(null);
          }
        } else if (localName.equals(XmlElementNames.MessageXml)) {
          this.parseMessageXml(reader);
        }
      }
    } while (!reader.isEndElement(
        XmlNamespace.NotSpecified, XmlElementNames.SOAPDetailElementName));
  }
  /**
   * Parses the.
   *
   * @param reader the reader
   * @param soapNamespace the soap namespace
   * @return the soap fault details
   * @throws Exception the exception
   */
  public static SoapFaultDetails parse(EwsXmlReader reader, XmlNamespace soapNamespace)
      throws Exception {
    SoapFaultDetails soapFaultDetails = new SoapFaultDetails();

    do {
      reader.read();
      if (reader.getNodeType().equals(new XmlNodeType(XmlNodeType.START_ELEMENT))) {
        String localName = reader.getLocalName();
        if (localName.equals(XmlElementNames.SOAPFaultCodeElementName)) {
          soapFaultDetails.setFaultCode(reader.readElementValue());
        } else if (localName.equals(XmlElementNames.SOAPFaultStringElementName)) {
          soapFaultDetails.setFaultString(reader.readElementValue());
        } else if (localName.equals(XmlElementNames.SOAPFaultActorElementName)) {
          soapFaultDetails.setFaultActor(reader.readElementValue());
        } else if (localName.equals(XmlElementNames.SOAPDetailElementName)) {
          soapFaultDetails.parseDetailNode(reader);
        }
      }
    } while (!reader.isEndElement(soapNamespace, XmlElementNames.SOAPFaultElementName));

    return soapFaultDetails;
  }
  /**
   * Executes this instance.
   *
   * @return the autodiscover response
   * @throws ServiceLocalException the service local exception
   * @throws Exception the exception
   */
  protected AutodiscoverResponse internalExecute() throws ServiceLocalException, Exception {
    this.validate();
    HttpWebRequest request = null;
    try {
      request = this.service.prepareHttpWebRequestForUrl(this.url);
      this.service.traceHttpRequestHeaders(TraceFlags.AutodiscoverRequestHttpHeaders, request);

      boolean needSignature =
          this.getService().getCredentials() != null
              && this.getService().getCredentials().isNeedSignature();
      boolean needTrace = this.getService().isTraceEnabledFor(TraceFlags.AutodiscoverRequest);

      OutputStream urlOutStream = request.getOutputStream();
      // OutputStreamWriter out = new OutputStreamWriter(request
      // .getOutputStream());

      ByteArrayOutputStream memoryStream = new ByteArrayOutputStream();
      EwsServiceXmlWriter writer = new EwsServiceXmlWriter(this.getService(), memoryStream);
      writer.setRequireWSSecurityUtilityNamespace(needSignature);
      this.writeSoapRequest(this.url, writer);

      if (needSignature) {
        this.service.getCredentials().sign(memoryStream);
      }

      if (needTrace) {
        memoryStream.flush();
        this.service.traceXml(TraceFlags.AutodiscoverRequest, memoryStream);
      }
      memoryStream.writeTo(urlOutStream);
      urlOutStream.flush();
      urlOutStream.close();
      memoryStream.close();
      // out.write(memoryStream.toString());
      // out.close();
      request.executeRequest();
      request.getResponseCode();
      if (AutodiscoverRequest.isRedirectionResponse(request)) {
        AutodiscoverResponse response = this.createRedirectionResponse(request);
        if (response != null) {
          return response;
        } else {
          throw new ServiceRemoteException("The service returned an invalid redirection response.");
        }
      }

      /*
       * BufferedReader in = new BufferedReader(new
       * InputStreamReader(request.getInputStream()));
       *
       * String decodedString;
       *
       * while ((decodedString = in.readLine()) != null) {
       * System.out.println(decodedString); } in.close();
       */

      memoryStream = new ByteArrayOutputStream();
      InputStream serviceResponseStream = request.getInputStream();

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

      if (this.service.isTraceEnabled()) {
        this.service.traceResponse(request, memoryStream);
      }
      ByteArrayInputStream memoryStreamIn = new ByteArrayInputStream(memoryStream.toByteArray());
      EwsXmlReader ewsXmlReader = new EwsXmlReader(memoryStreamIn);

      // WCF may not generate an XML declaration.
      ewsXmlReader.read();
      if (ewsXmlReader.getNodeType().getNodeType() == XmlNodeType.START_DOCUMENT) {
        ewsXmlReader.readStartElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);
      } else if ((ewsXmlReader.getNodeType().getNodeType() != XmlNodeType.START_ELEMENT)
          || (!ewsXmlReader.getLocalName().equals(XmlElementNames.SOAPEnvelopeElementName))
          || (!ewsXmlReader
              .getNamespaceUri()
              .equals(EwsUtilities.getNamespaceUri(XmlNamespace.Soap)))) {
        throw new ServiceXmlDeserializationException(
            "The Autodiscover service response was invalid.");
      }

      this.readSoapHeaders(ewsXmlReader);

      AutodiscoverResponse response = this.readSoapBody(ewsXmlReader);

      ewsXmlReader.readEndElement(XmlNamespace.Soap, XmlElementNames.SOAPEnvelopeElementName);

      if (response.getErrorCode() == AutodiscoverErrorCode.NoError) {
        return response;
      } else {
        throw new AutodiscoverResponseException(
            response.getErrorCode(), response.getErrorMessage());
      }

    } catch (XMLStreamException ex) {
      this.service.traceMessage(
          TraceFlags.AutodiscoverConfiguration,
          String.format("XML parsing error: %s", ex.getMessage()));

      // Wrap exception
      throw new ServiceRequestException(
          String.format("The request failed. %s", ex.getMessage()), ex);
    } catch (IOException ex) {
      this.service.traceMessage(
          TraceFlags.AutodiscoverConfiguration, String.format("I/O error: %s", ex.getMessage()));

      // Wrap exception
      throw new ServiceRequestException(
          String.format("The request failed. %s", ex.getMessage()), ex);
    } catch (Exception ex) {
      // HttpWebRequest httpWebResponse = (HttpWebRequest)ex;

      if (null != request && request.getResponseCode() == 7) {
        if (AutodiscoverRequest.isRedirectionResponse(request)) {
          this.service.processHttpResponseHeaders(
              TraceFlags.AutodiscoverResponseHttpHeaders, request);

          AutodiscoverResponse response = this.createRedirectionResponse(request);
          if (response != null) {
            return response;
          }
        } else {
          this.processWebException(ex, request);
        }
      }

      // Wrap exception if the above code block didn't throw
      throw new ServiceRequestException(
          String.format("The request failed. %s", ex.getMessage()), ex);
    } finally {
      try {
        if (request != null) {
          request.close();
        }
      } catch (Exception e) {
        // do nothing
      }
    }
  }