/*
 *  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.io.IOException;
import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.StringUtils;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;

import org.ametys.cms.content.ContentHelper;
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.WorkflowAwareContentHelper;
import org.ametys.cms.repository.WorkflowStepExpression;
import org.ametys.core.right.RightManager;
import org.ametys.core.schedule.progression.ContainerProgressionTracker;
import org.ametys.core.ui.mail.StandardMailBodyHelper;
import org.ametys.core.ui.mail.StandardMailBodyHelper.MailBodyBuilder;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.population.PopulationContextHelper;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.LambdaUtils;
import org.ametys.core.util.LambdaUtils.LambdaException;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.plugins.core.impl.schedule.AbstractStaticSchedulable;
import org.ametys.plugins.core.schedule.Scheduler;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.data.holder.DataHolder;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
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.LogicalOperator;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.repository.query.expression.ExpressionContext;
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.DataAndVersionAwareAmetysObject;
import org.ametys.plugins.repository.version.ModifiableDataAwareVersionableAmetysObject;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;

import jakarta.mail.MessagingException;

/**
 * Alerts engine: sends alerts mail.
 */
public class AlertSchedulable extends AbstractStaticSchedulable implements Initializable
{
    /** The schedulable id */
    public static final String SCHEDULABLE_ID = AlertSchedulable.class.getName();
    
    /** The job context param to set to true when using instantMode */
    public static final String JOBDATAMAP_INSTANT_MODE_KEY = "instantMode";
    
    /** The job context param to specify the target contents when using instantMode */
    public static final String JOBDATAMAP_CONTENT_IDS_KEY = "contentIds";
    
    /** The job context param to set the message when using instantMode */
    public static final String JOBDATAMAP_MESSAGE_KEY = "message";
    
    /** The context used for validation alerts expressions */
    protected static final ExpressionContext __AWAITING_VALIDATION_ALERT_EXPR_CONTEXT = ExpressionContext.newInstance().withUnversioned(true);
    /** The context used for validation alerts expressions */
    protected static final ExpressionContext __PROPOSAL_DATE_EXPR_CONTEXT = ExpressionContext.newInstance().withInternal(true);
    
    /** The service manager. */
    protected ServiceManager _manager;
    
    /** Is the engine initialized ? */
    protected boolean _initialized;
    
    /** The cocoon environment context. */
    protected org.apache.cocoon.environment.Context _environmentContext;
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    
    /** The rights manager. */
    protected RightManager _rightManager;
    
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;
    
    /** The content helper */
    protected ContentHelper _contentHelper;
    
    /** 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;
    
    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
    }
    
    public void initialize() throws Exception
    {
        _mailFrom = Config.getInstance().getValue("smtp.mail.from");
    }
    
    /**
     * Configure the engine (called by the scheduler).
     * @param configuration the component configuration.
     * @throws ConfigurationException if the configuration is not valid
     */
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        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();
    }
    
    /**
     * 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);
    }
    
    /**
     * Send all the alerts. Can be overridden to add alerts.
     * @throws AmetysRepositoryException if an error occurs.
     */
    @Override
    public void execute(JobExecutionContext context, ContainerProgressionTracker progressionTracker) throws Exception
    {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        if (isInstantMode(jobDataMap))
        {
            @SuppressWarnings("unchecked")
            List<String> contentIds = (List<String>) jobDataMap.get(Scheduler.PARAM_VALUES_PREFIX + JOBDATAMAP_CONTENT_IDS_KEY);
            String message = jobDataMap.getString(Scheduler.PARAM_VALUES_PREFIX + JOBDATAMAP_MESSAGE_KEY);
            _sendInstantAlerts(contentIds, message);
        }
        else
        {
            _sendAwaitingValidationAlerts();
            _sendUnmodifiedAlerts();
            _sendReminders();
            _sendScheduledArchivingReminders();
        }
    }

    /**
     * Check if the scheduler was triggered to send an instant alert
     * @param jobDataMap the job data map
     * @return true if the scheduler was triggered to send an instant alert
     */
    protected boolean isInstantMode(JobDataMap jobDataMap)
    {
        boolean instantMode = jobDataMap.getBooleanValue(Scheduler.PARAM_VALUES_PREFIX + JOBDATAMAP_INSTANT_MODE_KEY);
        return instantMode;
    }
    
    /**
     * Send instant alerts on contents
     * @param contentIds The contents to alert on
     * @param message The custom message to add to the mail
     * @throws AmetysRepositoryException if an error occurred
     */
    protected void _sendInstantAlerts (List<String> contentIds, String message) throws AmetysRepositoryException
    {
        if (contentIds != null && !contentIds.isEmpty())
        {
            for (String contentId : contentIds)
            {
                Content content = _resolver.resolveById(contentId);
                _sendInstantAlertEmail (content, message);
            }
        }
    }
    
    /**
     * 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);
        
        I18nizableText i18nSubject = new I18nizableText(null, getI18nKeyBody(_instantAlertSubject, content), params);
        I18nizableText i18nBody = new I18nizableText(null, getI18nKeyBody(_instantAlertBody, content), params);
        
        try
        {
            MailBodyBuilder body = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withDetails(new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_MESSAGE"), message, false)
                    .withLink(_getContentUrl(content), new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_LINK_TITLE"));
            
            _sendMails(i18nSubject, body, users, _mailFrom, content.getLanguage());
        }
        catch (IOException e)
        {
            getLogger().error("Fail to build HTML mail body for instant alert", e);
        }
    }
    
    /**
     * 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, __AWAITING_VALIDATION_ALERT_EXPR_CONTEXT));
            Expression waitingExpression = new DateExpression(WorkflowAwareContentHelper.METADATA_LAST_PROPOSAL_DATE, Operator.LT, calendar.getTime(), __PROPOSAL_DATE_EXPR_CONTEXT);
            // Or proposal date before the last "awaiting validation" date and the and X days after the last "awaiting validation" date.
            Expression proposalBeforeLastDateExpr = new BinaryExpression(WorkflowAwareContentHelper.METADATA_LAST_PROPOSAL_DATE, __PROPOSAL_DATE_EXPR_CONTEXT, Operator.LT, AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, __AWAITING_VALIDATION_ALERT_EXPR_CONTEXT);
            Expression lastDateExpr = new DateExpression(AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, Operator.LT, calendar.getTime(), __AWAITING_VALIDATION_ALERT_EXPR_CONTEXT);
            Expression expression = new OrExpression(new AndExpression(noLastDateExpr, waitingExpression),
                                                     new AndExpression(proposalBeforeLastDateExpr, lastDateExpr));
            
            String query = ContentQueryHelper.getContentXPathQuery(expression);
            
            try (AmetysObjectIterable<ModifiableContent> contents = _resolver.query(query))
            {
                if (getLogger().isInfoEnabled())
                {
                    getLogger().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.
                    ModifiableDataHolder dataHolder = ((ModifiableDataAwareVersionableAmetysObject) content).getUnversionedDataHolder();
                    dataHolder.setValue(AlertsConstants.AWAITING_VALIDATION_ALERT_LAST_DATE, ZonedDateTime.now());
                    
                    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());
            
            ExpressionContext exprContext = ExpressionContext.newInstance().withUnversioned(true);
            
            // 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, exprContext);
            // 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, exprContext));
            Expression lastModifiedExpression = new DateExpression("lastModified", Operator.LT, calendar.getTime(), ExpressionContext.newInstance().withInternal(true));
            Expression lastDateExpr = new DateExpression(AlertsConstants.UNMODIFIED_ALERT_LAST_DATE, Operator.LT, calendar.getTime(), exprContext);
            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 = _resolver.query(query))
            {
                if (getLogger().isInfoEnabled())
                {
                    getLogger().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.
                    ModifiableDataHolder dataHolder = ((ModifiableDataAwareVersionableAmetysObject) content).getUnversionedDataHolder();
                    dataHolder.setValue(AlertsConstants.UNMODIFIED_ALERT_LAST_DATE, ZonedDateTime.now());
                    
                    content.saveChanges();
                }
            }
        }
    }
    
    /**
     * Send the content reminders.
     * @throws AmetysRepositoryException if an error occurs.
     */
    protected void _sendReminders() throws AmetysRepositoryException
    {
        Date now = DateUtils.asDate(LocalDate.now());
        
        ExpressionContext exprContext = ExpressionContext.newInstance().withUnversioned(true);
        Expression reminderExpr = new BooleanExpression(AlertsConstants.REMINDER_ENABLED, Operator.EQ, true, exprContext);
        Expression dateExpr = new DateExpression(AlertsConstants.REMINDER_DATE, Operator.EQ, now, exprContext);
        Expression expression = new AndExpression(reminderExpr, dateExpr);
        
        String query = ContentQueryHelper.getContentXPathQuery(expression);
        
        try (AmetysObjectIterable<Content> contents = _resolver.query(query))
        {
            if (getLogger().isInfoEnabled())
            {
                getLogger().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());
            
            ExpressionContext exprContext = ExpressionContext.newInstance().withUnversioned(true);
            
            // No last date and X days before the scheduled date.
            Expression noLastDateExpr = new NotExpression(new MetadataExpression(AlertsConstants.SCHEDULED_ARCHIVING_REMINDER_LAST_DATE, exprContext));
            Expression scheduledDelayExpression = new DateExpression(ArchiveConstants.META_ARCHIVE_SCHEDULED_DATE, Operator.LE, calendar.getTime(), exprContext);
            Expression expression = new AndExpression(noLastDateExpr, scheduledDelayExpression);
            
            String query = ContentQueryHelper.getContentXPathQuery(expression);
            
            try (AmetysObjectIterable<ModifiableContent> contents = _resolver.query(query))
            {
                if (getLogger().isInfoEnabled())
                {
                    getLogger().info("Contents with scheduled archiving reminder today: " + contents.getSize());
                }
                
                for (ModifiableContent content : contents)
                {
                    _sendScheduledArchivingReminderEmail(content);
                    
                    // Set the last scheduled archiving reminder date to now.
                    ModifiableDataHolder dataHolder = ((ModifiableDataAwareVersionableAmetysObject) content).getUnversionedDataHolder();
                    dataHolder.setValue(AlertsConstants.SCHEDULED_ARCHIVING_REMINDER_LAST_DATE, ZonedDateTime.now());
                    
                    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);
        
        try
        {
            MailBodyBuilder body = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withLink(_getContentUrl(content), new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_LINK_TITLE"));
            
            _sendMails(i18nSubject, body, users, _mailFrom, content.getLanguage());
        }
        catch (IOException e)
        {
            getLogger().error("Fail to build HTML mail body for awaiting validation email", e);
        }
    }
    
    /**
     * 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);
        
        try
        {
            MailBodyBuilder bodyBuilder = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withLink(_getContentUrl(content), new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_LINK_TITLE"));
                    
            DataHolder dataHolder = ((DataAndVersionAwareAmetysObject) content).getUnversionedDataHolder();
            String alertText = dataHolder.getValueOrDefault(AlertsConstants.UNMODIFIED_ALERT_TEXT, StringUtils.EMPTY);
              
            if (StringUtils.isNotEmpty(alertText))
            {
                bodyBuilder.withDetails(new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_MESSAGE"), alertText, false);
            }
            
            _sendMails(i18nSubject, bodyBuilder, users, _mailFrom, content.getLanguage());
        }
        catch (IOException e)
        {
            getLogger().error("Fail to build HTML mail body for unmodified content alert", e);
        }
    }
    
    /**
     * 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);
        
        // Should never trigger a ClassCastException, as we query on an unversioned metadata.
        DataHolder dataHolder = ((DataAndVersionAwareAmetysObject) content).getUnversionedDataHolder();
        String reminderText = dataHolder.getValueOrDefault(AlertsConstants.REMINDER_TEXT, StringUtils.EMPTY);
        
        try
        {
            MailBodyBuilder body = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withDetails(new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_MESSAGE"), reminderText, false)
                    .withLink(_getContentUrl(content), new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_LINK_TITLE"));
            
            _sendMails(i18nSubject, body, users, _mailFrom, content.getLanguage());
        }
        catch (IOException e)
        {
            getLogger().error("Fail to build HTML mail body for content reminder", e);
        }
    }
    
    /**
     * 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);
        
        try
        {
            MailBodyBuilder body = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withLink(_getContentUrl(content), new I18nizableText("plugin.cms", "CONTENT_ALERTS_MAIL_CONTENT_LINK_TITLE"));
            
            _sendMails(i18nSubject, body, users, _mailFrom, content.getLanguage());
        }
        catch (IOException e)
        {
            getLogger().error("Fail to build HTML mail body for scheduled archiving reminder", e);
        }
    }
    
    /**
     * 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.
     * @return the parameters.
     */
    protected List<String> _getInstantAlertParams(Content content)
    {
        // TODO switch to named params
        List<String> params = new ArrayList<>();
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        
        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)
    {
        // TODO switch to named params
        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)
    {
        // TODO switch to named params
        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}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getReminderParams(Content content)
    {
        // TODO switch to named params
        List<String> params = new ArrayList<>();
        
        params.add(content.getTitle(null)); // {0}
        params.add(_getContentUrl(content)); // {1}
        
        params.addAll(_getAdditionalParams(content));
        
        return params;
    }
    
    /**
     * Get the mail parameters.
     * @param content the content.
     * @return the parameters.
     */
    protected List<String> _getScheduledArchivingReminderParams(ModifiableContent content)
    {
        // TODO switch to named params
        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 i18nSubject the e-mail subject.
     * @param bodyBuilder the e-mail body.
     * @param users users to send the mail to.
     * @param from the address sending the e-mail.
     * @param contentLang the content's language.
     * @throws IOException If an error occured while creating the body of the mail
     */
    protected void _sendMails(I18nizableText i18nSubject, MailBodyBuilder bodyBuilder, Set<UserIdentity> users, String from, String contentLang) throws IOException
    {
        Map<String, String> bodyByLanguage = new HashMap<>();
        for (UserIdentity identity : users)
        {
            User user = _userManager.getUser(identity.getPopulationId(), identity.getLogin());
            
            if (user != null && StringUtils.isNotBlank(user.getEmail()))
            {
                String mail = user.getEmail();
                
                String language = StringUtils.defaultIfBlank(user.getLanguage(), StringUtils.defaultIfBlank(contentLang, _userLanguagesManager.getDefaultLanguage()));
                
                String subject = _i18nUtils.translate(i18nSubject, language);
                String body;
                try
                {
                    body = bodyByLanguage.computeIfAbsent(
                        language,
                        // Retrieve the exception as a LambdaException to avoid IOException
                        LambdaUtils.wrap(lang -> bodyBuilder.withLanguage(lang).build())
                    );
                    
                    SendMailHelper.newMail()
                                  .withSubject(subject)
                                  .withHTMLBody(body)
                                  .withSender(from)
                                  .withRecipient(mail)
                                  .sendMail();
                    
                }
                catch (LambdaException e)
                {
                    throw (IOException) e.getCause();
                }
                catch (MessagingException | IOException e)
                {
                    if (getLogger().isWarnEnabled())
                    {
                        getLogger().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)
    {
        return _contentHelper.getContentBOUrl(content, Map.of());
    }
    
    /**
     * 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 context1 context of the expression for the first metadata
         * @param operator the operator to make the comparison.
         * @param metadata2 the second metadata name.
         * @param context2 context of the expression for the second metadata
         */
        public BinaryExpression(String metadata1, ExpressionContext context1, Operator operator, String metadata2, ExpressionContext context2)
        {
            _metadata1 = new MetadataExpression(metadata1, context1);
            _operator = operator;
            _metadata2 = new MetadataExpression(metadata2, context2);
        }
        
        @Override
        public String build()
        {
            return _metadata1.build() + " " + _operator + " " + _metadata2.build();
        }
    }
    
}