/*
 *  Copyright 2012 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.core.util;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.component.ComponentException;
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.components.ContextHelper;
import org.apache.cocoon.i18n.Bundle;
import org.apache.cocoon.i18n.BundleFactory;
import org.apache.cocoon.xml.ParamSaxBuffer;
import org.apache.cocoon.xml.SaxBuffer;
import org.apache.cocoon.xml.SaxBuffer.Characters;
import org.apache.commons.lang3.LocaleUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.TraversableSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import org.ametys.core.DevMode;
import org.ametys.core.DevMode.DEVMODE;
import org.ametys.core.cache.AbstractCacheManager;
import org.ametys.core.cache.Cache;
import org.ametys.core.cocoon.XMLResourceBundle;
import org.ametys.plugins.core.impl.cache.AbstractCacheKey;
import org.ametys.runtime.i18n.FormatableI18nizable;
import org.ametys.runtime.i18n.I18nizable;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.i18n.I18nizableTextParameter;
import org.ametys.runtime.plugin.PluginsManager;
import org.ametys.runtime.workspace.WorkspaceManager;

/**
 * Utils for i18n
 */
public class I18nUtils extends AbstractLogEnabled implements Component, Serviceable, Contextualizable, Initializable
{
    /** The avalon role */
    public static final String ROLE = I18nUtils.class.getName();
    
    /** i18n cache id */
    public static final String I18N_CACHE = I18nUtils.class.getName() + "$i18n";

    /** Base filename for application */
    public static final String APPLICATION = "application";
    
    /** Base filename for all other types except application (like plugin, workspace, etc.) */
    public static final String MESSAGES = "messages";
    
    /** I18n catalogues */
    protected Map<String, Location> _locations;
  
    /** The avalon context */
    protected Context _context;
    
    /** Source Resolver */
    protected SourceResolver _resolver;
    
    private BundleFactory _bundleFactory;
  
    private AbstractCacheManager _cacheManager;
    
    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _bundleFactory = (BundleFactory) manager.lookup(BundleFactory.ROLE);
        _cacheManager = (AbstractCacheManager) manager.lookup(AbstractCacheManager.ROLE);
        _resolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _createCache();

        _configure();
    }
    
    /**
     * Create the i18n cache
     */
    protected void _createCache()
    {
        _cacheManager.createMemoryCache(I18N_CACHE,
                new I18nizableText("plugin.core", "PLUGINS_CORE_I18N_CACHE_LABEL"),
                new I18nizableText("plugin.core", "PLUGINS_CORE_I18N_CACHE_DESCRIPTION"),
                true,
                null);
    }
    
    /**
     * Configure the i18n catalogue
     */
    protected void _configure ()
    {
        _locations = new HashMap<>();
        
        // initializes locations
        
        _locations.put("application", new Location(APPLICATION, new String[]{getApplicationCatalogLocation()}));
        
        // WEB-INF/param/*/i18n/
        for (String name : getParamsFoldersWithI18n())
        {
            _locations.put("param." + name, new Location(MESSAGES, new String[]{getParamCatalogLocation(name)}));
        }
        
        String type = "plugin";
        PluginsManager pm = PluginsManager.getInstance();
        for (String pluginName : pm.getPluginNames())
        {
            _locations.put(type + "." + pluginName, new Location(MESSAGES, new String[]{getOverridableCatalogLocation(type, pluginName), getDefaultCatalogLocation(type, pluginName)}));
        }
        
        type = "workspace";
        WorkspaceManager wm = WorkspaceManager.getInstance();
        for (String workspace : wm.getWorkspaceNames())
        {
            _locations.put(type + "." + workspace, new Location(MESSAGES, new String[]{getOverridableCatalogLocation(type, workspace), getDefaultCatalogLocation(type, workspace)}));
        }
    }
    
    /**
     * Get the catalog location for application.
     * context://WEB-INF/i18n
     * @return the location
     */
    public String getApplicationCatalogLocation()
    {
        return "context://WEB-INF/i18n";
    }
    
    /**
     * Get the catalog location form param.
     * context://WEB-INF/param/[name]/i18n
     * @param name the param name
     * @return the location
     */
    public String getParamCatalogLocation(String name)
    {
        return "context://WEB-INF/param/" + name + "/i18n";
    }
    
    /**
     * Get the default catalog location for most typed cases (plugin, workspace at least).
     * [type]:[name]://i18n
     * @param type the type
     * @param name the name of the element (can be a plugin, workspace, etc.)
     * @return the location
     */
    public String getDefaultCatalogLocation(String type, String name)
    {
        return type + ":" + name + "://i18n";
    }
    
    /**
     * Get the overridable catalog location for most typed cases (plugin, workspace at least).
     * context://WEB-INF/i18n/[type]s/[name]
     * @param type the type
     * @param name the name of the element (can be a plugin, workspace, etc.)
     * @return the location
     */
    public String getOverridableCatalogLocation(String type, String name)
    {
        // Transform plugin to plugins and workspace to workspaces
        return "context://WEB-INF/i18n/" + type + "s/" + name;
    }
    
    /**
     * Get the name of folders into WEB-INF/param which contains i18n catalogues
     * @return the name of folders into WEB-INF/param which contains i18n catalogues
     */
    public List<String> getParamsFoldersWithI18n()
    {
        try
        {
            Source paramsRootFolder = _resolver.resolveURI("context://WEB-INF/param");
            if (paramsRootFolder.exists() && paramsRootFolder instanceof TraversableSource)
            {
                Collection<Source> children = ((TraversableSource) paramsRootFolder).getChildren();
                
                return children.stream()
                        .filter(TraversableSource.class::isInstance)
                        .map(TraversableSource.class::cast)
                        .filter(s -> s.isCollection())
                        .filter(LambdaUtils.wrapPredicate(s -> s.getChild("i18n").exists()))
                        .map(s -> s.getName())
                        .collect(Collectors.toList());
            }
        }
        catch (IOException e)
        {
            getLogger().error("Error while fetching i18n folders in WEB-INF/param/*/i18n", e);
        }
        
        return List.of();
    }
    
    /**
     * Reload the i18n catalogues and clear cache.
     * This method should be called as soon as the list of i18n catalogue was changed, when adding a new catalogue for example.
     */
    public void reloadCatalogues ()
    {
        clearCache();
        _configure();
    }
    
    /**
     * Get the translation of the key.
     * @param text The i18n key to translate
     * @return The translation or null if there's no available translation
     * @throws IllegalStateException if an error occured
     */
    public String translate(I18nizable text)
    {
        return translate(text, null);
    }
    
    /**
     * Get the translation of the key.
     * @param text The i18n key to translate
     * @param language The language code to use for translation. Can be null.
     * @return The translation or null if there's no available translation
     * @throws IllegalStateException if an error occurred
     */
    public String translate(I18nizable text, String language) throws IllegalStateException
    {
        return translate(text, language, false);
    }
    
    /**
     * Get the translation of the key.
     * @param i18nizable The {@link I18nizable} to translate
     * @param language The language code to use for translation. Can be null.
     * @param rawValue Set true to get the value corresponding strictly to the specified Locale, without escalading to parent Locale if not found. Note that there is no cache for strict values.
     * @return The translation or null if there's no available translation
     * @throws IllegalStateException if an error occurred
     */
    public String translate(I18nizable i18nizable, String language, boolean rawValue) throws IllegalStateException
    {
        // Check language
        final String langCode;
        if (language != null)
        {
            langCode = language;
        }
        else
        {
            Map objectModel = ContextHelper.getObjectModel(_context);
            Locale locale = org.apache.cocoon.i18n.I18nUtils.findLocale(objectModel, "locale", null, Locale.getDefault(), true);
            langCode = locale.toString();
        }
        
        if (i18nizable instanceof FormatableI18nizable)
        {
            return ((FormatableI18nizable) i18nizable).format(LocaleUtils.toLocale(langCode));
        }
        
        I18nizableText text = (I18nizableText) i18nizable;
        String value = null;
        
        if (rawValue)
        {
            // No cache for strict values
            value = _translate(text, langCode, true);
        }
        else if (DevMode.getDeveloperMode() != DEVMODE.PRODUCTION)
        {
            // don't use cache in dev mode, so that i18n catalogues could by modified at any time
            value = _translate(text, langCode, false);
        }
        else
        {
            value = _getI18NCache().get(I18nKey.of(langCode, text), __ -> _translate(text, langCode, false));
        }

        return value;
    }
    
    /**
     * Clear the i18n cache.
     */
    public void clearCache()
    {
        _getI18NCache().invalidateAll();
    }
    
    /**
     * Get the translation of the key.
     * Only use in very specific cases (send mail for example)
     * @param text The i18n key to translate
     * @param language The language code to use for translation. Can be null.
     * @param rawValue Set true to get the value corresponding strictly to the specified Locale, without escalading to parent Locale if not found
     * @return The translation or null if there's no available translation
     * @throws IllegalStateException if an error occured
     */
    protected String _translate(I18nizableText text, String language, boolean rawValue) throws IllegalStateException
    {
        if (!text.isI18n())
        {
            return text.getLabel();
        }
        
        Location location = null;
        if (text.getLocation() != null)
        {
            location = new Location(text.getBundleName(), new String[]{text.getLocation()});
        }
        else
        {
            String catalogue = text.getCatalogue();
            location = _locations.get(catalogue);
        }
        
        if (location == null)
        {
            return null;
        }
        
        try
        {
            Bundle bundle = _bundleFactory.select(location.getLocations(), location.getName(), org.apache.cocoon.i18n.I18nUtils.parseLocale(language));
            
            // translated message
            ParamSaxBuffer buffer = rawValue ? (ParamSaxBuffer) ((XMLResourceBundle) bundle).getRawObject(text.getKey()) : (ParamSaxBuffer) bundle.getObject(text.getKey());
            
            if (buffer == null)
            {
                return null;
            }
            
            // message parameters
            Map<String, SaxBuffer> params = new HashMap<>();
            
            if (text.getParameters() != null)
            {
                int p = 0;
                for (String param : text.getParameters())
                {
                    Characters characters = new Characters(param.toCharArray(), 0, param.length());
                    params.put(String.valueOf(p++), new SaxBuffer(Arrays.asList(characters)));
                }
            }
            
            if (text.getParameterMap() != null)
            {
                for (String name : text.getParameterMap().keySet())
                {
                    I18nizableTextParameter i18nizable = text.getParameterMap().get(name);
                    
                    if (i18nizable instanceof FormatableI18nizable)
                    {
                        String param = ((FormatableI18nizable) i18nizable).format(LocaleUtils.toLocale(language));
                        Characters characters = new Characters(param.toCharArray(), 0, param.length());
                        params.put(name, new SaxBuffer(Arrays.asList(characters)));
                    }
                    else
                    {
                        // named parameters are themselves I18nizableText, so translate them recursively
                        String param = translate((I18nizableText) i18nizable, language, rawValue);
                        if (param == null)
                        {
                            param = "";
                        }
                        Characters characters = new Characters(param.toCharArray(), 0, param.length());
                        params.put(name, new SaxBuffer(Arrays.asList(characters)));
                    }
                }
            }
            
            StringBuilder result = new StringBuilder();
            buffer.toSAX(new BufferHandler(result), params);
            
            return result.toString();
        }
        catch (SAXException e)
        {
            throw new RuntimeException("Unable to get i18n translation", e);
        }
        catch (ComponentException e)
        {
            throw new RuntimeException("Unable to get i18n catalogue", e);
        }
    }
    
    private class BufferHandler extends DefaultHandler
    {
        StringBuilder _builder;
        
        public BufferHandler(StringBuilder builder)
        {
            _builder = builder;
        }
        
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException
        {
            _builder.append(ch, start, length);
        }
    }
    
    /**
     * Class representing an i18n location
     */
    protected static class Location
    {
        String[] _loc;
        String _name;
        
        /**
         * Constructor.
         * @param name the catalogue name
         * @param locations the files locations.
         */
        public Location(String name, String[] locations)
        {
            _name = name;
            _loc = locations;
        }
        
        /**
         * Get the name
         * @return the name
         */
        public String getName()
        {
            return _name;
        }
        
        /**
         * Get the files location
         * @return the files location
         */
        public String[] getLocations()
        {
            return _loc;
        }
    }
    
    /**
     * get the i18n cache (link language and I18nizable text to a translated value)
     * @return the i18n cache
     */
    protected Cache<I18nKey, String> _getI18NCache()
    {
        return _cacheManager.get(I18N_CACHE);
    }

    static final class I18nKey extends AbstractCacheKey
    {
        private I18nKey(String language, I18nizableText text)
        {
            super(language, text);
        }
        
        static I18nKey of(String language, I18nizableText text)
        {
            return new I18nKey(language, text);
        }
    }
}