/*
 *  Copyright 2018 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.plugins.odfpilotage.report;

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.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.mail.MessagingException;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.user.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.mail.SendMailHelper;
import org.ametys.odf.ODFHelper;
import org.ametys.odf.enumeration.OdfReferenceTableHelper;
import org.ametys.plugins.odfpilotage.helper.PilotageHelper;
import org.ametys.plugins.odfpilotage.helper.ReportHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

import com.google.common.collect.ImmutableList;

/**
 * The abstract class for pilotage reports.
 */
public abstract class AbstractPilotageReport extends AbstractLogEnabled implements PilotageReport, Serviceable, Initializable, PluginAware
{
    /**
     * The enumerator for different pilotage report status
     */
    public enum PilotageReportStatus
    {
        /** If the report has failed */
        FAIL,
        /** If the report is a success */
        SUCCESS,
        /** If there are no file in the report */
        NO_FILE
    }
    
    /** The source resolver */
    protected SourceResolver _sourceResolver;
    
    /** The pilotage helper */
    protected PilotageHelper _pilotageHelper;
    
    /** The ametys object resolver */
    protected AmetysObjectResolver _resolver;
    
    /** The report helper */
    protected ReportHelper _reportHelper;
    
    /** The ODF enumeration helper */
    protected OdfReferenceTableHelper _refTableHelper;
    
    /** The ODF helper */
    protected ODFHelper _odfHelper;
    
    /** The user manager */
    protected UserManager _userManager;
    
    /** The I18N utils */
    protected I18nUtils _i18nUtils;
    
    /** The tmp folder */
    protected File _tmpFolder;
    
    /** The current date formatted to yyyy-MM-dd */
    protected String _currentFormattedDate;

    private String _pluginName;
    private String _mailFrom;
    
    @Override
    public void initialize() throws Exception
    {
        _tmpFolder = new File(_pilotageHelper.getTmpPilotageFolder(), getType());
        _mailFrom = Config.getInstance().getValue("smtp.mail.from");
    }
    
    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
        _pilotageHelper = (PilotageHelper) manager.lookup(PilotageHelper.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _reportHelper = (ReportHelper) manager.lookup(ReportHelper.ROLE);
        _refTableHelper = (OdfReferenceTableHelper) manager.lookup(OdfReferenceTableHelper.ROLE);
        _odfHelper = (ODFHelper) manager.lookup(ODFHelper.ROLE);
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
    }

    /**
     * Launch a report generation on an orgunit.
     * @param reportParameters The report parameters
     * @return the name of the generated file
     * @throws Exception if an exception occurs
     */
    protected abstract String launchByOrgUnit(Map<String, String> reportParameters) throws Exception;

    /**
     * Launch a report generation on a program.
     * @param reportParameters The report parameters
     * @return the name of the generated file
     * @throws Exception if an exception occurs
     */
    protected abstract String launchByProgram(Map<String, String> reportParameters) throws Exception;
    
    /**
     * Get the name of the report
     * @return The report name
     */
    protected abstract String getType();
    
    /**
     * Get the plugin name to build the pipeline.
     * @return The plugin name
     */
    protected String getPluginName()
    {
        return _pluginName;
    }

    /**
     * Build the pipeline to launch the transformation.
     * @param outputFolderName The name of the output folder name
     * @return The pipeline for transformation
     */
    protected String getPipeline(String outputFolderName)
    {
        return "report/" + getType() + "/" + outputFolderName;
    }
    
    @Override
    public synchronized void launch(PilotageReportTarget target, Map<String, String> reportParameters, UserIdentity user)
    {
        getLogger().info("Début du rapport de pilotage");
        long time_0 = System.currentTimeMillis();

        String contextName = null;
        try
        {
            FileUtils.deleteQuietly(_tmpFolder);
            _tmpFolder.mkdir();
            _currentFormattedDate = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE);

            switch (target)
            {
                case PROGRAM:
                    contextName = launchByProgram(reportParameters);
                    break;
                case ORGUNIT:
                    contextName = launchByOrgUnit(reportParameters);
                    break;
                default:
                    break;
            }
        }
        catch (Exception e)
        {
            getLogger().error("Erreur d'écriture du rapport.", e);
        }
        finally
        {
            PilotageFile pilotageFile = new PilotageFile(PilotageReportStatus.FAIL, null);
            try
            {
                pilotageFile = createZipFile(_tmpFolder, contextName);
            }
            catch (Exception e)
            {
                getLogger().error("Une erreur est survenue lors de la compression des rapports.", e);
            }
            finally
            {
                sendMail(pilotageFile, user);
                
                FileUtils.deleteQuietly(_tmpFolder);
                _currentFormattedDate = null;
                
                long time_1 = System.currentTimeMillis();
                getLogger().info("Calcul et écriture du rapport de pilotage effectué en {} ms.", time_1 - time_0);
            }
        }
    }

    /**
     * Convert the report from XML to the required format
     * @param outputFolder folder where the file will stay temporarily
     * @param fileName the name of the file
     * @param xmlFile the file to be converted
     * @throws IOException if an error occurs
     */
    protected void convertReport(File outputFolder, String fileName, File xmlFile) throws IOException
    {
        Source source = null;
        try
        {
            // Transform XML to HTML-XLS
            source = _sourceResolver.resolveURI("cocoon://_plugins/" + getPluginName() + "/" + getPipeline(outputFolder.getName()) + "/" + fileName);
            try (InputStream is = source.getInputStream())
            {
                // Delete existing file
                File file = new File(outputFolder, fileName);
                FileUtils.deleteQuietly(file);
                file.createNewFile();
                
                // Save file
                try (OutputStream os = new FileOutputStream(file))
                {
                    IOUtils.copy(is, os);
                }
            }
        }
        finally
        {
            FileUtils.deleteQuietly(xmlFile);
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Compress a folder to zip format 
     * @param folderToZip the folder to be compressed
     * @param contextName the name of the report context
     * @return The pilotage file
     * @throws IOException if an exception occurs
     */
    protected PilotageFile createZipFile(File folderToZip, String contextName) throws IOException
    {
        if (StringUtils.isEmpty(contextName))
        {
            return new PilotageFile(PilotageReportStatus.FAIL, null);
        }
        
        File zipFile = new File(_pilotageHelper.getPilotageFolder(), _buildZipName(contextName));

        FileUtils.deleteQuietly(zipFile);
        File[] files = folderToZip.listFiles();

        if (files.length == 0)
        {
            getLogger().warn("Aucun fichier généré");
            return new PilotageFile(PilotageReportStatus.NO_FILE, null);
        }

        getLogger().info("Création de l'archive");
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile)))
        {
            for (File file : files)
            {
                try (FileInputStream is = new FileInputStream(file))
                {
                    byte[] buf = new byte[1024];
                    int len;
                    zos.putNextEntry(new ZipEntry(file.getName()));
                    while ((len = is.read(buf)) > 0)
                    {
                        zos.write(buf, 0, len);
                    }
                }
                finally
                {
                    zos.closeEntry();
                }
            }
        }
        
        return new PilotageFile(PilotageReportStatus.SUCCESS, zipFile);
    }
    
    /**
     * Send a mail with the ZIP file as attachment at the end of the report generation.
     * @param file the pilotage file
     * @param user the recipient if he has an email
     */
    protected void sendMail(PilotageFile file, UserIdentity user)
    {
        String recipient = Optional.ofNullable(user)
            .map(_userManager::getUser)
            .map(User::getEmail)
            .filter(StringUtils::isNotEmpty)
            .orElse(null);
        
        if (recipient != null)
        {
            String subject = getMailSubject();
            String body = getMailBody(file.getStatus());
            try
            {
                File zipFile = file.getZipFile();
                List<File> attachments = new ArrayList<>();
                if (zipFile != null && zipFile.exists())
                {
                    attachments.add(zipFile);
                }
                
                getLogger().info("Envoi du rapport par mail");
                SendMailHelper.sendMail(subject, null, body, attachments, recipient, _mailFrom);
            }
            catch (MessagingException | IOException e)
            {
                getLogger().warn("Fail to send email to {}", recipient, e); 
            }
        }
    }

    /**
     * The mail subject.
     * @return The subject of the mail
     */
    protected String getMailSubject()
    {
        return _i18nUtils.translate(new I18nizableText("plugin.odf-pilotage", "PLUGINS_ODF_PILOTAGE_MAIL_SUBJECT", ImmutableList.of(getReportName())));
    }

    /**
     * The mail body.
     * @param status the status of the pilotage report
     * @return The body of the mail
     */
    protected String getMailBody(PilotageReportStatus status)
    {
        String key = "PLUGINS_ODF_PILOTAGE_MAIL_BODY_" + status.name();
        return _i18nUtils.translate(new I18nizableText("plugin.odf-pilotage", key, ImmutableList.of(getReportName())));
    }
    
    /**
     * The report name to add in the mail.
     * @return The report name
     */
    protected abstract String getReportName();

    /**
     * Build the ZIP name.
     * @param contextName The report context name
     * @return The full ZIP name
     */
    private String _buildZipName(String contextName)
    {
        return FilterNameHelper.filterName(getType() + "-" + contextName + "-" + _currentFormattedDate) + ".zip";
    }
    
    /**
     * Object representing a pilotage file
     * Containing the zip file and the report status
     */
    public static class PilotageFile
    {
        private File _zipFile;
        private PilotageReportStatus _status;
        
        /**
         * The pilotage file constructor
         * @param status the status
         * @param zipFile the zip file, can be null or non-existent
         */
        public PilotageFile(PilotageReportStatus status, File zipFile)
        {
            this._zipFile = zipFile;
            this._status = status;
        }
        
        /**
         * Get the pilotage report status
         * @return the pilotage report status
         */
        public PilotageReportStatus getStatus()
        {
            return _status;
        }
        
        /**
         * Set the pilotage report status
         * @param status the status
         */
        public void setStatus(PilotageReportStatus status)
        {
            this._status = status;
        }
        
        /**
         * Get the zip file
         * @return the zip file
         */
        public File getZipFile()
        {
            return _zipFile;
        }
        
        /**
         * Set the zip file
         * @param zipFile the zip file
         */
        public void setZipFile(File zipFile)
        {
            this._zipFile = zipFile;
        }
    }
}