/*
 *  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.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configurable;
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.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.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.odfpilotage.schedulable.AbstractReportSchedulable;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.jcr.NameHelper;
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;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import jakarta.mail.MessagingException;

/**
 * The abstract class for pilotage reports.
 */
public abstract class AbstractPilotageReport extends AbstractLogEnabled implements PilotageReport, Serviceable, Initializable, PluginAware, Configurable
{
    /** Filename of the manifest to describe the ZIP content */
    public static final String MANIFEST_FILENAME = "manifest.json";

    private static final Gson __GSON = new GsonBuilder()
            .setPrettyPrinting()
            .disableHtmlEscaping()
            .create();
    
    /**
     * 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 _id;
    private I18nizableText _label;
    private String _pluginName;
    private String _mailFrom;
    private String _outputFormat;

    
    @Override
    public void initialize() throws Exception
    {
        _tmpFolder = new File(_reportHelper.getTmpPilotageFolder(), getType());
        _mailFrom = Config.getInstance().getValue("smtp.mail.from");
    }
    
    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
        _id = id;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _label = I18nizableText.parseI18nizableText(configuration.getChild("label"), "plugin." + _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);
    }

    @Override
    public String getId()
    {
        return _id;
    }
    
    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }
    
    @Override
    public boolean supports(AbstractReportSchedulable schedulable)
    {
        if (schedulable.forGenericReports() == isGeneric() && isSupportedTarget(schedulable.getTarget()))
        {
            return isCompatibleSchedulable(schedulable);
        }
        
        return false;
    }
    
    /**
     * Most of reports are generic. This method can be overridden.
     * @return <code>true</code> if the current report is generic, <code>false</code> otherwise
     */
    public boolean isGeneric()
    {
        return true;
    }
    
    /**
     * Returns <code>true</code> if the target is supported by the report.
     * @param target The target to test
     * @return <code>true</code> if the target is supported, <code>false</code> otherwise
     */
    protected abstract boolean isSupportedTarget(PilotageReportTarget target);

    /**
     * Check if the given schedulable is compatible with the current
     * @param schedulable The schedulable to test
     * @return <code>true</code> if the schedulable is compatible with the report
     */
    protected boolean isCompatibleSchedulable(AbstractReportSchedulable schedulable)
    {
        return true;
    }
    
    /**
     * 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;
    }

    /**
     * Get the output format of the report.
     * @return The output format
     */
    protected String getOutputFormat()
    {
        return _outputFormat;
    }
    
    /**
     * Get the list of supported output formats
     * @return A {@link Set} of supported output formats
     */
    protected Set<String> getSupportedOutputFormats()
    {
        return Set.of(OUTPUT_FORMAT_DOC, OUTPUT_FORMAT_XLS);
    }
    
    /**
     * Get the output format of the report.
     * @return The output format
     */
    protected boolean isSupportedFormat()
    {
        return getSupportedOutputFormats().contains(getOutputFormat());
    }

    /**
     * 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);
            _outputFormat = reportParameters.get(PARAMETER_OUTPUT_FORMAT);
            
            if (!isSupportedFormat())
            {
                throw new UnsupportedOperationException("Impossible to launch the report '" + getType() + "' with the output format '" + getOutputFormat() + "'.");
            }

            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 '{}'.", getType(), e);
        }
        finally
        {
            PilotageFile pilotageFile = new PilotageFile(PilotageReportStatus.FAIL, null);
            try
            {
                pilotageFile = createZipFile(_tmpFolder, target, reportParameters, 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 filename without the extension
     * @param xmlFile the file to be converted
     * @throws IOException if an error occurs
     */
    protected void convertReport(File outputFolder, String fileName, File xmlFile) throws IOException
    {
        String completeFileName = fileName + "." + getOutputFormat();
        
        Source source = null;
        try
        {
            
            // Transform XML to configured output format
            source = _sourceResolver.resolveURI("cocoon://_plugins/odf-pilotage/" + getPipeline(outputFolder.getName()) + "/" + completeFileName, null, Map.of("reportPluginName", getPluginName()));
            try (InputStream is = source.getInputStream())
            {
                // Delete existing file
                File file = new File(outputFolder, completeFileName);
                FileUtils.deleteQuietly(file);
                file.createNewFile();
                
                // Save file
                try (OutputStream os = new FileOutputStream(file))
                {
                    IOUtils.copy(is, os);
                }
            }
        }
        finally
        {
            if (source != null)
            {
                _sourceResolver.release(source);
            }
        }
    }
    
    /**
     * Compress a folder to zip format.
     * @param folderToZip the folder to be compressed
     * @param target The target of the report
     * @param reportParameters The report parameters
     * @param contextName the name of the report context
     * @return The pilotage file
     * @throws IOException if an exception occurs
     */
    protected PilotageFile createZipFile(File folderToZip, PilotageReportTarget target, Map<String, String> reportParameters, String contextName) throws IOException
    {
        if (StringUtils.isEmpty(contextName))
        {
            return new PilotageFile(PilotageReportStatus.FAIL, null);
        }
        
        File zipFile = new File(_reportHelper.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)))
        {
            // Ajout du manifest.json
            addManifest(zos, target, reportParameters);
            
            // Ajout des fichiers générés
            for (File file : files)
            {
                try (FileInputStream is = new FileInputStream(file))
                {
                    zos.putNextEntry(new ZipEntry(file.getName()));
                    is.transferTo(zos);
                }
                finally
                {
                    zos.closeEntry();
                }
            }
        }
        
        return new PilotageFile(PilotageReportStatus.SUCCESS, zipFile);
    }
    
    /**
     * Add the manifest to JSON format to the ZIP.
     * @param zos The ZIP output stream
     * @param target The target of the report
     * @param reportParameters The report parameters
     * @throws IOException if an exception occurs
     */
    protected void addManifest(ZipOutputStream zos, PilotageReportTarget target, Map<String, String> reportParameters) throws IOException
    {
        Map<String, Object> manifestData = new HashMap<>();
        manifestData.put("type", getId());
        manifestData.put("date", _currentFormattedDate);
        manifestData.put("target", target.name().toLowerCase());
        manifestData.putAll(reportParameters);
        
        String json = __GSON.toJson(manifestData);
        try
        {
            zos.putNextEntry(new ZipEntry(MANIFEST_FILENAME));
            IOUtils.write(json, zos, StandardCharsets.UTF_8);
        }
        finally
        {
            zos.closeEntry();
        }
    }
    
    /**
     * 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.newMail()
                              .withSubject(subject)
                              .withTextBody(body)
                              .withAttachments(attachments)
                              .withRecipient(recipient)
                              .withSender(_mailFrom)
                              .sendMail();
            }
            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 String getReportName()
    {
        return _i18nUtils.translate(getLabel());
    }

    /**
     * Build the ZIP name.
     * @param contextName The report context name
     * @return The full ZIP name
     */
    protected String _buildZipName(String contextName)
    {
        return NameHelper.filterName(getType() + "-" + getOutputFormat() + "-" + 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;
        }
    }
}