/**
 * Parses metadata stored in a Debian Control File-like format.
 *
 * @see <a href="https://cran.r-project.org/doc/manuals/r-release/R-exts.html#The-DESCRIPTION-file">Description File</a>
 */
public static Map<String, String> parseDescriptionFile(final InputStream in) {
  checkNotNull(in);
  try {
    LinkedHashMap<String, String> results = new LinkedHashMap<>();
    InternetHeaders headers = new InternetHeaders(in);
    Enumeration headerEnumeration = headers.getAllHeaders();
    while (headerEnumeration.hasMoreElements()) {
      Header header = (Header) headerEnumeration.nextElement();
      String name = header.getName();
      String value = header.getValue()
          .replace("\r\n", "\n")
          .replace("\r", "\n"); // TODO: "should" be ASCII only, otherwise need to know encoding?
      results.put(name, value); // TODO: Supposedly no duplicates, is this true?
    }
    return results;
  } catch (MessagingException e) {
    throw new RException(null, e);
  }
}
 

@SuppressWarnings( "unchecked")
@PublicAtsApi
public List<PackageHeader> getAllHeaders() throws PackageException {

    try {
        List<PackageHeader> headers = new ArrayList<PackageHeader>();

        Enumeration<Header> messageHeaders = message.getAllHeaders();
        while (messageHeaders.hasMoreElements()) {
            Header messageHeader = messageHeaders.nextElement();
            headers.add(new PackageHeader(messageHeader.getName(), messageHeader.getValue()));
        }

        return headers;

    } catch (MessagingException me) {
        throw new PackageException(me);
    }
}
 

private String addHeadersTrace(
                                Enumeration<?> headers,
                                String level ) {

    final String level1 = level;
    final String level2 = "\t" + level1;
    final String prefix = getPrefixTrace(level1, "HEADERS START: ");

    StringBuilder headersString = new StringBuilder();

    boolean hasHeaders = headers.hasMoreElements();
    if (hasHeaders) {
        headersString.append(level1 + "HEADERS START:\n");
        while (headers.hasMoreElements()) {
            Header header = (Header) headers.nextElement();
            headersString.append(level2 + header.getName() + ": "
                                 + normalizeNewLinesTrace(prefix, header.getValue()) + "\n");
        }
        headersString.append(level1 + "HEADERS END:\n");
    }

    return headersString.toString();
}
 

protected MessageHeaders getHeaders(MimeMessage message) throws MessagingException {

        Map<String, String> headerMap = new HashMap<>();

        // oh wow 2015 and it's untyped and uses Enumeration
        Enumeration allHeaders = message.getAllHeaders();
        while (allHeaders.hasMoreElements()) {
            Header header = (Header) allHeaders.nextElement();
            String headerName = header.getName();
            String headerVal = header.getValue();

            headerMap.put(headerName, headerVal);

        }

        return new MessageHeaders(headerMap);
    }
 

public void validateCustomHeaders(final Email email, final MimeMessage sentMessage)
        throws MessagingException, IOException {
    Map<String, String> customHeaders = email.getCustomHeaders();
    List<Header> internetHeaders = (List<Header>) Collections.list(sentMessage.getAllHeaders());
    List<String> headerKeys = internetHeaders.stream().map(Header::getName).collect(toList());

    assertions.assertThat(headerKeys)
            .as("Should contains all the headers keys provided at construction time")
            .containsAll(customHeaders.keySet());

    customHeaders.entrySet().stream()
            .forEach(entry -> {
                try {
                    assertions.assertThat(sentMessage.getHeader(entry.getKey())).isNotNull().containsExactly(entry.getValue());
                } catch (MessagingException e) {
                }
            });
}
 

public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append("MDN From:").append(getPartnership().getReceiverIDs());
    buf.append("To:").append(getPartnership().getSenderIDs());

    Enumeration<Header> headerEn = getHeaders().getAllHeaders();
    buf.append(System.getProperty("line.separator") + "Headers:{");

    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        buf.append(header.getName()).append("=").append(header.getValue());

        if (headerEn.hasMoreElements()) {
            buf.append(", ");
        }
    }

    buf.append("}");
    buf.append(System.getProperty("line.separator") + "Attributes:").append(getAttributes());
    buf.append(System.getProperty("line.separator") + "Text: " + System.getProperty("line.separator"));
    buf.append(getText()).append(System.getProperty("line.separator"));

    return buf.toString();
}
 

@Override
public Collection<MailAddress> match(Mail mail) throws javax.mail.MessagingException {
    MimeMessage mm = mail.getMessage();
    int count = 0;
    for (Enumeration<Header> e = mm.getAllHeaders(); e.hasMoreElements();) {
        Header hdr = e.nextElement();
        if (hdr.getName().equals(RFC2822Headers.RECEIVED)) {
            count++;
        }
    }
    if (count >= limit) {
        return mail.getRecipients();
    } else {
        return null;
    }
}
 

String getHeaders() throws MessagingException {
    ensureMessage(false);

    StringBuilder sb = new StringBuilder();
    Enumeration<Header> headers = imessage.getAllHeaders();
    while (headers.hasMoreElements()) {
        Header header = headers.nextElement();
        sb.append(header.getName()).append(": ").append(header.getValue()).append("\n");
    }
    return sb.toString();
}
 

@SuppressWarnings("unchecked")
public void persistMessageHeaders(NodeRef messageRef, MimeMessage message)
{
    try
    {
        Enumeration<Header> headers = message.getAllHeaders();
        List<String> messaheHeadersProperties = new ArrayList<String>();
        while(headers.hasMoreElements())
        {
            Header header = headers.nextElement();
            if (isPersistableHeader(header))
            {
                messaheHeadersProperties.add(header.getName() + ImapModel.MESSAGE_HEADER_TO_PERSIST_SPLITTER + header.getValue());
                
                if (logger.isDebugEnabled())
                {
                    logger.debug("[persistHeaders] Persisting Header " + header.getName() + " : " + header.getValue());
                }
            }
        }
        
        Map<QName, Serializable> props = new HashMap<QName, Serializable>();
        props.put(ImapModel.PROP_MESSAGE_HEADERS, (Serializable)messaheHeadersProperties);
        
        serviceRegistry.getNodeService().addAspect(messageRef, ImapModel.ASPECT_IMAP_MESSAGE_HEADERS, props);
    }
    catch(MessagingException me)
    {
        
    }
}
 

private boolean isPersistableHeader(Header header)
{
    for (String headerToPersist : messageHeadersToPersist)
    {
        if (headerToPersist.equalsIgnoreCase(header.getName()))
        {
            return true;
        }
    }
    return false; 
}
 

/**
 * Parses the PKG-INFO content as RFC 822 headers (per PEPs 241 and 314). (Yes, Python PKG-INFO information is
 * essentially stored as a file of email headers.)
 */
@VisibleForTesting
static Map<String, List<String>> parsePackageInfo(final InputStream in) throws Exception {
  checkNotNull(in);
  LinkedHashMap<String, List<String>> results = new LinkedHashMap<>();

  // All package info or metadata file types have their metadata stored in the same manner as email headers
  InternetHeaders headers = new InternetHeaders(in);
  Enumeration<Header> headerEnumeration = headers.getAllHeaders();
  while (headerEnumeration.hasMoreElements()) {
    Header header = headerEnumeration.nextElement();
    String underscoreName = header.getName().toLowerCase().replace('-', '_');
    String name = NAME_SUBSTITUTIONS.getOrDefault(underscoreName, underscoreName);
    String value = convertHeaderValue(header.getValue());
    if (!results.containsKey(name)) {
      results.put(name, new ArrayList<>());
    }
    results.get(name).add(value);
  }

  // Wheel metadata can also be stored in the payload section (description only, so far as I'm aware)
  if (!results.containsKey(PyPiAttributes.P_DESCRIPTION)) {
    String text =  Strings.nullToEmpty(CharStreams.toString(new InputStreamReader(in, StandardCharsets.UTF_8))).trim();
    if (!text.isEmpty()) {
      List<String> description = new ArrayList<>();
      description.add(text.replace("\r\n", "\n").replaceAll("[ ]*\\n[ ]*", "\n") + "\n");
      results.put(PyPiAttributes.P_DESCRIPTION, description);
    }
  }

  return results;
}
 

public String toString() {
    StringBuffer buf = new StringBuffer();
    buf.append("Message From:").append(getPartnership().getSenderIDs());
    buf.append("To:").append(getPartnership().getReceiverIDs());

    Enumeration<Header> headerEn = getHeaders().getAllHeaders();
    buf.append(System.getProperty("line.separator") + "Headers:{");

    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        buf.append(header.getName()).append("=").append(header.getValue());

        if (headerEn.hasMoreElements()) {
            buf.append(", ");
        }
    }

    buf.append("}");
    buf.append(System.getProperty("line.separator") + "Attributes:").append(getAttributes());

    MessageMDN mdn = getMDN();

    if (mdn != null) {
        buf.append(System.getProperty("line.separator") + "MDN:");
        buf.append(mdn.toString());
    }

    return buf.toString();
}
 

public void copyHeaders(InternetHeaders srcHeaders) {
    Enumeration<Header> headerEn = srcHeaders.getAllHeaders();
    while (headerEn.hasMoreElements()) {
        Header header = headerEn.nextElement();
        setHeader(header.getName(), header.getValue());
    }
}
 

private static RequestBuilder getRequestBuilder(String method, URL urlObj, NameValuePair[] params, Enumeration<Header> headers) throws URISyntaxException {

        RequestBuilder req = null;
        if (method == null || method.equalsIgnoreCase(Method.GET)) {
            //default get
            req = RequestBuilder.get();
        } else if (method.equalsIgnoreCase(Method.POST)) {
            req = RequestBuilder.post();
        } else if (method.equalsIgnoreCase(Method.HEAD)) {
            req = RequestBuilder.head();
        } else if (method.equalsIgnoreCase(Method.PUT)) {
            req = RequestBuilder.put();
        } else if (method.equalsIgnoreCase(Method.DELETE)) {
            req = RequestBuilder.delete();
        } else if (method.equalsIgnoreCase(Method.TRACE)) {
            req = RequestBuilder.trace();
        } else {
            throw new IllegalArgumentException("Illegal HTTP Method: " + method);
        }
        req.setUri(urlObj.toURI());
        if (params != null && params.length > 0) {
            req.addParameters(params);
        }
        if (headers != null) {
            boolean removeHeaderFolding = "true".equals(Properties.getProperty(HTTP_PROP_REMOVE_HEADER_FOLDING, "true"));
            while (headers.hasMoreElements()) {
                Header header = headers.nextElement();
                String headerValue = header.getValue();
                if (removeHeaderFolding) {
                    headerValue = headerValue.replaceAll("\r\n[ \t]*", " ");
                }
                req.setHeader(header.getName(), headerValue);
            }
        }
        return req;
    }
 

public static String printHeaders(Enumeration<Header> hdrs, String nameValueSeparator, String valuePairSeparator) {
    String headers = "";
    while (hdrs.hasMoreElements()) {
        Header h = hdrs.nextElement();
        headers = headers + valuePairSeparator + h.getName() + nameValueSeparator + h.getValue();
    }

    return (headers);

}
 

public static String printHeaders(Enumeration<Header> hdrs, String nameValueSeparator, String valuePairSeparator) {
    String headers = "";
    while (hdrs.hasMoreElements()) {
        Header h = hdrs.nextElement();
        headers = headers + valuePairSeparator + h.getName() + nameValueSeparator + h.getValue();
    }

    return (headers);

}
 

@Override
public boolean test(Part input) {
	try {
		// @formatter:off
		return list(input.getMatchingHeaders(new String[] { "Content-ID" }))
				.stream()
				.map(Header::getValue)
				.anyMatch(contentId::equals);
		// @formatter:on
	} catch (MessagingException e) {
		throw new AssertionError("Failed to access message", e);
	}
}
 

private void clearAllHeaders(MimeMessage message) throws javax.mail.MessagingException {
    Enumeration<Header> headers = message.getAllHeaders();

    while (headers.hasMoreElements()) {
        Header header = headers.nextElement();
        try {
            message.removeHeader(header.getName());
        } catch (javax.mail.MessagingException me) {
            LOGGER.error("Cannot remove header.", me);
        }
    }
    message.saveChanges();
}
 

private List<String> headerNamesStartingByPrefix(Mail mail) throws MessagingException {
    ImmutableList.Builder<String> headerToRemove = ImmutableList.builder();
    List<Header> headers = new MimeMessageUtils(mail.getMessage()).toHeaderList();
    for (Header header: headers) {
        if (header.getName().startsWith(prefix)) {
            headerToRemove.add(header.getName());
        }
    }
    return headerToRemove.build();
}
 

public List<Header> toHeaderList() throws MessagingException {
    ImmutableList.Builder<Header> headers = ImmutableList.builder();
    Enumeration<Header> allHeaders = message.getAllHeaders();
    while (allHeaders.hasMoreElements()) {
        headers.add(allHeaders.nextElement());
    }
    return headers.build();
}
 

@Override
public Collection<MailAddress> match(Mail mail) throws MessagingException {
    List<Header> headers = new MimeMessageUtils(mail.getMessage()).toHeaderList();

    for (Header header: headers) {
        if (header.getName().startsWith(prefix)) {
            return mail.getRecipients();
        }
    }

    return matchSpecific(mail);
}
 

private void prependHeader(MimeMessage message, String signatureHeader)
        throws MessagingException {
    List<String> prevHeader = Collections.list(message.getAllHeaderLines());
    Collections.list(message.getAllHeaders())
        .stream()
        .map(Header::getName)
        .forEach(Throwing.consumer(message::removeHeader).sneakyThrow());

    message.addHeaderLine(signatureHeader);
    prevHeader
        .forEach(Throwing.consumer(message::addHeaderLine).sneakyThrow());
}
 

private void copyRelevantHeaders(MimeMessage originalMessage, MimeMessage newMessage) throws MessagingException {
    Enumeration<Header> headerEnum = originalMessage.getMatchingHeaders(
            new String[] { RFC2822Headers.DATE, RFC2822Headers.FROM, RFC2822Headers.REPLY_TO, RFC2822Headers.TO, 
                    RFC2822Headers.SUBJECT, RFC2822Headers.RETURN_PATH });
    while (headerEnum.hasMoreElements()) {
        Header header = headerEnum.nextElement();
        newMessage.addHeader(header.getName(), header.getValue());
    }
}
 

@Override
public List<String> getHeaderNames() throws SieveMailException {
    Set<String> headerNames = new HashSet<>();
    try {
        Enumeration<Header> allHeaders = getMessage().getAllHeaders();
        while (allHeaders.hasMoreElements()) {
            headerNames.add(allHeaders.nextElement().getName());
        }
        return new ArrayList<>(headerNames);
    } catch (MessagingException ex) {
        throw new SieveMailException(ex);
    }
}
 

@VisibleForTesting
void processTextBodyAsAttachment(MimeMessage mimeMessage) throws MessagingException {
    List<Header> contentHeaders = getContentHeadersFromMimeMessage(mimeMessage);

    removeAllContentHeaderFromMimeMessage(mimeMessage, contentHeaders);

    Multipart multipart = new MimeMultipart();
    multipart.addBodyPart(createMimeBodyPartWithContentHeadersFromMimeMessage(mimeMessage, contentHeaders));

    mimeMessage.setContent(multipart);
    mimeMessage.saveChanges();
}
 

private MimeBodyPart createMimeBodyPartWithContentHeadersFromMimeMessage(MimeMessage mimeMessage, List<Header> contentHeaders) throws MessagingException {
    MimeBodyPart fileBody = new MimeBodyPart(mimeMessage.getRawInputStream());
    for (Header header : contentHeaders) {
        fileBody.setHeader(header.getName(), header.getValue());
    }

    fileBody.setDisposition(Part.ATTACHMENT);
    return fileBody;
}
 

private static Optional<ImmutableMap<String, HeadersDto>> fetchPerRecipientsHeaders(Set<AdditionalField> additionalFields, Mail mail) {
    if (!additionalFields.contains(AdditionalField.PER_RECIPIENTS_HEADERS)) {
        return Optional.empty();
    }
    Multimap<MailAddress, PerRecipientHeaders.Header> headersByRecipient = mail
            .getPerRecipientSpecificHeaders()
            .getHeadersByRecipient();

    return Optional.of(headersByRecipient
        .keySet()
        .stream()
        .collect(Guavate.toImmutableMap(MailAddress::asString, (address) -> fetchPerRecipientHeader(headersByRecipient, address))));
}
 

private static HeadersDto fetchPerRecipientHeader(
        Multimap<MailAddress, PerRecipientHeaders.Header> headersByRecipient,
        MailAddress address) {
    return new HeadersDto(headersByRecipient.get(address)
        .stream()
        .collect(Guavate.toImmutableListMultimap(PerRecipientHeaders.Header::getName, PerRecipientHeaders.Header::getValue)));
}
 

@Override
public Enumeration<Header> getAllHeaders() throws MessagingException {
    if (headers == null) {
        loadHeaders();
    }
    return headers.getAllHeaders();
}
 

@Override
public Enumeration<Header> getMatchingHeaders(String[] names) throws MessagingException {
    if (headers == null) {
        loadHeaders();
    }
    return headers.getMatchingHeaders(names);
}