/*
 *  Copyright 2014 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.odf.export.pdf;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

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.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.excalibur.source.SourceResolver;
import org.apache.excalibur.source.SourceUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.core.authentication.AuthenticateAction;
import org.ametys.core.engine.BackgroundEngineHelper;
import org.ametys.core.user.User;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.util.AmetysHomeHelper;

/**
 * Content consistency engine: generate consistency information for all contents.
 * Sends a report e-mail if there are inconsistencies.
 */
public class GeneratePDFEngine implements Runnable
{
    /** The logger. */
    protected static final Logger _LOGGER = LoggerFactory.getLogger(GeneratePDFEngine.class.getName());
    
    /** Is the thread running ? */
    private static boolean _RUNNING;
    
    /** The avalon context. */
    protected Context _context;

    /** The cocoon environment context. */
    protected org.apache.cocoon.environment.Context _environmentContext;
    
    /** The service manager. */
    protected ServiceManager _manager;
    
    /** The avalon source resolver. */
    protected SourceResolver _sourceResolver;
    
    /** The i18n utils. */
    protected I18nUtils _i18nUtils;
    
    /** The catalog directory. */
    protected File _catalogRootDirectory;
    
    /** Is the engine initialized ? */
    protected boolean _initialized;
    
    /** The sender of the email */
    protected String _mailFrom;
    
    /** The contextual parameters */
    protected Map<String, Object> _contextualParameters;
    
    private User _issuer;
    private String _catalog;

    /**
     * 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.
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        
        // initialize the parameters
        _mailFrom = Config.getInstance().getValueAsString("smtp.mail.from");
        
        _catalogRootDirectory = new File(AmetysHomeHelper.getAmetysHomeData(), "odf/catalog");
        
        _initialized = true;
    }
    
    /**
     * Configure the engine (called by the scheduler).
     * @param configuration the component configuration.
     * @throws ConfigurationException if an error occurs
     */
    public void configure(Configuration configuration) throws ConfigurationException
    {
        // Ignore
    }
    
    /**
     * Set the contextual parameters
     * @param contextualParameters the contextual parameters
     */
    public void setContextualParameters(Map<String, Object> contextualParameters)
    {
        _contextualParameters = contextualParameters;
    }
    
    /**
     * Set the code of catalogue to generate
     * @param code the code
     */
    public void setCatalog (String code)
    {
        _catalog = code;
    }
    
    /**
     * Set the user who launched the PDF export
     * @param issuer the issuer
     */
    public void setIssuer(User issuer)
    {
        _issuer = issuer;
    }
    
    /**
     * Check the initialization and throw an exception if not initialized.
     */
    protected void _checkInitialization()
    {
        if (!_initialized)
        {
            String message = "The synchronization component has to be initialized before being run";
            _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.
     */
    public static boolean isRunning()
    {
        return _RUNNING;
    }
    
    private static void setRunning(boolean running)
    {
        _RUNNING = running;
    }
    
    @Override
    public void run()
    {
        Map<String, Object> environmentInformation = null;
        boolean error = false; 
        
        try
        {
            _LOGGER.info("Preparing to generate the pdf catalog...");
            
            _checkInitialization();
            
            // Create the environment.
            environmentInformation = BackgroundEngineHelper.createAndEnterEngineEnvironment(_manager, _environmentContext, new SLF4JLoggerAdapter(_LOGGER));
            BackgroundEnvironment environment = (BackgroundEnvironment) environmentInformation.get("environment");
            
            Request request = (Request) environment.getObjectModel().get(ObjectModelHelper.REQUEST_OBJECT);
            
            _generatePDF(request);
        }
        catch (Exception e)
        {
            error = true;
            _LOGGER.error("An error occurred while generating the PDF catalog.", e);
        }
        finally
        {
            _sendMail(error);
            
            // Leave the environment.
            if (environmentInformation != null)
            {
                BackgroundEngineHelper.leaveEngineEnvironment(environmentInformation);
            }
            // Dispose of the resources.
            _dispose();
            
            if (!error)
            {
                _LOGGER.info("The pdf catalog has been generated.");
            }
        }
    }
    
    /**
     * Dispose of the resources and looked-up components.
     */
    protected void _dispose()
    {
        _sourceResolver = null;
        _environmentContext = null;
        _context = null;
        _manager = null;
        
        _initialized = false;
    }
    
    /**
     * Generates the PDF file. Checks that there is no current generation process.
     * @param request The request
     * @throws AmetysRepositoryException if an error occurs.
     * @throws IOException if an I/O error occurs.
     */
    protected void _generatePDF(Request request) throws AmetysRepositoryException, IOException
    {
        if (isRunning())
        {
            _LOGGER.error("Cannot start the generation, as the engine is running at the time.");
        }
        else
        {
            try
            {
                setRunning(true);
                
                // Generate the report.
                _doGeneratePDF(request);
            }
            finally
            {
                setRunning(false);
            }
        }
    }
    
    /**
     * Generate the PDF file
     * @param request the request
     * @throws IOException if an I/O error occurs.
     */
    protected void _doGeneratePDF(Request request) throws IOException
    {
        SitemapSource source = null;
        File pdfTmpFile = null;
        try
        {
            FileUtils.forceMkdir(_catalogRootDirectory);
            
            File catalogDir = new File (_catalogRootDirectory, _catalog);
            if (!catalogDir.exists())
            {
                catalogDir.mkdir();
            }
            
            File langDir = new File (catalogDir, getLanguage());
            if (!langDir.exists())
            {
                langDir.mkdir();
            }
            
            request.setAttribute(AuthenticateAction.REQUEST_ATTRIBUTE_INTERNAL_ALLOWED, true);
            
            // Resolve the export to the appropriate pdf url.
            source = (SitemapSource) _sourceResolver.resolveURI("cocoon://_plugins/odf/programs/" + _catalog + "/" + getLanguage() + "/catalog.pdf");
            
            // Save the pdf into a temporary file.
            pdfTmpFile = new File(langDir, "catalog.tmp.pdf");
            
            
            try (OutputStream pdfTmpOs = new FileOutputStream(pdfTmpFile); InputStream sourceIs = source.getInputStream())
            {
                SourceUtil.copy(sourceIs, pdfTmpOs);
            }
            
            // If all went well until now, rename the temporary file 
            File catalogFile = new File(langDir, "catalog.pdf");
            if (catalogFile.exists())
            {
                catalogFile.delete();
            }
            
            if (!pdfTmpFile.renameTo(catalogFile))
            {
                throw new IOException("Fail to rename catalog.tmp.pdf to catalog.pdf");
            }
            
            _sendMail(false);
        }
        finally
        {
            if (pdfTmpFile != null)
            {
                FileUtils.deleteQuietly(pdfTmpFile);
            }
            
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Get the language for export
     * @return The language
     */
    protected String getLanguage()
    {
        if (_contextualParameters.containsKey("lang"))
        {
            return (String) _contextualParameters.get("lang");
        }
        return Config.getInstance().getValueAsString("odf.programs.lang");
    }
    
    /**
     * Sends an email to the user who has launched the generation of PDF
     * @param error true if the catalog wasn't generated successfully, false otherwise.
     */
    protected void _sendMail(boolean error)
    {
        String recipient = _issuer.getEmail();
        
        if (!StringUtils.isEmpty(recipient))
        {
            String subject = getMailSubject();
            String body = error ? getFailureMailBody() : getSuccessMailBody();
            
            try
            {
                SendMailHelper.sendMail(subject, null, body, recipient, _mailFrom);
            }
            catch (MessagingException e)
            {
                if (_LOGGER.isWarnEnabled())
                {
                    _LOGGER.warn("Fail to send email to " + recipient, e); 
                }
            }
        }
        
    }
    
    /**
     * Get the subject of mail
     * @return the subject
     */
    protected String getMailSubject ()
    {
        I18nizableText subjectKey = new I18nizableText("plugin.odf", "PLUGINS_ODF_PDF_EXPORT_MAIL_SUBJECT");
        return _i18nUtils.translate(subjectKey, getLanguage()); // FIXME Use user preference language
    }
    
    /**
     * Get the body of mail in case of success
     * @return the body
     */
    protected String getSuccessMailBody ()
    {
        List<String> params = new ArrayList<>();
        
        String downloadLink = StringUtils.removeEndIgnoreCase(Config.getInstance().getValueAsString("cms.url"), "index.html");
        downloadLink += (downloadLink.endsWith("/") ? "" : "/") + "plugins/odf/download/" + _catalog + "/" + getLanguage() + "/catalog.pdf";
        params.add(downloadLink); // {0}
        
        I18nizableText subjectKey = new I18nizableText("plugin.odf", "PLUGINS_ODF_PDF_EXPORT_MAIL_BODY_SUCCESS", params);
        return _i18nUtils.translate(subjectKey, null); // FIXME Use user preference language
    }
    
    /**
     * Get the body of mail in case of failure
     * @return the body
     */
    protected String getFailureMailBody ()
    {
        I18nizableText subjectKey = new I18nizableText("plugin.odf", "PLUGINS_ODF_PDF_EXPORT_MAIL_BODY_FAILURE");
        return _i18nUtils.translate(subjectKey, getLanguage()); // FIXME Use user preference language
    }
}