/*
 *  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.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.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.xml.sax.SAXException;

import org.ametys.core.ui.Callable;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.metadata.UnknownMetadataException;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.util.AmetysHomeHelper;
import org.ametys.web.cocoon.I18nTransformer;
import org.ametys.web.cocoon.I18nUtils;
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
{
    /** 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"; 

    
    private SkinsManager _skinsManager;
    private SkinModelsManager _modelsManager;
    private SiteManager _siteManager;
    private I18nUtils _i18nUtils;

    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _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);
    }
    
    /**
     * 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)
        {
            try
            {
                if (skinId.equals(site.getSkinId()))
                {
                    return true;
                }
            }
            catch (UnknownMetadataException e)
            {
                // No skin is defined for this site
            }
            
        }
        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)
        {
            try
            {
                String skinId = site.getSkinId();
                List<Site> skin = skins.get(skinId);

                if (skin != null)
                {
                    skin.add(site);
                }
            }
            catch (UnknownMetadataException e)
            {
                // Nothing
            }
        }

        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
     */
    @Callable
    public Map<String, Object> importSkin(String skinName, String tmpDirPath, Map<String, Object> values) throws TransformerConfigurationException, IOException, SAXException
    {
        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())
            {
                //Map<String, Errors> errors = new HashMap<>();
                _createConfigFile(tmpDir, values/*, errors*/);
                
                /*if (errors.size() > 0)
                {
                    List<Map<String, Object>> allErrors = new ArrayList<>();
                    
                    for (Map.Entry<String, Errors> entry : errors.entrySet())
                    {
                        Map<String, Object> error = new HashMap<>();
                        error.put("name", entry.getKey());
                        
                        List<I18nizableText> errorMessages = entry.getValue().getErrors();
                        error.put("errorMessages", errorMessages);
                        
                        allErrors.add(error);
                    }
                    
                    result.put("errors", allErrors);
                    return result;
                }*/
            }
            
            // 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
     */
    @Callable
    public Map<String, Object> configureSkin (String skinName,  Map<String, Object> values) throws TransformerConfigurationException, IOException, SAXException
    {
        Map<String, Object> result = new HashMap<>();
        
        Skin skin = _skinsManager.getSkin(skinName);
        
        File skinDir = new File (skin.getLocation());
        
        File configFile = new File(skinDir, "stylesheets" + File.separator + "config" + File.separator + "config.xsl");
        if (configFile.exists())
        {
            FileUtils.deleteQuietly(configFile);
        }
        
        // Map<String, Errors> errors = new HashMap<>();
        _createConfigFile(skinDir, values/*, errors*/);
        
        /*if (errors.size() > 0)
        {
            List<Map<String, Object>> allErrors = new ArrayList<>();
            
            for (Map.Entry<String, Errors> entry : errors.entrySet())
            {
                Map<String, Object> error = new HashMap<>();
                error.put("name", entry.getKey());
                
                List<I18nizableText> errorMessages = entry.getValue().getErrors();
                error.put("errorMessages", errorMessages);
                
                allErrors.add(error);
            }
            
            result.put("errors", allErrors);
            return result;
        }*/
        
        _i18nUtils.reloadCatalogues();
        I18nTransformer.needsReload();
        
        result.put("skinId", skinName);
        return result;
    }
    
    private void _createConfigFile(File skinDir, Map<String, Object> values/*, Map<String, Errors> allErrors*/) throws IOException, SAXException, TransformerConfigurationException
    {
        // TODO Handle server errors
        
        File configFile = new File(skinDir, "stylesheets" + File.separator + "config" + File.separator + "config.xsl");
        
        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())
            {
                attrs.clear();
                attrs.addCDATAAttribute("name", variable.getKey());
                
                XMLUtils.createElement(handler, "xsl:variable", attrs, ParameterHelper.valueToString(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;
    }
}