/*
 *  Copyright 2010 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.service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.activity.Disposable;
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.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.solr.common.SolrInputDocument;

import org.ametys.cms.content.indexing.solr.SolrContentIndexer;
import org.ametys.core.ui.ClientSideElement.Script;
import org.ametys.core.ui.ClientSideElement.ScriptFile;
import org.ametys.plugins.core.ui.util.ConfigurationHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.parameter.AbstractParameterParser;
import org.ametys.runtime.parameter.Enumerator;
import org.ametys.runtime.parameter.ParameterHelper;
import org.ametys.runtime.parameter.ParameterHelper.ParameterType;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.ZoneItem;

/**
 * Class representing a business service. <br>
 * A service is identified by an id and a Cocoon-URL.<br>
 * This URL corresponds to a pipeline called by a page template.<br>
 * URL must be relative to the sitemap of the plugin containing the service.
 */
public class StaticService extends AbstractLogEnabled implements Service, Contextualizable, Configurable, PluginAware, Serviceable, Disposable
{
    /** The plugin name */
    protected String _pluginName;
    /** The feature name */
    protected String _featureName;
    /** The service manager */
    protected ServiceManager _manager;
    /** The context. */
    protected Context _context;
    /** The script configured */
    protected Script _paramsScript;
    /** The list of service parameter group */
    protected List<ServiceParameterGroup> _groups;
    /** The map of service parameters */
    protected Map<String, ServiceParameterOrRepeater> _parameters;
    
    private String _id;
    private I18nizableText _label;
    private I18nizableText _description;
    private I18nizableText _category;
    
    private String _iconGlyph;
    private String _iconDecorator;
    private String _smallIcon;
    private String _mediumIcon;
    private String _largeIcon;
    private List<ScriptFile> _cssFiles;
    
    private boolean _isCacheable;
    private boolean _isPrivate;
    /** The right needed to create an instance of this service, blank or null if no right is needed. */
    private String _right;
    
    private String _url;
    
    
    private List<String> _parametersToIndex;
    
    // ComponentManager for validators
    private ThreadSafeComponentManager<Validator> _validatorManager;
    
    // ComponentManager for enumerators
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;

    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _manager = smanager;
    }

    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void dispose()
    {
        _validatorManager.dispose();
        _validatorManager = null;
        
        _enumeratorManager.dispose();
        _enumeratorManager = null;
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _validatorManager = new ThreadSafeComponentManager<>();
        _validatorManager.setLogger(getLogger());
        _validatorManager.contextualize(_context);
        _validatorManager.service(_manager);
        
        _enumeratorManager = new ThreadSafeComponentManager<>();
        _enumeratorManager.setLogger(getLogger());
        _enumeratorManager.contextualize(_context);
        _enumeratorManager.service(_manager);
        
        _label = _parseI18nizableText(configuration, "label");
        _description = _parseI18nizableText(configuration, "description");
        _category = _parseI18nizableText(configuration, "category");
        
        _isCacheable = configuration.getChild("cacheable").getValueAsBoolean(false);
        _isPrivate = configuration.getChild("private").getValueAsBoolean(false);
        _right = configuration.getChild("right").getValue(null);

        this._iconGlyph = configuration.getChild("thumbnail").getChild("glyph").getValue(null);
        this._iconDecorator = configuration.getChild("thumbnail").getChild("decorator").getValue(null);
        this._smallIcon = _configureThumbnail(configuration.getChild("thumbnail").getChild("small"), "/plugins/web/resources/img/service/servicepage_16.png");
        this._mediumIcon = _configureThumbnail(configuration.getChild("thumbnail").getChild("medium"), "/plugins/web/resources/img/service/servicepage_32.png");
        this._largeIcon = _configureThumbnail(configuration.getChild("thumbnail").getChild("marge"), "/plugins/web/resources/img/service/servicepage_50.png");

        _cssFiles = _configureImports(configuration.getChild("css"));
        _paramsScript = _configureScript(configuration.getChild("parameters"));
        
        _url = configuration.getChild("url").getValue();
        _parameters = new LinkedHashMap<>();
        _groups = new ArrayList<>();
        
        ServiceParameterParser serviceParameterParser = new ServiceParameterParser(_enumeratorManager, _validatorManager);
        ServiceParameterOrRepeaterParser serviceParamOrRepeaterParser = new ServiceParameterOrRepeaterParser(serviceParameterParser);
        
        configureParameters(configuration.getChild("parameters"), serviceParamOrRepeaterParser);
        
        try
        {
            serviceParameterParser.lookupComponents();
        }
        catch (Exception e)
        {
            throw new ConfigurationException("Unable to lookup parameter local components", configuration, e);
        }
        
        configureIndexation(configuration.getChild("indexation"));
    }
    
    /**
     * Configure the service parameters.
     * @param configuration the service configuration.
     * @param serviceParameterParser the parser.
     * @throws ConfigurationException if an error occurs.
     */
    protected void configureParameters(Configuration configuration, ServiceParameterOrRepeaterParser serviceParameterParser) throws ConfigurationException
    {
        Configuration[] groupConfigurations = configuration.getChildren("group");
        if (groupConfigurations.length > 0)
        {
            // Has groups.
            for (Configuration groupConfiguration : groupConfigurations)
            {
                ServiceParameterGroup group = new ServiceParameterGroup();
                _groups.add(group);
                
                configureParameterGroup(group, groupConfiguration, _pluginName, serviceParameterParser);
            }
        }
        else
        {
            // No group tag, create a single group and put all params in it.
            ServiceParameterGroup group = new ServiceParameterGroup();
            _groups.add(group);
            
            configureParameterGroup(group, configuration, _pluginName, serviceParameterParser);
        }
    }
    
    /**
     * Configure the indexation process.<br>
     * This class only allow to index the value of some parameters (not repeaters).
     * @param configuration the indexation configuration.
     * @throws ConfigurationException if an error occurs.
     */
    protected void configureIndexation(Configuration configuration) throws ConfigurationException
    {
        _parametersToIndex = new ArrayList<>();
        
        for (Configuration config : configuration.getChildren("parameter"))
        {
            String id = config.getValue("");
            ServiceParameterOrRepeater param = _parameters.get(id);
            
            if (param == null || !(param instanceof ServiceParameter))
            {
                if (getLogger().isWarnEnabled())
                {
                    getLogger().warn("Invalid indexation configuration for service " + _id + " : there's no parameter '" + id + "'");
                }
            }
            else
            {
                _parametersToIndex.add(id);
            }
        }
    }
    
    /**
     * Configure the service parameters.
     * @param group the group to put the params in.
     * @param configuration the service configuration.
     * @param serviceParameterParser the parser.
     * @throws ConfigurationException if an error occurs.
     */
    @Deprecated
    protected void configureParameterGroup(ServiceParameterGroup group, Configuration configuration, ServiceParameterOrRepeaterParser serviceParameterParser) throws ConfigurationException
    {
        configureParameterGroup(group, configuration, _pluginName, serviceParameterParser);
    }
    
    /**
     * Configure the service parameters.
     * @param group the group to put the params in.
     * @param configuration the service configuration.
     * @param pluginName the plugin name
     * @param serviceParameterParser the parser.
     * @throws ConfigurationException if an error occurs.
     */
    protected void configureParameterGroup(ServiceParameterGroup group, Configuration configuration, String pluginName, ServiceParameterOrRepeaterParser serviceParameterParser) throws ConfigurationException
    {
        for (Configuration paramConfiguration : configuration.getChildren())
        {
            String paramName = paramConfiguration.getName();
            if (paramName.equals("parameter") || paramName.equals("repeater"))
            {
                ServiceParameterOrRepeater serviceParameter = serviceParameterParser.parse(_manager, pluginName, paramConfiguration);
                
                // Add the param or repeater to the parameter map as well as to his group.
                _parameters.put(serviceParameter.getId(), serviceParameter);
                group.add(serviceParameter);
            }
        }
    }
    
    @Override
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
        _featureName = featureName;
        _id = id;
    }

    @Override
    public String getPluginName()
    {
        return _pluginName;
    }

    @Override
    public String getId()
    {
        return _id;
    }
    
    @Override
    public boolean isCacheable(Page currentPage, ZoneItem zoneItem)
    {
        return _isCacheable;
    }
    
    @Override
    public I18nizableText getLabel()
    {
        return _label;
    }
    
    @Override
    public I18nizableText getDescription()
    {
        return _description;
    }
    
    @Override
    public I18nizableText getCategory()
    {
        return _category;
    }
    
    @Override
    public String getIconGlyph()
    {
        return _iconGlyph;
    }
    
    @Override
    public String getIconDecorator()
    {
        return _iconDecorator;
    }
    
    @Override
    public String getSmallIcon()
    {
        return _smallIcon;
    }
    
    @Override
    public String getMediumIcon()
    {
        return _mediumIcon;
    }
    
    @Override
    public String getLargeIcon()
    {
        return _largeIcon;
    }

    @Override
    public String getURL()
    {
        return "cocoon://_plugins/" + _pluginName + "/" + _url;
    }
    
    @Override
    public Map<String, ServiceParameterOrRepeater> getParameters()
    {
        return Collections.unmodifiableMap(_parameters);
    }
    
    @Override
    public List<ServiceParameterGroup> getParameterGroups()
    {
        return Collections.unmodifiableList(_groups);
    }
    
    @Override
    public Script getParametersScript()
    {
        return _paramsScript;
    }

    @Override
    public List<ScriptFile> getCSSFiles()
    {
        return _cssFiles;
    }
    
    @Override
    public boolean isPrivate()
    {
        return _isPrivate;
    }
    
    @Override
    public String getRight()
    {
        return _right;
    }
    
    @Override
    public void index(ZoneItem zoneItem, SolrInputDocument document)
    {
        for (String id : _parametersToIndex)
        {
            if (zoneItem.getServiceParameters().hasMetadata(id))
            {
                ServiceParameter parameter = (ServiceParameter) _parameters.get(id);
                ParameterType type = parameter.getType();
                
                switch (type)
                {
                    case BOOLEAN:
                    case DOUBLE:
                    case LONG:
                    case STRING:
                        String language = zoneItem.getZone().getPage().getSitemapName();
                        
                        String[] values = zoneItem.getServiceParameters().getStringArray(id);
                        for (String value : values)
                        {
                            SolrContentIndexer.indexFulltextValue(document, value, language);
                        }
                        break;
                    default:
                        break;
                }
            }
        }
    }
    
    /**
     * Parse an i18n text.
     * @param config the configuration to use.
     * @param name the child name.
     * @return the i18n text.
     */
    protected I18nizableText _parseI18nizableText(Configuration config, String name)
    {
        return I18nizableText.parseI18nizableText(config.getChild(name), "plugin." + _pluginName, "");
    }

    private String _configureThumbnail(Configuration valueConf, String defaultImage)
    {
        String value = valueConf.getValue(null);
        if (value == null)
        {
            return defaultImage;
        }
        else
        {
            String pluginName = valueConf.getAttribute("plugin", this._pluginName);
            return "/plugins/" + pluginName + "/resources/" + value;
        }
    }
    
    /**
     * Configure the script
     * @param configuration the global configuration
     * @return The script created
     * @throws ConfigurationException if configuration is invalid
     */
    protected Script _configureScript(Configuration configuration) throws ConfigurationException
    {
        List<ScriptFile> scriptsImports = _configureImports(configuration.getChild("scripts"));
        List<ScriptFile> cssImports = _configureImports(configuration.getChild("css"));
        String jsClassName = _configureClass(configuration.getChild("action"));
        
        return new Script(this.getId(), jsClassName, scriptsImports, cssImports, new HashMap<>());
    }
    
    
    /**
     * Configure the js class name
     * @param configuration The configuration on action tag
     * @return The js class name
     * @throws ConfigurationException If an error occurs
     */
    protected String _configureClass(Configuration configuration) throws ConfigurationException
    {
        String jsClassName = configuration.getAttribute("class", "");
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Js class configured is '" + jsClassName + "'");
        }
        return jsClassName;        
    }
    
    /**
     * Configure the import part
     * @param configuration The imports configuration
     * @return The set of the complete url of imported file
     * @throws ConfigurationException If an error occurs
     */
    protected List<ScriptFile> _configureImports(Configuration configuration) throws ConfigurationException
    {
        return ConfigurationHelper.parsePluginResourceList(configuration, getPluginName(), getLogger());
    }
    
    private static class ServiceParameterParser extends AbstractParameterParser<ServiceParameter, ParameterType>
    {
        /**
         * Creates an {@link ServiceParameterParser}.
         * @param enumeratorManager the enumerator component manager.
         * @param validatorManager the validator component manager.
         */
        public ServiceParameterParser(ThreadSafeComponentManager<Enumerator> enumeratorManager, ThreadSafeComponentManager<Validator> validatorManager)
        {
            super(enumeratorManager, validatorManager);
        }
        
        @Override
        protected ServiceParameter _createParameter(Configuration parameterConfig) throws ConfigurationException
        {
            return new ServiceParameter();
        }
        
        @Override
        protected String _parseId(Configuration parameterConfig) throws ConfigurationException
        {
            String parameterName = parameterConfig.getAttribute("name");
            
            if (!parameterName.matches("^[a-zA-Z0-9_-]+$"))
            {
                throw new ConfigurationException("Invalid parameter name: " + parameterName, parameterConfig);
            }
            
            return parameterName;
        }
        
        @Override
        protected ParameterType _parseType(Configuration parameterConfig) throws ConfigurationException
        {
            try
            {
                return ParameterType.valueOf(parameterConfig.getAttribute("type").toUpperCase());
            }
            catch (IllegalArgumentException e)
            {
                throw new ConfigurationException("Invalid type", parameterConfig, e);
            }
        }
        
        @Override
        protected Object _parseDefaultValue(Configuration parameterConfig, ServiceParameter parameter)
        {
            String value;
            
            Configuration childNode = parameterConfig.getChild("default-value", false);
            if (childNode == null)
            {
                value = null;
            }
            else
            {
                value = childNode.getValue("");
            }
            
            return ParameterHelper.castValue(value, parameter.getType());
        }
        
        @Override
        protected void _additionalParsing(ServiceManager manager, String pluginName, Configuration parameterConfig, String parameterId, ServiceParameter parameter) throws ConfigurationException
        {
            super._additionalParsing(manager, pluginName, parameterConfig, parameterId, parameter);
            
            parameter.setId(parameterId);
            parameter.setMultiple(parameterConfig.getAttributeAsBoolean("multiple", false));
        }
    }
    
    /**
     * Class for service parameter or repeater parser
     */
    protected static class ServiceParameterOrRepeaterParser
    {
        
        private ServiceParameterParser _serviceParameterParser;
        
        
        /**
         * The constructor
         * @param paramParser the paramParser to parse
         */
        public ServiceParameterOrRepeaterParser(ServiceParameterParser paramParser)
        {
            _serviceParameterParser = paramParser;
        }
        
        /**
         * Parse the service parameters of repeater
         * @param manager the service manager
         * @param pluginName the plugin name
         * @param paramConfiguration the param configuration
         * @return the service parameter parser
         * @throws ConfigurationException if an error occurred
         */
        public ServiceParameterOrRepeater parse(ServiceManager manager, String pluginName, Configuration paramConfiguration) throws ConfigurationException
        {
            String name = paramConfiguration.getName();
            if (name.equals("parameter"))
            {
                return _serviceParameterParser.parseParameter(manager, pluginName, paramConfiguration);
            }
            else if (name.equals("repeater"))
            {
                return parseRepeater(manager, pluginName, paramConfiguration);
            }
            else
            {
                throw new ConfigurationException("Only parameter and repeater can be found in a service parameters configuration. Invalid tag: " + name, paramConfiguration);
            }
        }
        
        /**
         * Parse the repeater
         * @param manager the service manager
         * @param pluginName the plugin name
         * @param repeaterConfig the repeater configuration
         * @return the service parameter parser
         * @throws ConfigurationException if an error occurred
         */
        protected ServiceParameterRepeater parseRepeater(ServiceManager manager, String pluginName, Configuration repeaterConfig) throws ConfigurationException
        {
            ServiceParameterRepeater repeater = new ServiceParameterRepeater();
            
            String parameterId = _parseId(repeaterConfig);
            
            repeater.setId(parameterId);
            repeater.setPluginName(pluginName);
            repeater.setLabel(_parseI18nizableText(repeaterConfig, pluginName, "label"));
            repeater.setDescription(_parseI18nizableText(repeaterConfig, pluginName, "description"));
            
            repeater.setAddLabel(_parseI18nizableText(repeaterConfig, pluginName, "add-label"));
            repeater.setEditLabel(_parseI18nizableText(repeaterConfig, pluginName, "edit-label"));
            repeater.setDeleteLabel(_parseI18nizableText(repeaterConfig, pluginName, "del-label"));
            repeater.setAddIcon(_parseIcon(repeaterConfig.getChild("add-icon"), pluginName, "/plugins/web/resources/img/widget/repeater/add_12.png"));
            repeater.setEditIcon(_parseIcon(repeaterConfig.getChild("edit-icon"), pluginName, "/plugins/web/resources/img/widget/repeater/edit_12.png"));
            repeater.setDeleteIcon(_parseIcon(repeaterConfig.getChild("del-icon"), pluginName, "/plugins/web/resources/img/widget/repeater/delete_12.png"));
            
            repeater.setInitialSize(repeaterConfig.getAttributeAsInteger("initial-size", 0));
            repeater.setMinSize(repeaterConfig.getAttributeAsInteger("min-size", 0));
            repeater.setMaxSize(repeaterConfig.getAttributeAsInteger("max-size", -1));
            
            repeater.setChildrenParameters(parseParameters(manager, pluginName, repeaterConfig));
            
            return repeater;
        }
        
        /**
         * Parse the id
         * @param parameterConfig the parameter configuration
         * @return the parsed Id
         * @throws ConfigurationException if an error occurred
         */
        protected String _parseId(Configuration parameterConfig) throws ConfigurationException
        {
            String parameterName = parameterConfig.getAttribute("name");
            
            if (!parameterName.matches("^[a-zA-Z0-9_-]+$"))
            {
                throw new ConfigurationException("Invalid parameter name: " + parameterName, parameterConfig);
            }
            
            return parameterName;
        }
        
        /**
         * Parses an i18n text.
         * @param config the configuration to use.
         * @param pluginName the current plugin name.
         * @param name the child name.
         * @return the i18n text.
         * @throws ConfigurationException if the configuration is not valid.
         */
        protected I18nizableText _parseI18nizableText(Configuration config, String pluginName, String name) throws ConfigurationException
        {
            return I18nizableText.parseI18nizableText(config.getChild(name), "plugin." + pluginName);
        }
        
        /**
         * Parse icon
         * @param iconConfig The icon config
         * @param defaultPluginName The default plugin name
         * @param defaultImage The default image
         * @return The icon path
         */
        protected String _parseIcon(Configuration iconConfig, String defaultPluginName, String defaultImage)
        {
            String value = iconConfig.getValue(null);
            if (value == null)
            {
                return defaultImage;
            }
            else
            {
                String pluginName = iconConfig.getAttribute("plugin", defaultPluginName);
                return "/plugins/" + pluginName + "/resources/" + value;
            }
        }
        
        /**
         * Parse the parameters
         * @param manager the service manager
         * @param pluginName the plugin name
         * @param repeaterConfig the repeater configuration
         * @return the service parameter parser 
         * @throws ConfigurationException if an error occurred
         */
        protected Map<String, ServiceParameter> parseParameters(ServiceManager manager, String pluginName, Configuration repeaterConfig) throws ConfigurationException
        {
            Map<String, ServiceParameter> params = new LinkedHashMap<>();
            
            for (Configuration paramConfiguration : repeaterConfig.getChildren("parameter"))
            {
                ServiceParameter serviceParameter = _serviceParameterParser.parseParameter(manager, pluginName, paramConfiguration);

                params.put(serviceParameter.getId(), serviceParameter);
            }
            
            return params;
        }
    }
}