/*
 *  Copyright 2015 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.web.skin;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.stream.Collectors;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.io.FileUtils;
import org.apache.xml.serializer.OutputPropertiesFactory;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

import org.ametys.core.ui.Callable;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.CategorizedElementDefinitionHelper;
import org.ametys.runtime.model.DefinitionAndValue;
import org.ametys.runtime.model.ElementDefinition;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.util.AmetysHomeHelper;
import org.ametys.web.cocoon.I18nTransformer;
import org.ametys.web.cocoon.I18nUtils;
import org.ametys.web.impl.model.type.xsl.XSLElementType;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;

/**
 * DAO for manipulating skins
 */
public class SkinDAO extends AbstractLogEnabled implements Serviceable, Component, Contextualizable
{
    /** The avalon role*/
    public static final String ROLE = SkinDAO.class.getName();
    
    private static final String __LICENCE = "\n"
            + "   Copyright 2012 Anyware Services\n"
            + "\n"
            + "   Licensed under the Apache License, Version 2.0 (the \"License\");\n"
            + "   you may not use this file except in compliance with the License.\n"
            + "   You may obtain a copy of the License at\n"
            + "\n"
            + "       http://www.apache.org/licenses/LICENSE-2.0\n"
            + "\n"
            + "   Unless required by applicable law or agreed to in writing, software\n"
            + "   distributed under the License is distributed on an \"AS IS\" BASIS,\n"
            + "   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
            + "   See the License for the specific language governing permissions and\n"
            + "   limitations under the License.\n"
            + "\n"; 

    /** The service manager instance */
    protected ServiceManager _manager;
    private Context _context;
    private SkinsManager _skinsManager;
    private SkinModelsManager _modelsManager;
    private SiteManager _siteManager;
    private I18nUtils _i18nUtils;
    private SkinParameterTypeExtensionPoint _skinParameterTypeEP;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _manager = manager;
        _skinsManager = (SkinsManager) manager.lookup(SkinsManager.ROLE);
        _modelsManager = (SkinModelsManager) manager.lookup(SkinModelsManager.ROLE);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(org.ametys.core.util.I18nUtils.ROLE);
        _skinParameterTypeEP = (SkinParameterTypeExtensionPoint) manager.lookup(SkinParameterTypeExtensionPoint.ROLE);
    }
    
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    /**
     * Retrieve informations on a skin
     * @param skinId The skin id
     * @return the informations of a skin
     */
    @Callable
    public Map<String, Object> getSkin(String skinId)
    {
        Map<String, Object> result = new HashMap<>();

        Skin skin = _skinsManager.getSkin(skinId);

        if (skin != null)
        {
            result.put("id", skin.getId());
            result.put("label", skin.getLabel());
            result.put("inUse", isInUse(skinId));
    
            String modelName = _modelsManager.getModelOfSkin(skin);
            result.put("model", modelName);
        }
        
        return result;
    }
    
    /**
     * Determines if a skin exists
     * @param skinId The skin id
     * @return true if skin exists.
     * @throws ProcessingException if an error occurs
     */
    @Callable
    public boolean skinExists (String skinId) throws ProcessingException
    {
        return _skinsManager.getSkins().contains(skinId);
    }
    
    /**
     * Determines if a skin is currently used by one or more sites
     * @param skinId The skin id
     * @return true if skin is currently in use
     */
    @Callable
    public boolean isInUse (String skinId)
    {
        AmetysObjectIterable<Site> sites = _siteManager.getSites();
        for (Site site : sites)
        {
            if (skinId.equals(site.getSkinId()))
            {
                return true;
            }
            
        }
        return false;
    }
    
    /**
     * Retrieve the list of available skins
     * @return a map of skins
     * @throws ProcessingException if an error occurs
     */
    @Callable
    public Map<String, Object> getSkins() throws ProcessingException
    {
        Map<String, Object> result = new HashMap<>();

        result.put("skins", _skins2JsonObject());

        return result;
    }

    private List<Object> _skins2JsonObject()
    {
        List<Object> skinsList = new ArrayList<>();
        Map<String, List<Site>> skins = new HashMap<>();
        for (String id : _skinsManager.getSkins())
        {
            skins.put(id, new ArrayList<Site>());
        }

        AmetysObjectIterable<Site> sites = _siteManager.getSites();
        for (Site site : sites)
        {
            String skinId = site.getSkinId();
            if (skinId != null)
            {
                List<Site> skin = skins.get(skinId);
    
                if (skin != null)
                {
                    skin.add(site);
                }
            }
        }

        for (String id : skins.keySet())
        {
            skinsList.add(_skin2JsonObject(id, skins.get(id)));
        }

        return skinsList;
    }

    private Map<String, Object> _skin2JsonObject(String id, List<Site> skinSites)
    {
        Map<String, Object> jsonSkin = new HashMap<>();

        Skin skin = _skinsManager.getSkin(id);

        jsonSkin.put("id", skin.getId());
        jsonSkin.put("label", skin.getLabel());
        jsonSkin.put("description", skin.getDescription());
        jsonSkin.put("iconLarge", skin.getLargeImage());
        jsonSkin.put("iconSmall", skin.getSmallImage());
        jsonSkin.put("nbSites", skinSites.size());
        jsonSkin.put("sites", skinSites.stream()
                .map(site -> site.getTitle() + " (" + site.getName() + ")")
                .collect(Collectors.joining(", ")));

        String modelName = _modelsManager.getModelOfSkin(skin);
        if (modelName != null)
        {
            SkinModel model = _modelsManager.getModel(modelName);
            if (model != null)
            {
                Map<String, Object> skinModel = new HashMap<>();

                skinModel.put("id", modelName);
                skinModel.put("name", model.getLabel());

                jsonSkin.put("model", skinModel);
            }
        }

        return jsonSkin;
    }



    /**
     * This action receive a form with the "importfile" zip file as an exported skin.
     * Replace existing skin 
     * @param skinName The skin name
     * @param tmpDirPath The directory where the zip was uploaded 
     * @param values the configuration's values. Can be empty.
     * @return The skin name
     * @throws SAXException if an error occurs during configuration file creation
     * @throws IOException if an error occurs while manipulating files
     * @throws TransformerConfigurationException if an error occurs during configuration file creation
     * @throws ProcessingException error while parsing model
     */
    @Callable
    public Map<String, Object> importSkin(String skinName, String tmpDirPath, Map<String, Object> values) throws TransformerConfigurationException, IOException, SAXException, ProcessingException
    {
        Map<String, Object> result = new HashMap<>();
        
        File ametysTmpDir = AmetysHomeHelper.getAmetysHomeTmp();
        File tmpDir = new File(ametysTmpDir, tmpDirPath.replace('/', File.separatorChar));
        if (tmpDir.isDirectory())
        {
            File rootLocation = new File(_skinsManager.getSkinsLocation());

            if (!values.isEmpty())
            {
                SkinParametersModel model = new SkinParametersModel(skinName, tmpDir, _skinParameterTypeEP, _context, _manager);
                Map<String, ElementDefinition> flatDefinitions = model.getFlatDefinitions();
                Map<String, DefinitionAndValue> definitionAndValues = _getDefinitionAndValues(values, flatDefinitions);
                
                Map<String, List<I18nizableText>> errorFields = CategorizedElementDefinitionHelper.validateValuesForWriting(definitionAndValues, LoggerFactory.getLogger(getClass()));
                if (!errorFields.isEmpty())
                {
                    result.put("errors", errorFields);
                    return result;
                }
                
                _createConfigFile(model, tmpDir, values);
            }
            
            // If exists: remove.
            File skinDir = new File(rootLocation, skinName);
            if (skinDir.exists())
            {
                FileUtils.deleteDirectory(skinDir);
            }

            // Move to skins
            FileUtils.moveDirectory(tmpDir, skinDir);

            _i18nUtils.reloadCatalogues();
            I18nTransformer.needsReload();
        }
        
        result.put("skinId", skinName);
        return result;
    }
    
    /**
     * Configure a skin
     * @param skinName the skin name
     * @param values the configuration's values
     * @return A map with "errors" key that is a map &lt;errorName&gt; &lt;errorMessage&gt;
     * @throws SAXException if an error occurs during configuration file creation
     * @throws IOException if an error occurs during configuration file creation
     * @throws TransformerConfigurationException if an error occurs during configuration file creation
     * @throws ProcessingException error while parsing model
     */
    @Callable
    public Map<String, Object> configureSkin (String skinName,  Map<String, Object> values) throws TransformerConfigurationException, IOException, SAXException, ProcessingException
    {
        Map<String, Object> result = new HashMap<>();
        
        Skin skin = _skinsManager.getSkin(skinName);
        
        File skinDir = new File (skin.getLocation());
        SkinParametersModel model = new SkinParametersModel(skinName, skinDir, _skinParameterTypeEP, _context, _manager);
        
        Map<String, ElementDefinition> flatDefinitions = model.getFlatDefinitions();
        Map<String, DefinitionAndValue> definitionAndValues = _getDefinitionAndValues(values, flatDefinitions);
        
        Map<String, List<I18nizableText>> errorFields = CategorizedElementDefinitionHelper.validateValuesForWriting(definitionAndValues, LoggerFactory.getLogger(getClass()));
        if (!errorFields.isEmpty())
        {
            result.put("errors", errorFields);
            return result;
        }
        
        //Delete the old file only if no error found
        File configFile = new File(skinDir, "stylesheets" + File.separator + "config" + File.separator + "config.xsl");
        if (configFile.exists())
        {
            FileUtils.deleteQuietly(configFile);
        }
        _createConfigFile(model, skinDir, values);
        
        _i18nUtils.reloadCatalogues();
        I18nTransformer.needsReload();
        
        result.put("skinId", skinName);
        return result;
    }
    
    private Map<String, DefinitionAndValue> _getDefinitionAndValues(Map<String, Object> values, Map<String, ElementDefinition> flatDefinitions)
    {
        Map<String, DefinitionAndValue> definitionAndValues = new HashMap<>();
        for (Map.Entry<String, ElementDefinition> definitionEntry : flatDefinitions.entrySet())
        {
            Object value = values.get(definitionEntry.getKey());
            ElementDefinition definition = definitionEntry.getValue();
            if (definition != null)
            {
                DefinitionAndValue definitionAndValue = new DefinitionAndValue<>(null, definition, value);
                definitionAndValues.put(definitionEntry.getKey(), definitionAndValue);
            }
        }
        return definitionAndValues;
    }
    
    private void _createConfigFile(SkinParametersModel model, File skinDir, Map<String, Object> values) throws IOException, SAXException, TransformerConfigurationException, ProcessingException
    {
        File configFile = new File(skinDir, "stylesheets" + File.separator + "config" + File.separator + "config.xsl");
        
        Map<String, ElementDefinition> flatDefinitions = model.getFlatDefinitions();
        
        SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory.newInstance();
        TransformerHandler handler = factory.newTransformerHandler();
        
        try (OutputStream os = new BufferedOutputStream(new FileOutputStream(configFile)))
        {
            Result result = new StreamResult(os);
            
            Properties format = new Properties();
            format.put(OutputKeys.METHOD, "xml");
            format.put(OutputKeys.ENCODING, "UTF-8");
            format.put(OutputKeys.INDENT, "yes");
            format.put(OutputKeys.OMIT_XML_DECLARATION, "no");
            format.put(OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, "4");
            
            handler.setResult(result);
            handler.getTransformer().setOutputProperties(format);
            
            handler.startDocument();
            
            AttributesImpl attrs = new AttributesImpl();
            attrs.addCDATAAttribute("version", "1.0");
            attrs.addCDATAAttribute("xmlns:xsl", "http://www.w3.org/1999/XSL/Transform");
            
            handler.comment(__LICENCE.toCharArray(), 0, __LICENCE.length());
            XMLUtils.startElement(handler, "xsl:stylesheet", attrs);
            
            for (Entry<String, Object> variable : values.entrySet())
            {
                ElementDefinition elementDefinition = flatDefinitions.get(variable.getKey());
                if (elementDefinition != null)
                {
                    ElementType type = elementDefinition.getType();
                    if (type instanceof XSLElementType)
                    {
                        ((XSLElementType) type).write(handler, elementDefinition.getName(), variable.getValue());
                    }
                }
            }
            
            XMLUtils.endElement(handler, "xsl:stylesheet");
            
            handler.endDocument();
        }
    }
    
    /**
     * Duplicate an existing skin
     * @param skinId The new skin id
     * @param originalSkinId The original skin id
     * @return An error message, or null if successful
     * @throws IOException if an I/O exception occurs during copy
     */
    @Callable
    public String copySkin(String skinId, String originalSkinId) throws IOException
    {
        // Check if exists
        if (_skinsManager.getSkins().contains(skinId))
        {
            return "already-exists";
        }
        
        File srcDir = new File(_skinsManager.getSkinsLocation() + File.separator + originalSkinId);
        File destDir = new File(_skinsManager.getSkinsLocation() + File.separator + skinId);
        
        FileUtils.copyDirectory(srcDir, destDir, new ModelFileFilter(srcDir), false);
        
        _i18nUtils.reloadCatalogues();
        I18nTransformer.needsReload();
        
        return null;
    }
    
    /**
     * Delete a skin
     * @param skinId The skin id
     * @return the skin id
     * @throws IOException if an I/O exception occurs during deletion
     */
    @Callable
    public String deleteSkin(String skinId) throws IOException
    {
        Skin skin = _skinsManager.getSkin(skinId);
        File file = skin.getFile();
        
        if (file.exists())
        {
            FileUtils.deleteDirectory(file);
        }
        
        return skinId;
    }
    
    /**
     * Parse the values file and make a liaison with the definitions, to return a collection of {@link DefinitionAndValue}
     * @param skinDir folder of the skin
     * @param flatDefinitions map of {@link ElementDefinition}
     * @return a {@link Collection} of {@link DefinitionAndValue} using flatDefinitions and the values found in skinDir
     * @throws Exception Impossible to read the file
     */
    public Collection<DefinitionAndValue> readValues(File skinDir, Map<String, ElementDefinition> flatDefinitions) throws Exception
    {
        Collection<DefinitionAndValue> definitionAndValues = new ArrayList<>();
        String fileName = "stylesheets" + File.separator + "config" + File.separator + "config.xsl";
        File configFile = new File(skinDir, fileName);
        boolean fileExists = configFile.exists();

        if (fileExists)
        {
            Configuration configuration = new DefaultConfigurationBuilder().buildFromFile(configFile);
            for (Entry<String, ElementDefinition> entry : flatDefinitions.entrySet())
            {
                String parameterName = entry.getKey();
                ElementDefinition definition = entry.getValue();
                if (definition != null)
                {
                    ElementType type = definition.getType();
                    if (type instanceof XSLElementType)
                    {
                        Object value = ((XSLElementType) type).read(configuration, parameterName);
                        DefinitionAndValue definitionAndValue = new DefinitionAndValue<>(null, definition, value);
                        definitionAndValues.add(definitionAndValue);
                    }
                }
            }
            
            return definitionAndValues;
        }
        
        return null;
    }
}