/*
 *  Copyright 2010 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.cms.alerts;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.mail.MessagingException;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.Constants;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.util.log.SLF4JLoggerAdapter;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.cms.content.archive.ArchiveConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ContentQueryHelper;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowStepExpression;
import org.ametys.cms.repository.WorkflowStepExpression.LogicalOperator;
import org.ametys.core.engine.BackgroundEngineHelper;
import org.ametys.core.right.RightManager;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.query.expression.AndExpression;
import org.ametys.plugins.repository.query.expression.BooleanExpression;
import org.ametys.plugins.repository.query.expression.DateExpression;
import org.ametys.plugins.repository.query.expression.Expression;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.MetadataExpression;
import org.ametys.plugins.repository.query.expression.NotExpression;
import org.ametys.plugins.repository.query.expression.OrExpression;
import org.ametys.plugins.repository.version.MetadataAndVersionAwareAmetysObject;
import org.ametys.plugins.repository.version.ModifiableMetadataAwareVersionableAmetysObject;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;

/**
 * Alerts engine: sends alerts mail.
 */
public class AlertEngine implements Runnable
{
    
    /** The logger. */
    protected static final Logger _LOGGER = LoggerFactory.getLogger(AlertEngine.class);
    
    /** The avalon context. */
    protected Context _context;
    
    /** The service manager. */
    protected ServiceManager _manager;
    
    /** The server base URL. */
    protected String _baseUrl;
    
    /** Is the engine initialized ? */
    protected boolean _initialized;
    
    /** The cocoon environment context. */
    protected org.apache.cocoon.environment.Context _environmentContext;
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _ametysResolver;
    
    /** The rights manager. */
    protected RightManager _rightManager;
    
    /** The users manager. */
    protected UserManager _userManager;
    
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;
    
    /** The content of "from" field in emails. */
    protected String _mailFrom;
    
    /** The "waiting for validation" e-mail will be sent to users that have at least one of this rights. */
    protected Set<String> _awaitingValidationRights;
    
    /** The "waiting for validation" e-mail subject i18n key. */
    protected String _awaitingValidationSubject;
    
    /** The "waiting for validation" e-mail body i18n key. */
    protected String _awaitingValidationBody;
    
    /** Only contents in this steps will be taken into account for the "unmodified content" alert. */
    protected int[] _unmodifiedContentStepIds;
    
    /** The "unmodified content" e-mail will be sent to users that have at least one of this rights. */
    protected Set<String> _unmodifiedContentRights;
    
    /** The "unmodified content" e-mail subject i18n key. */
    protected String _unmodifiedContentSubject;
    
    /** The "unmodified content" e-mail body i18n key. */
    protected String _unmodifiedContentBody;
    
    /** The reminder e-mail will be sent to users that have this at least one of this rights. */
    protected Set<String> _reminderRights;
    
    /** The reminder e-mail subject i18n key. */
    protected String _reminderSubject;
    
    /** The reminder e-mail body i18n key. */
    protected String _reminderBody;
    
    /** The scheduled archiving reminder e-mail will be sent to users that have this at least one of this rights. */
    protected Set<String> _scheduledArchivingReminderRights;
    
    /** The scheduled archiving reminder e-mail subject i18n key. */
    protected String _scheduledArchivingReminderSubject;
    
    /** The scheduled archiving reminder e-mail body i18n key. */
    protected String _scheduledArchivingReminderBody;
   
    /** The instant alert e-mail will be sent to users that have this at least one of this rights. */
    protected Set<String> _instantAlertRights;
    /** The instant alert e-mail subject i18n key. */
    protected String _instantAlertSubject;
    /** The instant alert e-mail body i18n key. */
    protected String _instantAlertBody;
    
    /** True if the engine was been run in instant mode (for instant alerts only) **/
    protected boolean _instantMode;
    /** The list of contents' id (for instant alerts only) **/
    private List<String> _instantAlertContentIds;
    /** The email message (for instant alerts only) **/
    private String _instantAlertMessage;
    
    /**
     * Default constructor
     */
    public AlertEngine ()
    {
        _instantMode = false;
    }
    
    /**
     * Constructor used to send instant alerts
     * @param contentIds The content's id
     * @param message the message
     */
    public AlertEngine (List<String> contentIds, String message)
    {
        _instantMode = true;
        _instantAlertContentIds = contentIds;
        _instantAlertMessage = message;
    }
    
    /**
     * Initialize the alert engine.
     * @param manager the avalon service manager.
     * @param context the avalon context.
     * @throws ContextException if the CONTEXT_ENVIRONMENT_CONTEXT cannot be found
     * @throws ServiceException if some components cannot be resolved
     */
    public void initialize(ServiceManager manager, Context context) throws ContextException, ServiceException
    {
        _manager = manager;
        _context = context;
        _environmentContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
        
        // Lookup the needed components.
        _ametysResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        
        _baseUrl = StringUtils.stripEnd(StringUtils.removeEndIgnoreCase(Config.getInstance().getValue("cms.url"), "index.html"), "/");
        _mailFrom = Config.getInstance().getValue("smtp.mail.from");
        
        _initialized = true;
    }
    
    /**
     * Configure the engine (called by the scheduler).
     * @param configuration the component configuration.
     * @throws ConfigurationException if the configuration is not valid
     */
    public void configure(Configuration configuration) throws ConfigurationException
    {
        Configuration instantConf = configuration.getChild("instantAlert");
        Configuration validationConf = configuration.getChild("awaitingValidation");
        Configuration unmodifiedConf = configuration.getChild("unmodifiedContent");
        Configuration reminderConf = configuration.getChild("reminder");
        Configuration scheduledArchivingReminderConf = configuration.getChild("scheduledArchiving");
        
        // Configure the rights.
        _instantAlertRights = _getRightsFromConf(instantConf);
        _awaitingValidationRights = _getRightsFromConf(validationConf);
        _unmodifiedContentRights = _getRightsFromConf(unmodifiedConf);
        _reminderRights = _getRightsFromConf(reminderConf);
        _scheduledArchivingReminderRights = _getRightsFromConf(scheduledArchivingReminderConf);
        Configuration[] stepIds = unmodifiedConf.getChildren("stepId");
        _unmodifiedContentStepIds = new int[stepIds.length];
        int i = 0;
        for (Configuration stepId : stepIds)
        {
            try
            {
                _unmodifiedContentStepIds[i] = Integer.parseInt(stepId.getValue(""));
                i++;
            }
            catch (NumberFormatException e)
            {
                // Ignore
            }
        }
        
        // Configure the i18n texts.
        _awaitingValidationSubject = validationConf.getChild("subjectKey").getValue();
        _awaitingValidationBody = validationConf.getChild("bodyKey").getValue();
        _unmodifiedContentSubject = unmodifiedConf.getChild("subjectKey").getValue();
        _unmodifiedContentBody = unmodifiedConf.getChild("bodyKey").getValue();
        _reminderSubject = reminderConf.getChild("subjectKey").getValue();
        _reminderBody = reminderConf.getChild("bodyKey").getValue();
        _scheduledArchivingReminderSubject = scheduledArchivingReminderConf.getChild("subjectKey").getValue();
        _scheduledArchivingReminderBody = scheduledArchivingReminderConf.getChild("bodyKey").getValue();
        _instantAlertSubject = instantConf.getChild("subjectKey").getValue();
        _instantAlertBody = instantConf.getChild("bodyKey").getValue();
    }
    
    /**
     * Check the initialization and throw an exception if not initialized.
     */
    protected void _checkInitialization()
    {
        if (!_initialized)
        {
            String message = "Le composant de synchronisation doit être initialisé avant d'être lancé.";
            _LOGGER.error(message);
            throw new IllegalStateException(message);
        }
    }
    
    @Override
    public void run()
    {
        Map<String, Object> environmentInformation = null;
        try
        {
            _LOGGER.info("Preparing to send the alerts...");
            
            _checkInitialization();
            
            // Create the environment.
            environmentInformation = BackgroundEngineHelper.createAndEnterEngineEnvironment(_manager, _environmentContext, new SLF4JLoggerAdapter(_LOGGER));
            
            // Prepare and send all the alerts.
            _sendAlerts();
        }
        catch (Exception e)
        {
            _LOGGER.error("An error occurred sending the alerts.", e);
        }
        finally
        {
            // Leave the environment.
            if (environmentInformation != null)
            {
                BackgroundEngineHelper.leaveEngineEnvironment(environmentInformation);
            }
            // Dispose of the resources.
            _dispose();
            _LOGGER.info("Alerts sent.");
        }
    }
    
    /**
     * Set the necessary request attributes
     * @param content The content
     */
    protected void _setRequestAttributes (Content content)
    {
        Request request = ContextHelper.getRequest(_context);
        
        List<String> populationContexts = new ArrayList<>();
        populationContexts.add("/application");
        
        request.setAttribute(PopulationContextHelper.POPULATION_CONTEXTS_REQUEST_ATTR, populationContexts);
    }
    
    /**
     * Dispose of the resources and looked-up components.
     */
    protected void _dispose()
    {
        // Release the components.
        if (_manager != null)
        {
            _manager.release(_ametysResolver);
            _manager.release(_rightManager);
            _manager.release(_userManager);
        }
        
        _ametysResolver = null;
        _rightManager = null;
        _userManager = null;
        
        _environmentContext = null;
        _context = null;
        _manager = null;
        
        _initialized = false;
    }
    
    /**
     * Send all the alerts. Can be overridden to add alerts.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendAlerts() throws AmetysRepositoryException
    {
        if (_instantMode)
        {
            _sendInstantAlerts();
        }
        else
        {
            _sendAwaitingValidationAlerts();
            _sendUnmodifiedAlerts();
            _sendReminders();
            _sendScheduledArchivingReminders();
        }
    }
    
    /**
     * Send instant alerts on contents
     * @throws AmetysRepositoryException if an error occurred
     */
    protected void _sendInstantAlerts () throws AmetysRepositoryException
    {
        if (_instantAlertContentIds != null && !_instantAlertContentIds.isEmpty())
        {
            for (String contentId : _instantAlertContentIds)
            {
                Content content = _ametysResolver.resolveById(contentId);
                _sendInstantAlertEmail (content, _instantAlertMessage);
            }
        }
    }
    
    /**
     * Send a instant e-mail alert to all the users who have the right to edit the content.
     * @param content the content about which to send the alert.
     * @param message the message
     * @throws AmetysRepositoryException if an error occurred
     */
    protected void _sendInstantAlertEmail(Content content, String message) throws AmetysRepositoryException
    {
        _setRequestAttributes(content);
        
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _instantAlertRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        List<String> params = _getInstantAlertParams(content, message);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_instantAlertSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_instantAlertBody, content), params);
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _i18nUtils.translate(i18nBody);
        
        _sendMails(subject, body, users, _mailFrom);
    }
    
    /**
     * Send the "awaiting validation" alerts.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendAwaitingValidationAlerts() throws AmetysRepositoryException
    {
        Long delay = Config.getInstance().getValue("remind.content.validation.delay");
        if (delay != null && delay > 0)
        {
            Calendar calendar = new GregorianCalendar();
            _removeTimeParts(calendar);
            calendar.add(Calendar.DAY_OF_MONTH, 1 - delay.intValue());
            
            // No last date and X days after the proposal date.
            Expression noLastDateExpr = new NotExpression(new MetadataExpression(AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, true));
            Expression waitingExpression = new DateExpression("proposalDate", Operator.LT, calendar.getTime(), true);
            // Or proposal date before the last "awaiting validation" date and the and X days after the last "awaiting validation" date.
            Expression proposalBeforeLastDateExpr = new BinaryExpression("proposalDate", true, Operator.LT, AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, true);
            Expression lastDateExpr = new DateExpression(AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, Operator.LT, calendar.getTime(), true);
            Expression expression = new OrExpression(new AndExpression(noLastDateExpr, waitingExpression),
                                                     new AndExpression(proposalBeforeLastDateExpr, lastDateExpr));
            
            String query = ContentQueryHelper.getContentXPathQuery(expression);
            
            
            
            try (AmetysObjectIterable<ModifiableContent> contents = _ametysResolver.query(query))
            {
                if (_LOGGER.isInfoEnabled())
                {
                    _LOGGER.info("Contents waiting for validation: " + contents.getSize());
                }
                
                for (ModifiableContent content : contents)
                {
                    // Send the alert e-mails.
                    _sendAwaitingValidationEmail(content);
                    
                    // Set the last validation alert date to now.
                    ModifiableCompositeMetadata meta = ((ModifiableMetadataAwareVersionableAmetysObject) content).getUnversionedMetadataHolder();
                    meta.setMetadata(AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, new Date());
                    
                    content.saveChanges();
                }
            }
        }
    }
    
    /**
     * Send the unmodified content alerts.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendUnmodifiedAlerts() throws AmetysRepositoryException
    {
        Long delay = Config.getInstance().getValue("remind.unmodified.content.delay");
        if (delay != null && delay > 0)
        {
            Calendar calendar = new GregorianCalendar();
            _removeTimeParts(calendar);
            calendar.add(Calendar.DAY_OF_MONTH, 1 - delay.intValue());
            
            // If no step is configured, stepExpr will return the empty string.
            Expression stepExpr = new WorkflowStepExpression(Operator.EQ, _unmodifiedContentStepIds, LogicalOperator.OR);
            // Get only the contents on which the alert is enabled.
            Expression unmodifiedExpr = new BooleanExpression(AlertsConstants.UNMODIFIED_ALERT_ENABLED, true, true);
            // No last date and X days after the proposal date, or X days after the last date.
            Expression noLastDateExpr = new NotExpression(new MetadataExpression(AlertsConstants.UNMODIFIED_ALERT_LAST_DATE, true));
            Expression lastModifiedExpression = new DateExpression("lastModified", Operator.LT, calendar.getTime());
            Expression lastDateExpr = new DateExpression(AlertsConstants.UNMODIFIED_ALERT_LAST_DATE, Operator.LT, calendar.getTime(), true);
            Expression dateExpr = new OrExpression(new AndExpression(noLastDateExpr, lastModifiedExpression), lastDateExpr);
            // Full AND expression.
            Expression expression = new AndExpression(unmodifiedExpr, dateExpr, stepExpr);
            
            String query = ContentQueryHelper.getContentXPathQuery(expression);
            
            try (AmetysObjectIterable<ModifiableContent> contents = _ametysResolver.query(query))
            {
                if (_LOGGER.isInfoEnabled())
                {
                    _LOGGER.info("Contents not modified for " + delay + " days: " + contents.getSize());
                }
                
                for (ModifiableContent content : contents)
                {
                    // Send the alert e-mail.
                    _sendUnmodifiedContentEmail(content);
                    
                    // Set the last unmodified alert date to now.
                    ModifiableCompositeMetadata meta = ((ModifiableMetadataAwareVersionableAmetysObject) content).getUnversionedMetadataHolder();
                    meta.setMetadata(AlertsConstants.UNMODIFIED_ALERT_LAST_DATE, new Date());
                    
                    content.saveChanges();
                }
            }
        }
    }
    
    /**
     * Send the content reminders.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendReminders() throws AmetysRepositoryException
    {
        Calendar now = new GregorianCalendar();
        _removeTimeParts(now);
        
        Expression reminderExpr = new BooleanExpression(AlertsConstants.REMINDER_ENABLED, Operator.EQ, true, true);
        Expression dateExpr = new DateExpression(AlertsConstants.REMINDER_DATE, Operator.EQ, now.getTime(), true);
        Expression expression = new AndExpression(reminderExpr, dateExpr);
        
        String query = ContentQueryHelper.getContentXPathQuery(expression);
        
        try (AmetysObjectIterable<Content> contents = _ametysResolver.query(query))
        {
            if (_LOGGER.isInfoEnabled())
            {
                _LOGGER.info("Contents with reminder today: " + contents.getSize());
            }
            
            for (Content content : contents)
            {
                _sendReminderEmail(content);
            }
        }
    }
    
    /**
     * Send the scheduled archiving reminders on contents.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendScheduledArchivingReminders() throws AmetysRepositoryException
    {
        Long delay = Config.getInstance().getValue("archive.scheduler.reminder.delay");
        if (delay != null && delay > 0)
        {
            Calendar calendar = new GregorianCalendar();
            _removeTimeParts(calendar);
            calendar.add(Calendar.DAY_OF_MONTH, delay.intValue());
            
            // No last date and X days before the scheduled date.
            Expression noLastDateExpr = new NotExpression(new MetadataExpression(AlertsConstants.SCHEDULED_ARCHIVING_REMINDER_LAST_DATE, true));
            Expression scheduledDelayExpression = new DateExpression(ArchiveConstants.META_ARCHIVE_SCHEDULED_DATE, Operator.LE, calendar.getTime(), true);
            Expression expression = new AndExpression(noLastDateExpr, scheduledDelayExpression);
            
            String query = ContentQueryHelper.getContentXPathQuery(expression);
            
            try (AmetysObjectIterable<ModifiableContent> contents = _ametysResolver.query(query))
            {
                if (_LOGGER.isInfoEnabled())
                {
                    _LOGGER.info("Contents with scheduled archiving reminder today: " + contents.getSize());
                }
                
                for (ModifiableContent content : contents)
                {
                    _sendScheduledArchivingReminderEmail(content);
                    
                    // Set the last scheduled archiving reminder date to now.
                    ModifiableCompositeMetadata meta = ((ModifiableMetadataAwareVersionableAmetysObject) content).getUnversionedMetadataHolder();
                    meta.setMetadata(AlertsConstants.SCHEDULED_ARCHIVING_REMINDER_LAST_DATE, new Date());
                    
                    content.saveChanges();
                }
            }
        }
    }
    
    /**
     * Send a "waiting for validation" e-mail alert to all the users who have the right to validate.
     * @param content the content about which to send the alert.
     * @throws AmetysRepositoryException if an error occured on the repository
     */
    protected void _sendAwaitingValidationEmail(Content content) throws AmetysRepositoryException
    {
        _setRequestAttributes(content);
        
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _awaitingValidationRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        List<String> params = _getAwaitingValidationParams(content);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_awaitingValidationSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_awaitingValidationBody, content), params);
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _i18nUtils.translate(i18nBody);
        
        _sendMails(subject, body, users, _mailFrom);
    }
    
    /**
     * Send a "unmodified content" e-mail alert to all the users who have the right to edit.
     * @param content the content about which to send the alert.
     * @throws AmetysRepositoryException if an error occured on the repository
     */
    protected void _sendUnmodifiedContentEmail(Content content) throws AmetysRepositoryException
    {
        _setRequestAttributes(content);
        
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _unmodifiedContentRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        List<String> params = _getUnmodifiedContentParams(content);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_unmodifiedContentSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_unmodifiedContentBody, content), params);
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _i18nUtils.translate(i18nBody);
        
        _sendMails(subject, body, users, _mailFrom);
    }
    
    /**
     * Send a reminder e-mail to all the users who have the right to edit.
     * @param content the content about which to send the reminder.
     * @throws AmetysRepositoryException if an error occured on the repository
     */
    protected void _sendReminderEmail(Content content) throws AmetysRepositoryException
    {
        _setRequestAttributes(content);
        
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _reminderRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        List<String> params = _getReminderParams(content);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_reminderSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_reminderBody, content), params);
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _i18nUtils.translate(i18nBody);
        
        _sendMails(subject, body, users, _mailFrom);
    }
    
    /**
     * Send a "scheduled archiving reminder" e-mail to all the users who have the right to archive.
     * @param content the content about which to send the alert.
     * @throws AmetysRepositoryException if an error occured on the repository
     */
    protected void _sendScheduledArchivingReminderEmail(ModifiableContent content) throws AmetysRepositoryException
    {
        _setRequestAttributes(content);
        
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _scheduledArchivingReminderRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        List<String> params = _getScheduledArchivingReminderParams(content);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_scheduledArchivingReminderSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_scheduledArchivingReminderBody, content), params);
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _i18nUtils.translate(i18nBody);
        
        _sendMails(subject, body, users, _mailFrom);
    }
    
    /**
     * Get the transform i18n body key for specific content
     * @param bodyI18nKey the original body key
     * @param content the content
     * @return the transform i18n body key
     */
    protected String getI18nKeyBody(String bodyI18nKey, Content content)
    {
        return bodyI18nKey;
    }
    
    /**
     * Get the mail parameters for instant alert.
     * @param content the content.
     * @param message the message
     * @return the parameters.
     */
    protected List<String> _getInstantAlertParams(Content content, String message)
    {
        List<String> params = new ArrayList<>();
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        params.add(message); // {2}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the additional i18n parameters for content
     * @param content The content
     * @return The additional i18n parameters
     */
    protected List<String> _getAdditionalParams (Content content)
    {
        return Collections.EMPTY_LIST;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getAwaitingValidationParams(Content content)
    {
        List<String> params = new ArrayList<>();
        
        Long delay = Config.getInstance().getValue("remind.content.validation.delay");
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        params.add(String.valueOf(delay)); // {2}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getUnmodifiedContentParams(Content content)
    {
        List<String> params = new ArrayList<>();
        
        Long delay = Config.getInstance().getValue("remind.unmodified.content.delay");
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        params.add(String.valueOf(delay));  // {2}
        
        CompositeMetadata meta = ((MetadataAndVersionAwareAmetysObject) content).getUnversionedMetadataHolder();
        String alertText = meta.getString(AlertsConstants.UNMODIFIED_ALERT_TEXT, "");
        params.add(alertText);  // {3}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getReminderParams(Content content)
    {
        List<String> params = new ArrayList<>();
        
        // Should never trigger a ClassCastException, as we query on an unversioned metadata.
        CompositeMetadata meta = ((MetadataAndVersionAwareAmetysObject) content).getUnversionedMetadataHolder();
        String reminderText = meta.getString(AlertsConstants.REMINDER_TEXT, "");
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        params.add(reminderText);  // {2}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getScheduledArchivingReminderParams(ModifiableContent content)
    {
        List<String> params = new ArrayList<>();
        
        Long delay = Config.getInstance().getValue("archive.scheduler.reminder.delay");
         
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        params.add(String.valueOf(delay)); // {2}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Send the alert emails.
     * @param subject the e-mail subject.
     * @param body the e-mail body.
     * @param users users to send the mail to.
     * @param from the address sending the e-mail.
     */
    protected void _sendMails(String subject, String body, Set<UserIdentity> users, String from)
    {
        for (UserIdentity identity : users)
        {
            User user = _userManager.getUser(identity.getPopulationId(), identity.getLogin());
            
            if (user != null && StringUtils.isNotBlank(user.getEmail()))
            {
                String mail = user.getEmail();
                
                try
                {
                    SendMailHelper.sendMail(subject, null, body, mail, from);
                }
                catch (MessagingException e)
                {
                    if (_LOGGER.isWarnEnabled())
                    {
                        _LOGGER.warn("Could not send an alert e-mail to " + mail, e);
                    }
                }
            }
        }
    }
    
    /**
     * Get the URL to the given content tool.
     * @param content the content.
     * @return the content URL.
     */
    protected String _getContentUrl(Content content)
    {
        StringBuilder url = new StringBuilder(_baseUrl);
        url.append("/index.html?uitool=uitool-content,id:%27").append(content.getId()).append("%27");
        
        return url.toString();
    }
    
    /**
     * Remove the time parts from a calendar, leaving only date parts.
     * @param calendar the calendar.
     */
    protected void _removeTimeParts(Calendar calendar)
    {
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
    }
    
    /**
     * Get a set of rights from a configuration.
     * @param configuration the configuration.
     * @return the set of rights.
     * @throws ConfigurationException if the configuration is not valid.
     */
    protected Set<String> _getRightsFromConf(Configuration configuration) throws ConfigurationException
    {
        Set<String> rights = new HashSet<>();
        
        for (Configuration rightConf : configuration.getChildren("right"))
        {
            String right = rightConf.getValue("");
            if (StringUtils.isNotBlank(right))
            {
                rights.add(right);
            }
        }
        
        return rights;
    }
    
    /**
     * Binary date expression: test on two metadatas.
     */
    protected class BinaryExpression implements Expression
    {
        private MetadataExpression _metadata1;
        private MetadataExpression _metadata2;
        private Operator _operator;
        
        /**
         * Creates the comparison Expression.
         * @param metadata1 the first metadata name.
         * @param operator the operator to make the comparison
         * @param metadata2 the second metadata name.
         */
        public BinaryExpression(String metadata1, Operator operator, String metadata2)
        {
            _metadata1 = new MetadataExpression(metadata1);
            _operator = operator;
            _metadata2 = new MetadataExpression(metadata2);
        }
        
        /**
         * Creates the comparison Expression.
         * @param metadata1 the first metadata name.
         * @param unversioned1 true if the first metadata is unversioned.
         * @param operator the operator to make the comparison.
         * @param metadata2 the second metadata name.
         * @param unversioned2 true if the second metadata is unversioned.
         */
        public BinaryExpression(String metadata1, boolean unversioned1, Operator operator, String metadata2, boolean unversioned2)
        {
            _metadata1 = new MetadataExpression(metadata1, unversioned1);
            _operator = operator;
            _metadata2 = new MetadataExpression(metadata2, unversioned2);
        }
        
        @Override
        public String build()
        {
            return _metadata1.build() + " " + _operator + " " + _metadata2.build();
        }
    }
    
}