/*
 *  Copyright 2012 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.workflow.archive;

import java.io.IOException;
import java.io.InputStream;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

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.commons.lang.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.quartz.JobExecutionContext;
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.core.authentication.AuthenticateAction;
import org.ametys.core.model.type.ModelItemTypeExtensionPoint;
import org.ametys.core.right.RightManager;
import org.ametys.core.schedule.progression.ContainerProgressionTracker;
import org.ametys.core.ui.mail.StandardMailBodyHelper;
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.core.impl.schedule.AbstractStaticSchedulable;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.provider.RequestAttributeWorkspaceSelector;
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.ExpressionContext;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;

import jakarta.mail.MessagingException;

/**
 * Runnable engine that archive the contents that have an scheduled archiving
 * date set before the current date.
 */
public class ArchiveContentsSchedulable extends AbstractStaticSchedulable
{
    /** The logger. */
    protected Logger _logger = LoggerFactory.getLogger(ArchiveContentsSchedulable.class);

    /** The service manager. */
    protected ServiceManager _manager;

    /** The server base URL. */
    protected String _baseUrl;

    /** The cocoon environment context. */
    protected org.apache.cocoon.environment.Context _environmentContext;

    /** The ametys object resolver. */
    protected AmetysObjectResolver _ametysResolver;

    /** The avalon source resolver. */
    protected SourceResolver _sourceResolver;
    
    /** The rights manager */
    protected RightManager _rightManager;
    
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;
    
    /** The content of "from" field in emails. */
    protected String _mailFrom;

    /** The sysadmin mail address, to which will be sent the report e-mail. */
    protected String _sysadminMail;
    
    /** The user e-mail notification will be sent to users that have this at least one of this rights. */
    protected Set<String> _archiveRights;
    
    /** The user notification mail body i18n key. */
    protected String _userMailBody;
    
    /** The user notification mail subject i18n key. */
    protected String _userMailSubject;
    
    /** The user notification error mail body i18n key. */
    protected String _userErrorMailBody;
    
    /** The user notification error mail subject i18n key. */
    protected String _userErrorMailSubject;
    

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _smanager = manager;
        _schedulableParameterTypeExtensionPoint = (ModelItemTypeExtensionPoint) _smanager.lookup(ModelItemTypeExtensionPoint.ROLE_SCHEDULABLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        
        _manager = manager;
        // Lookup the needed components.
        _ametysResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.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");
        _sysadminMail = Config.getInstance().getValue("smtp.mail.sysadminto");
    }

    @Override
    public void contextualize(Context context) throws ContextException
    {
        super.contextualize(context);
        _environmentContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }

    /**
     * Configure the engine (called by the scheduler).
     * 
     * @param configuration the component configuration.
     * @throws ConfigurationException If an error occurred
     */
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        super.configure(configuration);
        // Rights
        Configuration rightsConf = configuration.getChild("rights");
        
        _archiveRights = new HashSet<>();
        
        for (Configuration rightConf : rightsConf.getChildren("right"))
        {
            String right = rightConf.getValue("");
            if (StringUtils.isNotBlank(right))
            {
                _archiveRights.add(right);
            }
        }
        
        // Mails
        Configuration validMailsConf = configuration.getChild("mails").getChild("valid");
        Configuration errorMailsConf = configuration.getChild("mails").getChild("error");
        
        _userMailBody = validMailsConf.getChild("bodyKey").getValue();
        _userMailSubject = validMailsConf.getChild("subjectKey").getValue();
        
        _userErrorMailBody = errorMailsConf.getChild("bodyKey").getValue();
        _userErrorMailSubject = errorMailsConf.getChild("subjectKey").getValue();

    }

    @Override
    public void execute(JobExecutionContext context, ContainerProgressionTracker progressionTracker) throws Exception
    {
        Request request = ContextHelper.getRequest(_context);
        
        // Get all the content which scheduled archiving date is passed.
        Expression dateExpression = new DateExpression(ArchiveConstants.META_ARCHIVE_SCHEDULED_DATE, Operator.LE, new Date(), ExpressionContext.newInstance().withUnversioned(true));
        String query = ContentQueryHelper.getContentXPathQuery(dateExpression);

        try (AmetysObjectIterable<Content> contents = _ametysResolver.query(query))
        {
            List<Content> archivedContents = new ArrayList<>();
            List<Content> contentsWithError = new ArrayList<>();
           
            try
            {
                // Authorize workflow actions and "check-auth" CMS action
                request.setAttribute(AuthenticateAction.REQUEST_ATTRIBUTE_INTERNAL_ALLOWED, true);
                
                for (Content content : contents)
                {
                    setRequestAttributes(request, content);
                    
                    Set<UserIdentity> users = _getAuthorizedContributors(content);
                    
                    Source source = null;
                    try
                    {
                        String contentId = content.getId();
                        
                        String uri = getArchiveActionUri(contentId);
                        source = _sourceResolver.resolveURI(uri);
                        
                        try (InputStream is =  source.getInputStream())
                        {
                            String workspaceBackup = RequestAttributeWorkspaceSelector.getForcedWorkspace(request);
                            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, ArchiveConstants.ARCHIVE_WORKSPACE);
                            
                            Content archivedContent = _ametysResolver.resolveById(contentId);
                            archivedContents.add(archivedContent);
                            
                            sendMailToContributors(archivedContent, users);
                            
                            RequestAttributeWorkspaceSelector.setForcedWorkspace(request, workspaceBackup);
                        }
                    }
                    catch (Exception e)
                    {
                        contentsWithError.add (content);
                        sendErrorMailToContributors(content, users);
                        _logger.error("Error while trying to archive the content : " + content.getId() + "\nThis content is probably not archived.", e);
                    }
                    finally
                    {
                        if (source != null)
                        {
                            _sourceResolver.release(source);
                        }
                    }
                }
            }
            finally
            {
                request.removeAttribute(AuthenticateAction.REQUEST_ATTRIBUTE_INTERNAL_ALLOWED);
                
                // Send mail to administrator
                sendMailToAdministrator(archivedContents, contentsWithError);
            }
        }
    }
    
    /**
     * Set the necessary request attributes 
     * @param request The request
     * @param content The content
     */
    protected void setRequestAttributes (Request request, Content content)
    {
        // Set the population contexts to be able to get allowed users
        List<String> populationContexts = new ArrayList<>();
        populationContexts.add("/application");
        
        request.setAttribute(PopulationContextHelper.POPULATION_CONTEXTS_REQUEST_ATTR, populationContexts);
    }
    
    /**
     * Get the pipeline uri for the archive action
     * @param contentId the current contend id
     * @return a pipeline uri
     */
    protected String getArchiveActionUri(String contentId)
    {
        return "cocoon://_plugins/cms/archives/archive/" + ArchiveConstants.ARCHIVE_WORKFLOW_ACTION_ID + "?contentId=" + contentId;
    }

    /**
     * Send the archive report e-mail.
     * @param archivedContents The list of archived contents
     * @param contentsWithError The list of contents with error
     */
    protected void sendMailToAdministrator(List<Content> archivedContents, List<Content> contentsWithError)
    {
        if (archivedContents.size() != 0 || contentsWithError.size() != 0)
        {
            try
            {
                I18nizableText i18nSubject = new I18nizableText("plugin.cms", "PLUGINS_CMS_ARCHIVE_CONTENTS_REPORT_SUBJECT");
                
                List<String> bodyParams = getAdminEmailParams(archivedContents, contentsWithError);
                I18nizableText i18nBody = new I18nizableText("plugin.cms", "PLUGINS_CMS_ARCHIVE_CONTENTS_REPORT_BODY", bodyParams);
                
                String subject = _i18nUtils.translate(i18nSubject);
                
                String body = StandardMailBodyHelper.newHTMLBody()
                        .withTitle(i18nSubject)
                        .withMessage(i18nBody)
                        .withLink(_getRequestURI(null) + "/index.html", new I18nizableText("plugin.cms", "PLUGINS_CMS_ARCHIVE_CONTENTS_REPORT_BODY_LINK"))
                        .build();
                
                if (StringUtils.isNotBlank(_sysadminMail))
                {
                    SendMailHelper.newMail()
                                  .withSubject(subject)
                                  .withHTMLBody(body)
                                  .withSender(_mailFrom)
                                  .withRecipient(_sysadminMail)
                                  .sendMail();
                }
            }
            catch (MessagingException | IOException e)
            {
                _logger.warn("Error sending the archive report e-mail.", e);
            }
        }
    }
    

    /**
     * Get the report e-mail parameters.
     * @param archivedContents The list of archived contents
     * @param contentsWithError The list of contents with error
     * @return the e-mail parameters.
     */
    protected List<String> getAdminEmailParams(List<Content> archivedContents, List<Content> contentsWithError)
    {
        List<String> params = new ArrayList<>();
        
        DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT);
        params.add(df.format(new Date())); // {0}
        
        params.add(String.valueOf(archivedContents.size())); // {1}
        params.add(_getContentsListAsString(archivedContents)); // {2}

        params.add(String.valueOf(contentsWithError.size())); // {3}
        params.add(_getContentsListAsString(contentsWithError)); // {4}

        return params;
    }
    
    /**
     * Get the contents list as String
     * @param contents The contents
     * @return the list of contents as String
     */
    protected String _getContentsListAsString (List<Content> contents)
    {
        List<String> contentNames = contents.stream()
            .map(this::_getContentTitle)
            .collect(Collectors.toList());
        
        if (!contentNames.isEmpty())
        {
            StringBuilder sb = new StringBuilder();
            sb.append("<ul>");
            contentNames.forEach(c -> sb.append("<li>").append(c).append("</li>"));
            sb.append("</ul>");
            
            return sb.toString();
        }
        else
        {
            return "";
        }
    }
    
    /**
     * Get content title for mail
     * @param content the content
     * @return the content title
     */
    protected String _getContentTitle(Content content)
    {
        return content.getTitle(null);
    }
    
    /**
     * Get the authorized contributors to receive mail notification
     * @param content The content to be archived
     * @return The user logins
     */
    protected Set<UserIdentity> _getAuthorizedContributors (Content content)
    {
        Set<UserIdentity> users = new HashSet<>();
        for (String right : _archiveRights)
        {
            users.addAll(_rightManager.getAllowedUsers(right, content).resolveAllowedUsers(Config.getInstance().getValue("runtime.mail.massive.sending")));
        }
        
        return users;
    }

    /**
     * Send the mail to alert users that the content has been archived.
     * @param content The archived content 
     * @param users The users
     */
    protected void sendMailToContributors(Content content, Set<UserIdentity> users)
    {
        try
        {
            List<String> params = getBodyParamsForContributors (content, true);
            
            I18nizableText i18nSubject = new I18nizableText(null, _userMailSubject, params);
            I18nizableText i18nBody = new I18nizableText(null, _userMailBody, params);
            
            String body = StandardMailBodyHelper.newHTMLBody()
                .withTitle(i18nSubject)
                .withMessage(i18nBody)
                .withLink(getContentUri(content, true), new I18nizableText("plugin.cms", "CONTENT_ARCHIVE_MAIL_CONTENT_BODY_CONTENT_LINK"))
                .build();
            
            String subject = _i18nUtils.translate(i18nSubject);
            
            _sendMailsToUsers(subject, body, users, _mailFrom);
        }
        catch (Exception e)
        {
            _logger.error("Unable to send mail to contributors after archiving content '" + content.getName() + "'", e);
        }
    }
    
    /**
     * Get email body parameters
     * @param content the archived content
     * @param archived true if the content has archived
     * @return The mail parameters
     */
    protected List<String> getBodyParamsForContributors (Content content, boolean archived)
    {
        List<String> params = new ArrayList<>();
        
        params.add(content.getTitle(null)); // {0}
        params.add(DateFormat.getDateInstance(DateFormat.LONG).format(new Date())); // {1}
        params.add(getContentUri(content, archived));
        
        return params;
    }
    
    /**
     * Get the content uri
     * @param content the archived content
     * @param archived true if the content has archived
     * @return the content uri
     */
    protected String getContentUri(Content content, boolean archived)
    {
        if (archived)
        {
            return _getRequestURI(content) + "/index.html?uitool=uitool-content,id:%27" + content.getId() + "%27,workspace:%27archives%27,%27ignore-workflow%27:%27true%27,%27content-message-type%27:%27archived-content%27";
        }
        else
        {
            return _getRequestURI(content) + "/index.html?uitool=uitool-content,id:%27" + content.getId() + "%27";
        }
    }
    
    /**
     * Send the mail to alert users that an error has occurred while trying to archive the content.
     * @param content The content 
     * @param users The users
     */
    protected void sendErrorMailToContributors(Content content, Set<UserIdentity> users)
    {
        try
        {
            List<String> params = getBodyParamsForContributors (content, false);
            
            I18nizableText i18nSubject = new I18nizableText(null, _userErrorMailSubject, params);
            I18nizableText i18nBody = new I18nizableText(null, _userErrorMailBody, params);
            
            String body = StandardMailBodyHelper.newHTMLBody()
                    .withTitle(i18nSubject)
                    .withMessage(i18nBody)
                    .withLink(getContentUri(content, false), new I18nizableText("plugin.cms", "CONTENT_ARCHIVE_MAIL_CONTENT_BODY_CONTENT_LINK"))
                    .build();
            
            String subject = _i18nUtils.translate(i18nSubject);
            
            _sendMailsToUsers(subject, body, users, _mailFrom);
        }
        catch (Exception e)
        {
            _logger.error("Unable to send mail to contributors after archiving content '" + content.getName() + "' failed", e);
        }
    }
    
    /**
     * Get the request URI to set in mail
     * @param content The content. Can be null
     * @return the request URI
     */
    protected String _getRequestURI (Content content)
    {
        return _baseUrl;
    }

    /**
     * Send the emails to users (contributors)
     * @param subject the e-mail subject.
     * @param htmlBody the e-mail body.
     * @param users users to send the mail to.
     * @param from the address sending the e-mail.
     */
    protected void _sendMailsToUsers(String subject, String htmlBody, Set<UserIdentity> users, String from)
    {
        for (UserIdentity userIdentity : users)
        {
            User user = _userManager.getUser(userIdentity.getPopulationId(), userIdentity.getLogin());
            
            if (user != null && StringUtils.isNotBlank(user.getEmail()))
            {
                String mail = user.getEmail();
                
                try
                {
                    SendMailHelper.newMail()
                                  .withSubject(subject)
                                  .withHTMLBody(htmlBody)
                                  .withSender(from)
                                  .withRecipient(mail)
                                  .sendMail();
                }
                catch (MessagingException | IOException e)
                {
                    if (_logger.isWarnEnabled())
                    {
                        _logger.warn("Could not send an archive notification e-mail to " + mail, e);
                    }
                }
            }
        }
    }
}