/*
 *  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.content.consistency;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
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.components.source.impl.SitemapSource;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.background.BackgroundEnvironment;
import org.apache.cocoon.util.log.SLF4JLoggerAdapter;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.SourceUtil;
import org.apache.excalibur.xml.sax.SAXParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import org.ametys.core.authentication.AuthenticateAction;
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.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.servlet.RuntimeConfig;

/**
 * Content consistency engine: generate consistency information for all contents.
 * Sends a report e-mail if there are inconsistencies.
 */
public class ContentConsistencyEngine implements Runnable
{
    
    /** The logger. */
    protected static final Logger _LOGGER = LoggerFactory.getLogger(ContentConsistencyEngine.class);
    
    /** The report e-mail will be sent to users who possess this right on the application context. */
    protected static final String _MAIL_RIGHT = "CMS_Rights_ReceiveConsistencyReport";
    
    private static boolean _RUNNING;
    
    /** The avalon context. */
    protected Context _context;
    
    /** The service manager. */
    protected ServiceManager _manager;
    
    /** The server base URL. */
    protected String _baseUrl;
    
    /** The report directory. */
    protected File _reportDirectory;
    
    /** 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 avalon source resolver. */
    protected SourceResolver _sourceResolver;
    
    /** A SAX parser. */
    protected SAXParser _saxParser;
    
    /** 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;
    
    /**
     * Initialize the alert engine.
     * @param manager the avalon service manager.
     * @param context the avalon context.
     * @throws ContextException if an error occurs retrieving the environment context.
     * @throws ServiceException if an error occurs retrieving a component.
     */
    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);
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _saxParser = (SAXParser) manager.lookup(SAXParser.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().getValueAsString("cms.url"), "index.html"), "/");
        _mailFrom = Config.getInstance().getValueAsString("smtp.mail.from");
        _reportDirectory = new File(RuntimeConfig.getInstance().getAmetysHome(), "consistency");
        
        _initialized = true;
    }
    
    /**
     * Configure the engine (called by the scheduler).
     * @param configuration the component configuration.
     * @throws ConfigurationException if an error occurred
     */
    public void configure(Configuration configuration) throws ConfigurationException
    {
        // Ignore
    }
    
    /**
     * 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);
        }
    }
    
    /**
     * Test if the engine is running at the time.
     * @return true if the engine is running, false otherwise.
     */
    static boolean isRunning()
    {
        return _RUNNING;
    }
    
    private static void setRunning(boolean running)
    {
        _RUNNING = running;
    }
    
    @Override
    public void run()
    {
        Map<String, Object> environmentInformation = null;
        
        try
        {
            _LOGGER.info("Preparing to generate the content consistency report...");
            
            _checkInitialization();
            
            // Create the environment.
            environmentInformation = BackgroundEngineHelper.createAndEnterEngineEnvironment(_manager, _environmentContext, new SLF4JLoggerAdapter(_LOGGER));
            BackgroundEnvironment environment = (BackgroundEnvironment) environmentInformation.get("environment");

            // Authorize workflow actions and "check-auth" CMS action, from this background environment 
            Request request = (Request) environment.getObjectModel().get(ObjectModelHelper.REQUEST_OBJECT);
            request.setAttribute(AuthenticateAction.REQUEST_ATTRIBUTE_INTERNAL_ALLOWED, true);
            
            _generateReports();
        }
        catch (Exception e)
        {
            _LOGGER.error("An error occurred generating the content consistency report.", e);
        }
        finally
        {
            // Leave the environment.
            if (environmentInformation != null)
            {
                BackgroundEngineHelper.leaveEngineEnvironment(environmentInformation);
            }
            // Dispose of the resources.
            _dispose();
            _LOGGER.info("Content consistency report generated.");
        }
    }
    
    /**
     * 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;
        _sourceResolver = 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.
     * @throws IOException if an error occurred 
     */
    protected void _generateReports() throws AmetysRepositoryException, IOException
    {
        if (isRunning())
        {
            _LOGGER.error("Cannot start a global consistency check, as the engine is running at the time.");
        }
        else
        {
            try
            {
                setRunning(true);
                
                Request request = ContextHelper.getRequest(_context);
                
                // 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);
                
                // Generate the report.
                _generateReport();
            }
            finally
            {
                setRunning(false);
            }
        }
    }
    
    /**
     * Generate the full consistency report.
     * @throws IOException if an i/o error occurs.
     */
    protected void _generateReport() throws IOException
    {
        SitemapSource source = null;
        File reportTmpFile = null;
        
        try
        {
            // Create the directory if it does not exist.
            FileUtils.forceMkdir(_reportDirectory);
            
            // Resolve the report pipeline.
            String url = "cocoon://_plugins/cms/consistency/inconsistent-contents-report.xml";
            source = (SitemapSource) _sourceResolver.resolveURI(url);
            
            // Save the report into a temporary file.
            reportTmpFile = new File(_reportDirectory, "report.tmp.xml");
            OutputStream reportTmpOs = new FileOutputStream(reportTmpFile);
            
            SourceUtil.copy(source.getInputStream(), reportTmpOs);
            
            // If all went well until now, copy the temporary file to the real report file.
            File reportFile = new File(_reportDirectory, "report.xml");
            FileUtils.copyFile(reportTmpFile, reportFile);
            
            try (FileInputStream reportIs = new FileInputStream(reportFile))
            {
                // Parse the report to know if there were contents with inconsistencies.
                ContentExistsHandler handler = new ContentExistsHandler();
                _saxParser.parse(new InputSource(reportIs), handler);
                
                // If inconsistent contents exist, send an e-mail.
                if (handler.hasFailures())
                {
                    _sendErrorEmail();
                }
            }
        }
        catch (SAXException e)
        {
            _LOGGER.error("The consistency report could not be parsed.", e);
        }
        finally
        {
            // Delete the temporary file.
            if (reportTmpFile != null)
            {
                reportTmpFile.delete();
            }

            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Send a reminder e-mail to all the users who have the right to edit.
     * @throws IOException if an error occurs building or sending the mail.
     */
    protected void _sendErrorEmail() throws IOException
    {
        Set<UserIdentity> users = _rightManager.getAllowedUsers(_MAIL_RIGHT, "/cms").resolveAllowedUsers(Config.getInstance().getValueAsBoolean("runtime.mail.massive.sending"));
        
        Map<String, String> params = _getEmailParams();
        
        I18nizableText i18nSubject = new I18nizableText("plugin.cms", "PLUGINS_CMS_GLOBAL_CONTENT_CONSISTENCY_MAIL_SUBJECT");
        
        String subject = _i18nUtils.translate(i18nSubject);
        String body = _getMailPart(params);
        
        if (StringUtils.isNotEmpty(body))
        {
            _sendMails(subject, body, users, _mailFrom);
        }
    }
    
    /**
     * Get a mail part.
     * @param parameters the pipeline parameters.
     * @return the mail part.
     * @throws IOException if an error occurred
     */
    protected String _getMailPart(Map<String, String> parameters) throws IOException
    {
        Source source = null;
        InputStream is = null;
        try
        {
            String uri = _getMailUri(parameters);
            source = _sourceResolver.resolveURI(uri, null, parameters);
            is = source.getInputStream();
            
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            SourceUtil.copy(is, bos);
            
            return bos.toString("UTF-8");
        }
        finally
        {
            if (is != null)
            {
                is.close();
            }
            
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Get the pipeline uri for mail body
     * @param parameters the mail paramters
     * @return a pipeline uri 
     */
    protected String _getMailUri (Map<String, String> parameters)
    {
        return "cocoon://_plugins/cms/consistency/inconsistent-contents-mail.html";
    }
    
    /**
     * Get the report e-mail parameters.
     * @return the e-mail parameters.
     */
    protected Map<String, String> _getEmailParams()
    {
        Map<String, String> params = new HashMap<>();
        
        StringBuilder url = new StringBuilder(_baseUrl);
        url.append("/index.html?uitool=uitool-global-consistency");
        
        params.put("url", url.toString());
        
        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 userIdentity : users)
        {
            User user = _userManager.getUser(userIdentity.getPopulationId(), userIdentity.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);
                    }
                }
            }
        }
    }
    
    /**
     * Handler which tests if exists a "/contents/content" tag.
     */
    protected class ContentExistsHandler extends DefaultHandler
    {
        
        /** In content tag? */
        protected boolean _inContentsTag;
        
        /** Has content tag? */
        protected boolean _hasContent;
        
        /** True if the report has content with failures. */
        protected boolean _hasFailures;
        
        /**
         * Create a handler.
         */
        public ContentExistsHandler()
        {
            super();
        }
        
        @Override
        public void startDocument() throws SAXException
        {
            super.startDocument();
            _inContentsTag = false;
            _hasContent = false;
            _hasFailures = false;
        }
        
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException
        {
            super.startElement(uri, localName, qName, attributes);
            if ("contents".equals(localName))
            {
                _inContentsTag = true;
            }
            else if (_inContentsTag && "content".equals(localName))
            {
                _hasContent = true;
                
                String notFoundCount = attributes.getValue("not-found-count");
                String unauthorizedCount = attributes.getValue("unauthorized-count");
                String serverErrorCount = attributes.getValue("server-error-count");
                if (NumberUtils.toInt(notFoundCount, -1) > 0 || NumberUtils.toInt(unauthorizedCount, -1) > 0 || NumberUtils.toInt(serverErrorCount, -1) > 0)
                {
                    _hasFailures = true;
                }
            }
        }
        
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException
        {
            if ("contents".equals(localName))
            {
                _inContentsTag = false;
            }
            super.endElement(uri, localName, qName);
        }
        
        /**
         * Has content.
         * @return true if the XML file has a content, false otherwise.
         */
        public boolean hasContent()
        {
            return _hasContent;
        }
        
        /**
         * Has failures.
         * @return true if the XML file has at least a content with failures, false otherwise.
         */
        public boolean hasFailures()
        {
            return _hasFailures;
        }
        
    }
    
}