/*
 *  Copyright 2019 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.core.util.mail;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.avalon.framework.activity.Disposable;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.jsoup.select.Selector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.runtime.config.Config;

import jakarta.activation.DataHandler;
import jakarta.mail.Message;
import jakarta.mail.MessagingException;
import jakarta.mail.Multipart;
import jakarta.mail.Part;
import jakarta.mail.Session;
import jakarta.mail.Transport;
import jakarta.mail.internet.InternetAddress;
import jakarta.mail.internet.MimeBodyPart;
import jakarta.mail.internet.MimeMessage;
import jakarta.mail.internet.MimeMultipart;
import jakarta.mail.internet.MimePart;
import jakarta.mail.internet.PreencodedMimeBodyPart;

/**
 * Helper for sending mail
 */
public final class SendMailHelper implements Disposable
{
    /** Regexp to validate an email */
    public static final String EMAIL_VALIDATION_REGEXP = "^.+@.+$"; // No you cannot do better
    /** Regexp to validate an email */
    public static final Pattern EMAIL_VALIDATION = Pattern.compile(EMAIL_VALIDATION_REGEXP);
    
    private static final Logger __LOGGER = LoggerFactory.getLogger(SendMailHelper.class);
    private static final ExecutorService __SINGLE_THREAD_EXECUTOR = Executors.newSingleThreadExecutor(new MailSenderThreadFactory());

    private SendMailHelper ()
    {
        // Nothing
    }

    @Override
    public void dispose()
    {
        __SINGLE_THREAD_EXECUTOR.shutdownNow();
    }
    
    private static class CssRule implements Comparable<CssRule>
    {
        private String _selector;
        private String _properties;
        private CssSpecificity _specificity;
        
        /**
         * CSSRule constructor
         * @param selector css selector
         * @param properties css properties for this rule
         * @param positionIdx The rules declaration index
         */
        public CssRule(String selector, String properties, int positionIdx)
        {
            _selector = selector;
            _properties = properties;
            _specificity = new CssSpecificity(_selector, positionIdx);
        }
        
        /**
         * Selector getter
         * @return the selector
         */
        public String getSelector()
        {
            return _selector;
        }
        
        /**
         * Properties getter
         * @return the properties
         */
        public String getProperties()
        {
            return _properties;
        }
        
        public int compareTo(CssRule r)
        {
            return _specificity.compareTo(r._specificity);
        }
    }
    
    private static class CssSpecificity implements Comparable<CssSpecificity>
    {
        /** Attribute selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_ATTR_PATTERN = Pattern.compile("(\\[[^\\]]+\\])");
        /** ID selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_ID_PATTERN = Pattern.compile("(#[^\\s\\+>~\\.\\[:]+)");
        /** Class selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_CLASS_PATTERN = Pattern.compile("(\\.[^\\s\\+>~\\.\\[:]+)");
        /** Pseudo-element selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_PSEUDO_ELEMENT_PATTERN = Pattern.compile("(::[^\\s\\+>~\\.\\[:]+|:first-line|:first-letter|:before|:after)", Pattern.CASE_INSENSITIVE);
        /** Pseudo-class (with bracket) selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_PSEUDO_CLASS_WITH_BRACKETS_PATTERN = Pattern.compile("(:[\\w-]+\\([^\\)]*\\))", Pattern.CASE_INSENSITIVE);
        /** Pseudo-class selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_PSEUDO_CLASS_PATTERN = Pattern.compile("(:[^\\s\\+>~\\.\\[:]+)");
        /** Element selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_ELEMENT_PATTERN = Pattern.compile("([^\\s\\+>~\\.\\[:]+)");
        
        /** Specific :not pseudo-class selectors pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_PSEUDO_CLASS_NOT_PATTERN = Pattern.compile(":not\\(([^\\)]*)\\)");
        /** Universal and separator characters pattern for CSS specificity processing */
        private static final Pattern __CSS_SPECIFICITY_UNIVERSAL_AND_SEPARATOR_PATTERN = Pattern.compile("[\\*\\s\\+>~]");

        
        private int[] _weights;
        
        public CssSpecificity(String selector, int positionIdx)
        {
            // Position index is used to differentiate equality cases
            // -> latest declaration should be the one applied
            _weights = new int[]{0, 0, 0, 0, positionIdx};
            
            String input = selector;
            
            // This part is loosely based on https://github.com/keeganstreet/specificity
            
            // Remove :not pseudo-class but leave its argument
            input = __CSS_SPECIFICITY_PSEUDO_CLASS_NOT_PATTERN.matcher(input).replaceAll(" $1 ");
            
            // The following regular expressions assume that selectors matching the preceding regular expressions have been removed
            input = _countReplaceAll(__CSS_SPECIFICITY_ATTR_PATTERN, input, 2);
            input = _countReplaceAll(__CSS_SPECIFICITY_ID_PATTERN, input, 1);
            input = _countReplaceAll(__CSS_SPECIFICITY_CLASS_PATTERN, input, 2);
            input = _countReplaceAll(__CSS_SPECIFICITY_PSEUDO_ELEMENT_PATTERN, input, 3);
            // A regex for pseudo classes with brackets - :nth-child(), :nth-last-child(), :nth-of-type(), :nth-last-type(), :lang()
            input = _countReplaceAll(__CSS_SPECIFICITY_PSEUDO_CLASS_WITH_BRACKETS_PATTERN, input, 2);
            // A regex for other pseudo classes, which don't have brackets
            input = _countReplaceAll(__CSS_SPECIFICITY_PSEUDO_CLASS_PATTERN, input, 2);
            
            // Remove universal selector and separator characters
            input = __CSS_SPECIFICITY_UNIVERSAL_AND_SEPARATOR_PATTERN.matcher(input).replaceAll(" ");
            
            _countReplaceAll(__CSS_SPECIFICITY_ELEMENT_PATTERN, input, 3);
        }
        
        private String _countReplaceAll(Pattern pattern, String selector, int sIndex)
        {
            Matcher m = pattern.matcher(selector);
            StringBuffer sb = new StringBuffer();
            
            while (m.find())
            {
                // Increment desired weight counter
                _weights[sIndex]++;
                
                // Replace matched selector part with whitespace
                m.appendReplacement(sb, " ");
            }
            
            m.appendTail(sb);
            
            return sb.toString();
        }
        
        public int compareTo(CssSpecificity o)
        {
            for (int i = 0; i < _weights.length; i++)
            {
                if (_weights[i] != o._weights[i])
                {
                    return _weights[i] - o._weights[i];
                }
            }
            
            return 0;
        }
    }
    
    /**
     * Creates a new mail builder.
     * @return the newly created {@link MailBuilder}.
     */
    public static MailBuilder newMail()
    {
        return new MailBuilder(__LOGGER, __SINGLE_THREAD_EXECUTOR);
    }
    
    /*
     * This method inline css in &lt;style&gt; tags directly in the appropriates tags. e.g. : &lt;style&gt;h1 {color: red;}&lt;/style&gt; &lt;h1&gt;a&lt;/h1&gt; becomes &lt;h1 style="color: red"&gt;a&lt;/h1&gt;
     */
    public static String inlineCSS(String html)
    {
        List<CssRule> rules = new LinkedList<>();
        
        Document doc = Jsoup.parse(html); 
        Elements els = doc.select("style");

        for (Element e : els) 
        { 
            String styleRules = e.getAllElements().get(0).data();
            styleRules = styleRules.replaceAll("\t|\r|\n", "").replaceAll("<!--", "").replaceAll("-->", "");

            styleRules = _removeComments(styleRules);

            styleRules = styleRules.trim();

            StringTokenizer st = new StringTokenizer(styleRules, "{}"); 
            while (st.countTokens() > 1) 
            { 
                String selectors = st.nextToken();
                String properties = st.nextToken();

                String[] selector = selectors.split(",");
                for (String s : selector)
                {
                    if (StringUtils.isNotBlank(s))
                    {
                        rules.add(new CssRule(s.trim(), properties, rules.size()));
                    }
                }
            } 
            e.remove(); 
        }
        
        // Sort rules by specificity
        Collections.sort(rules, Collections.reverseOrder());
    
        for (CssRule rule : rules)
        {
            try
            {
                Elements selectedElements = doc.select(rule.getSelector());
                for (Element selElem : selectedElements)
                {
                    String oldProperties = selElem.attr("style");
                    selElem.attr("style", oldProperties.length() > 0 ? concatenateProperties(oldProperties, rule.getProperties()) : rule.getProperties());
                }
            }
            catch (Selector.SelectorParseException ex)
            {
                __LOGGER.error("Cannot inline CSS with rule \"" + rule.getSelector() + "\".Ignoring this rule and continuing.", ex);
            }
        }
        
        return doc.toString();
    }

    private static String _removeComments(String styleRules)
    {
        int i = styleRules.indexOf("/*");
        int j = styleRules.indexOf("*/");
        
        if (i >= 0 && j > i)
        {
            return styleRules.substring(0, i) + _removeComments(styleRules.substring(j + 2));
        }
        
        return styleRules;
    }
    
    private static String concatenateProperties(String oldProp, String newProp) 
    { 
        String between = "";
        if (!newProp.endsWith(";"))
        {
            between += ";";
        }
        
        return newProp + between + oldProp.trim(); // The existing (old) properties should take precedence. 
    } 
    
    /**
     * Implements the builder pattern for creating and sending emails.
     */
    public static class MailBuilder
    {
        private Logger _logger;
        private ExecutorService _executor;
        
        private boolean _async;

        private String _subject;
        private String _htmlBody;
        private String _textBody;
        private Collection<File> _attachments;
        private Collection<NamedStream> _streamAttachments;
        private List<String> _recipients;
        private String _sender;
        private List<String> _cc;
        private List<String> _bcc;
        private boolean _deliveryReceipt;
        private boolean _readReceipt;
        private String _host;
        private long _port = -1;
        private String _securityProtocol;
        private String _user;
        private String _password;
        private boolean _singleEmail;
        private List<String> _errorReport;
        private boolean _inlineCSS = true;
        private boolean _embedBase64Resources = true;
        private Map<String, Pair<String, String>> _embeddedResource;
        
        
        MailBuilder(Logger logger, ExecutorService executor)
        {
            _logger = logger;
            _executor = executor;
        }
        
        /**
         * If the mail should be sent asynchronously or not.
         * @param async the asynchronous flag
         * @return this builder
         */
        public MailBuilder withAsync(boolean async)
        {
            _async = async;
            return this;
        }
        
        /**
         * Set the mail subject. This parameter is mandatory.
         * @param subject the mail subject
         * @return this builder
         */
        public MailBuilder withSubject(String subject)
        {
            _subject = subject;
            return this;
        }
        
        /**
         * Set the optional HTML body. May be null.
         * @param htmlBody the HTML mail body
         * @return this builder
         */
        public MailBuilder withHTMLBody(String htmlBody)
        {
            _htmlBody = htmlBody;
            return this;
        }
        
        /**
         * Set the optional HTML body. May be null.
         * @param htmlBody the HTML mail body
         * @param embeddedResource a map representing the resource related to the htmlBody. can be null.
         * the map map is composed of the resource URI identified by the content ID used in the html body
         * @return this builder
         */
        public MailBuilder withHTMLBody(String htmlBody, Map<String, Pair<String, String>> embeddedResource)
        {
            _htmlBody = htmlBody;
            _embeddedResource = embeddedResource;
            return this;
        }
        
        /**
         * Set the optional text body. May be null.
         * @param textBody the text mail body
         * @return this builder
         */
        public MailBuilder withTextBody(String textBody)
        {
            _textBody = textBody;
            return this;
        }
        
        /**
         * Set the optional attachments. May be null.
         * @param attachments the file attachments
         * @return this builder
         */
        public MailBuilder withAttachments(Collection<File> attachments)
        {
            _attachments = attachments;
            return this;
        }
        
        /**
         * Set the optional attachments. May be null.
         * @param attachments the input stream attachments
         * @return this builder
         */
        public MailBuilder withAttachmentsAsStream(Collection<NamedStream> attachments)
        {
            _streamAttachments = attachments;
            return this;
        }
        
        /**
         * Set the mail recipient
         * @param recipient the recipient address
         * @return this builder
         */
        public MailBuilder withRecipient(String recipient)
        {
            _recipients = List.of(recipient);
            return this;
        }
        
        /**
         * Set the mail recipients
         * @param recipients the recipients addresses
         * @return this builder
         */
        public MailBuilder withRecipients(List<String> recipients)
        {
            _recipients = recipients;
            return this;
        }
        
        /**
         * Set the mail sender.
         * @param sender the mail sender
         * @return this builder
         */
        public MailBuilder withSender(String sender)
        {
            _sender = sender;
            return this;
        }
        
        /**
         * Set the carbon copy address list. May be null.
         * @param cc the cc address list
         * @return this builder
         */
        public MailBuilder withCc(List<String> cc)
        {
            _cc = cc;
            return this;
        }
        
        /**
         * Set the blind carbon copy address list. May be null.
         * @param bcc the bcc address list
         * @return this builder
         */
        public MailBuilder withBcc(List<String> bcc)
        {
            _bcc = bcc;
            return this;
        }
        
        /**
         * Set to true to get a delivery receipt
         * @param deliveryReceipt the delivery receipt flag
         * @return this builder
         */
        public MailBuilder withDeliveryReceipt(boolean deliveryReceipt)
        {
            _deliveryReceipt = deliveryReceipt;
            return this;
        }
        
        /**
         * Set to true to get a read receipt
         * @param readReceipt the read receipt flag
         * @return this builder
         */
        public MailBuilder withReadReceipt(boolean readReceipt)
        {
            _readReceipt = readReceipt;
            return this;
        }
        
        /**
         * Set the SMTP host. Defaults to the value provided in the general configuration.
         * @param host the SMTP host
         * @return this builder
         */
        public MailBuilder withHost(String host)
        {
            _host = host;
            return this;
        }
        
        /**
         * Set the SMTP port. Defaults to the value provided in the general configuration.
         * @param port the SMTP port
         * @return this builder
         */
        public MailBuilder withPort(long port)
        {
            _port = port;
            return this;
        }
        
        /**
         * Set the security protocol ("starttls", "tlsssl"). May be null.
         * @param securityProtocol the security protocol
         * @return this builder
         */
        public MailBuilder withSecurityProtocol(String securityProtocol)
        {
            _securityProtocol = securityProtocol;
            return this;
        }
        
        /**
         * Set the SMTP user. Defaults to the value provided in the general configuration.
         * @param user the SMTP user
         * @return this builder
         */
        public MailBuilder withUser(String user)
        {
            _user = user;
            return this;
        }
        
        /**
         * Set the SMTP password. Defaults to the value provided in the general configuration.
         * @param password the STMP password
         * @return this builder
         */
        public MailBuilder withPassword(String password)
        {
            _password = password;
            return this;
        }
        
        /**
         * Set to true if a single email with all recipients should be sent. Defaults to false. 
         * @param singleEmail the single email flag
         * @return this builder
         */
        public MailBuilder withSingleEmail(boolean singleEmail)
        {
            _singleEmail = singleEmail;
            return this;
        }
        
        /**
         * Set a list to get the send error report. The list will be populated with each recipient which the send failed.
         * @param errorReport teh error report list to fill
         * @return this builder
         */
        public MailBuilder withErrorReport(List<String> errorReport)
        {
            _errorReport = errorReport;
            return this;
        }
        
        /**
         * Set to true to inline CSS rules. 
         * <br>Set to false to preserve provided HTML code as is.
         * <br>Default to true for legacy purposes.
         * @param inlineCSS the inlining CSS flag
         * @return this builder
         */
        public MailBuilder withInlineCSS(boolean inlineCSS)
        {
            _inlineCSS = inlineCSS;
            return this;
        }
        
        /**
         * Set to true to embed base64 resources as attachment. 
         * <br>Set to false to preserve provided HTML code as is.
         * <br>Default to true.
         * @param embedBase64Resources the embedding flag
         * @return this builder
         */
        public MailBuilder withEmbeddedBase64Resources(boolean embedBase64Resources)
        {
            _embedBase64Resources = embedBase64Resources;
            return this;
        }
        
        /**
         * Actually send mail.
         * @throws MessagingException If an error occurred while preparing or sending email
         * @throws IOException if an error occurs while attaching a file.
         */
        public void sendMail() throws MessagingException, IOException
        {
            Optional<Config> config = Optional.ofNullable(Config.getInstance());
            
            MailSender mailSender = new MailSender(_logger, 
                                                   _subject, 
                                                   _textBody, 
                                                   _prepareHTMLBody(_htmlBody), 
                                                   _embeddedResource, 
                                                   _attachments,
                                                   _streamAttachments,
                                                   _recipients, 
                                                   StringUtils.defaultIfEmpty(_sender, config.map(c -> c.<String>getValue("smtp.mail.from")).orElse(null)), 
                                                   _cc, 
                                                   _bcc, 
                                                   _deliveryReceipt, 
                                                   _readReceipt, 
                                                   StringUtils.defaultIfEmpty(_host, config.map(c -> c.<String>getValue("smtp.mail.host")).orElse(null)), 
                                                   _port > 0 ? _port : config.map(c -> c.<Long>getValue("smtp.mail.port")).orElse(0L), 
                                                   StringUtils.defaultIfEmpty(_securityProtocol, config.map(c -> c.<String>getValue("smtp.mail.security.protocol")).orElse(null)), 
                                                   StringUtils.defaultIfEmpty(_user, config.map(c -> c.<String>getValue("smtp.mail.user")).orElse(null)), 
                                                   StringUtils.defaultIfEmpty(_password, config.map(c -> c.<String>getValue("smtp.mail.password")).orElse(null)), _singleEmail, _errorReport);
            
            if (!_async)
            {
                mailSender.sendMail();
            }
            else
            {
                _executor.execute(mailSender);
            }
        }

        private String _prepareHTMLBody(String htmlBody)
        {
            String result = htmlBody;
            if (result != null)
            {
                if (_inlineCSS)
                {
                    result = inlineCSS(result);
                }
                
                if (_embedBase64Resources)
                {
                    result = _embedBase64Resources(result);
                }
            }
            return result;
        }
        
        private String _embedBase64Resources(String html)
        {
            // parse the html to retrieve all base64 resources
            // remove it from the html
            // replace it with a cid
            // add the base64 resource to the embeddedResource with it's cid
            
            Pattern pattern = Pattern.compile("\"data:(\\w+/\\w+);base64,(\\S*)\"");
            Matcher matcher = pattern.matcher(html);
            
            if (_embeddedResource == null)
            {
                _embeddedResource = new HashMap<>();
            }
            
            return matcher.replaceAll(match ->
            {
                String mimeType = match.group(1);
                String base64Resource = match.group(2);
                String hashCode = Integer.toString(base64Resource.hashCode());
                _embeddedResource.putIfAbsent(hashCode, Pair.of(mimeType, base64Resource));
                return "\"cid:" + hashCode + "\"";
            });
        }
    }
    
    /**
     * A record representing a stream with name and mime type
     *
     * @param inputStream the input stream
     * @param name the name
     * @param mimeType the mime type
     */
    public record NamedStream(InputStream inputStream, String name, String mimeType) { /* */ }
    
    private static class MailSender implements Runnable
    {
        private String _subject;
        private String _textBody;
        private String _htmlBody;
        private Map<String, Pair<String, String>> _embeddedAttachments;
        private Collection<File> _attachments;
        private Collection<NamedStream> _streamAttachments;
        private List<String> _recipients;
        private String _sender;
        private List<String> _cc;
        private List<String> _bcc;
        private boolean _deliveryReceipt;
        private boolean _readReceipt;
        private String _host;
        private long _port;
        private String _securityProtocol;
        private String _user;
        private String _password;
        private boolean _singleEmail;
        private List<String> _errorReport;
        private Logger _logger;

        /**
         * Initialize the mail sender with email parameters
         * @param logger The logger
         * @param subject The mail subject
         * @param textBody The text mail body. Can be null.
         * @param htmlBody The HTML mail body. Can be null.
         * @param embeddedResources a map representing the resources to embed. the key is the content id. the value is a pair of the mimeType and the base64 resource.
         * @param attachments the file attachments. Can be null.
         * @param streamAttachments the stream attachments. Can be null.
         * @param recipients The recipients addresses
         * @param sender The sender address. Can be null when called by MailChecker.
         * @param cc Carbon copy address list. Can be null.
         * @param bcc Blind carbon copy address list. Can be null.
         * @param deliveryReceipt true to request that the receiving mail server send a notification when the mail is received.
         * @param readReceipt true to request that the receiving mail client send a notification when the person opens the mail.
         * @param host The server mail host. Can be null when called by MailChecker.
         * @param port The server port
         * @param securityProtocol the security protocol to use when transporting the email
         * @param user The user name
         * @param password The user password
         * @param singleEmail true if just one email is sent with all recipients. Otherwise, an email will be sent for each recipients.
         * @param errorReport The error report list to get the recipients that failed. Can be null.
         */
        public MailSender(Logger logger, String subject, String textBody, String htmlBody, Map<String, Pair<String, String>> embeddedResources, Collection<File> attachments, Collection<NamedStream> streamAttachments, List<String> recipients, String sender, List<String> cc, List<String> bcc, boolean deliveryReceipt, boolean readReceipt, String host, long port, String securityProtocol, String user, String password, boolean singleEmail, List<String> errorReport)
        {
            _logger = logger;
            _subject = subject;
            _textBody = textBody;
            _htmlBody = htmlBody;
            _embeddedAttachments = embeddedResources;
            _attachments = attachments;
            _streamAttachments = streamAttachments;
            _recipients = recipients;
            _sender = sender;
            _cc = cc;
            _bcc = bcc;
            _deliveryReceipt = deliveryReceipt;
            _readReceipt = readReceipt;
            _host = host;
            _port = port;
            _securityProtocol = securityProtocol;
            _user = user;
            _password = password;
            _singleEmail = singleEmail;
            _errorReport = errorReport;
        }
        
        public void run()
        {
            try
            {
                sendMail();
            }
            catch (Exception e)
            {
                _logger.error("Unable to send mail with subject: {}", _subject, e);
            }
        }
        
        public void sendMail() throws MessagingException, IOException
        {
            List<InputStreamDataSource> dataSources = new ArrayList<>();
            try
            {
                Properties props = new Properties();
    
                // Setup mail server
                props.put("mail.smtp.host", _host);
                props.put("mail.smtp.port", _port);
                
                // Security protocol
                if (_securityProtocol.equals("starttls"))
                {
                    props.put("mail.smtp.starttls.enable", "true"); 
                }
                else if (_securityProtocol.equals("tlsssl"))
                {
                    props.put("mail.smtp.ssl.enable", "true");
                }
                
                Session session = Session.getInstance(props, null);
                
                // Define message
                MimeMessage message = new MimeMessage(session);
                
                if (_sender != null)
                {
                    message.setFrom(new InternetAddress(_sender));
                }
                
                message.setSentDate(new Date());
                message.setSubject(_subject, "UTF-8");
                
                if (_attachments == null && _streamAttachments == null)
                {
                    _setBodyPart(message);
                }
                else
                {
                    Multipart multipart = new MimeMultipart("mixed");
                    
                    MimeBodyPart bodyPart = new MimeBodyPart();
                    _setBodyPart(bodyPart);
                    multipart.addBodyPart(bodyPart);
                    
                    if (_attachments != null)
                    {
                        for (File attachment : _attachments)
                        {
                            MimeBodyPart fileBodyPart = new MimeBodyPart();
                            fileBodyPart.attachFile(attachment);
                            multipart.addBodyPart(fileBodyPart);
                        }
                    }
                    
                    if (_streamAttachments != null)
                    {
                        for (NamedStream attachment : _streamAttachments)
                        {
                            MimeBodyPart fileBodyPart = new MimeBodyPart();
                            InputStreamDataSource fds = new InputStreamDataSource(attachment);
                            dataSources.add(fds);
                            fileBodyPart.setDataHandler(new DataHandler(fds));
                            fileBodyPart.setFileName(attachment.name());
                            fileBodyPart.setDisposition(Part.ATTACHMENT);
                            multipart.addBodyPart(fileBodyPart);
                        }
                    }
                    
                    message.setContent(multipart);
                }
    
                // Carbon copies
                if (_cc != null)
                {
                    message.setRecipients(Message.RecipientType.CC, InternetAddress.parse(StringUtils.join(_cc, ','), false));
                }
    
                // Blind carbon copies
                if (_bcc != null)
                {
                    message.setRecipients(Message.RecipientType.BCC, InternetAddress.parse(StringUtils.join(_bcc, ','), false));
                }
                
                // Delivery receipt : Return-Receipt-To
                if (_deliveryReceipt)
                {
                    message.setHeader("Return-Receipt-To", _sender);
                }
                
                // Read receipt : Disposition-Notification-To
                if (_readReceipt)
                {
                    message.setHeader("Disposition-Notification-To", _sender);
                }
                
                try (Transport tr = session.getTransport("smtp"))
                {
                    tr.connect(_host, (int) _port, StringUtils.trimToNull(_user), StringUtils.trimToNull(_password));
                    
                    _sendMail(message, tr);
                }
            }
            finally
            {
                for (InputStreamDataSource dataSource : dataSources)
                {
                    dataSource.dispose();
                }
            }
        }
        
        private void _setBodyPart(MimePart part) throws MessagingException
        {
            if (_textBody != null && _htmlBody != null)
            {
                Multipart bodyMultipart = new MimeMultipart("alternative");
                
                MimeBodyPart textPart = new MimeBodyPart();
                bodyMultipart.addBodyPart(textPart);
                _setTextBody(textPart);
                
                MimeBodyPart htmlPart = new MimeBodyPart();
                bodyMultipart.addBodyPart(htmlPart);
                _setHTMLBody(htmlPart);
                
                part.setContent(bodyMultipart);
            }
            else if (_textBody != null)
            {
                _setTextBody(part);
            }
            else if (_htmlBody != null)
            {
                _setHTMLBody(part);
            }
        }
        
        private void _setTextBody(MimePart part) throws MessagingException
        {
            part.setText(_textBody, "UTF-8");
        }
        
        private void _setHTMLBody(MimePart part) throws MessagingException
        {
            if (_embeddedAttachments != null && _embeddedAttachments.size() > 0)
            {
                // create a new multipart related to store the html and the attachments
                MimeMultipart relatedMultipart = new MimeMultipart("related");
                part.setContent(relatedMultipart);
                
                MimeBodyPart htmlPart = new MimeBodyPart();
                
                relatedMultipart.addBodyPart(htmlPart);
                htmlPart.setText(_htmlBody, "UTF-8", "html");
                
                for (Entry<String, Pair<String, String>> entry : _embeddedAttachments.entrySet())
                {
                    MimeBodyPart entryPart = new PreencodedMimeBodyPart("base64");
                    // < and > for Gmail support
                    entryPart.setContentID("<" + entry.getKey() + ">");
                    entryPart.setDisposition(Part.INLINE);
                    entryPart.setFileName(entry.getKey());
                    entryPart.setContent(entry.getValue().getRight(), entry.getValue().getLeft());
                    
                    relatedMultipart.addBodyPart(entryPart);
                }
            }
            else
            {
                part.setText(_htmlBody, "UTF-8", "html");
            }
        }
        
        private void _sendMail(MimeMessage message, Transport tr) throws MessagingException
        {
            if (_recipients != null && _recipients.size() > 0 && _sender != null)
            {
                if (_singleEmail)
                {
                    // Send one mail to multiple recipients
                    message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(StringUtils.join(_recipients, ','), false));
                    message.saveChanges();
                    
                    tr.sendMessage(message, message.getAllRecipients());
                }
                else
                {
                    // Send mail for each recipients
                    for (String recipient : _recipients)
                    {
                        try
                        {
                            message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(recipient, false));
                            message.saveChanges();
                            tr.sendMessage(message, message.getAllRecipients());
                        }
                        catch (Exception e) 
                        {
                            if (_errorReport != null)
                            {
                                _errorReport.add(recipient);
                            }
                            _logger.error("Can't send mail with subject \"{}\" to the address {}", _subject, recipient, e);
                        }
                    }
                }
            }
        }
    }
    
    private static class MailSenderThreadFactory implements ThreadFactory
    {
        private ThreadFactory _defaultThreadFactory;

        public MailSenderThreadFactory()
        {
            _defaultThreadFactory = Executors.defaultThreadFactory();
        }
        
        public Thread newThread(Runnable r)
        {
            Thread thread = _defaultThreadFactory.newThread(r);
            thread.setName("mail-sender-thread");
            thread.setDaemon(true);
            
            return thread;
        }
    }
}