/*
 *  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.site;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.regex.Pattern;

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.commons.lang3.StringUtils;

import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.I18nizableTextKeyComparator;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.type.RepositoryElementType;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.CategorizedElementDefinitionParser;
import org.ametys.runtime.model.Enumerator;
import org.ametys.runtime.model.Model;
import org.ametys.runtime.model.ModelHelper;
import org.ametys.runtime.model.ModelItem;
import org.ametys.runtime.model.ModelItemGroup;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.AbstractThreadSafeComponentExtensionPoint;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.repository.site.SiteType;
import org.ametys.web.repository.site.SiteTypesExtensionPoint;

/**
 * Extension point holding all {@link SiteParameter} definitions.
 */
public class SiteConfigurationExtensionPoint extends AbstractThreadSafeComponentExtensionPoint<RepositoryElementType> implements Model
{
    /** Avalon Role */
    public static final String ROLE = SiteConfigurationExtensionPoint.class.getName();
    
    private static final Pattern __PARAM_NAME_PATTERN = Pattern.compile("[a-z][a-z0-9-_]*", Pattern.CASE_INSENSITIVE);
    
    private static final String __GENERAL_INFORMATIONS_I18N_KEY = "PLUGINS_WEB_SITE_INFORMATION_CATEGORY";
    
    /** The site manager. */
    protected SiteManager _siteManager;
    
    /** The site type extension point. */
    protected SiteTypesExtensionPoint _siteTypeEP;
    
    /** Component gathering utility methods for internationalizable text translation {@link I18nUtils} */
    protected I18nUtils _i18nUtils;
    
    /** Parameters map, indexed by parameter ID. */
    private Map<String, SiteParameter> _parameters;

    /** Determines if all parameters are valued, by site. */
    private Map<String, Boolean> _isComplete;
    
    /** ComponentManager for {@link Validator}s. */
    private ThreadSafeComponentManager<Validator> _validatorManager;
    
    /** ComponentManager for {@link Enumerator}s. */
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    
    /** Site parameter parser. */
    private SiteParameterParser _parameterParser;
    
    private SiteParameterTypeExtensionPoint _siteParameterTypeEP;

    
    @Override
    public void initialize() throws Exception
    {
        super.initialize();

        _parameters = new LinkedHashMap<>();
        _isComplete = new HashMap<>();
        
        _validatorManager = new ThreadSafeComponentManager<>();
        _validatorManager.setLogger(getLogger());
        _validatorManager.contextualize(_context);
        _validatorManager.service(_cocoonManager);
        
        _enumeratorManager = new ThreadSafeComponentManager<>();
        _enumeratorManager.setLogger(getLogger());
        _enumeratorManager.contextualize(_context);
        _enumeratorManager.service(_cocoonManager);
        
        _parameterParser = new SiteParameterParser(_siteParameterTypeEP, _enumeratorManager, _validatorManager);
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _siteTypeEP = (SiteTypesExtensionPoint) manager.lookup(SiteTypesExtensionPoint.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
        _siteParameterTypeEP = (SiteParameterTypeExtensionPoint) manager.lookup(SiteParameterTypeExtensionPoint.ROLE);
    }
    
    /**
     * Dispose the manager before restarting it
     */
    @Override
    public void dispose()
    {
        _isComplete = new HashMap<>();
        
        _parameterParser = null;
        
        _parameters = null;
        _validatorManager.dispose();
        _validatorManager = null;
        _enumeratorManager.dispose();
        _enumeratorManager = null;
        
        super.dispose();
    }
    
    @Override
    public boolean hasExtension(String id)
    {
        return _parameters.containsKey(id);
    }
    
    @Override
    public void addExtension(String id, String pluginName, String featureName, Configuration configuration) throws ConfigurationException
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Adding site parameters from feature " + pluginName + "/" + featureName);
        }
        
        Configuration[] parameterConfigurations = configuration.getChildren("param");
        for (Configuration parameterConfiguration : parameterConfigurations)
        {
            _addParameter(pluginName, featureName, parameterConfiguration);
        }
    }
    
    @Override
    public RepositoryElementType getExtension(String id)
    {
        return (RepositoryElementType) _parameters.get(id).getType();
    }
    
    @Override
    public Set<String> getExtensionsIds()
    {
        return Collections.unmodifiableSet(_parameters.keySet());
    }
    
    @Override
    public void initializeExtensions() throws Exception
    {
        super.initializeExtensions();
        _parameterParser.lookupComponents();
    }
    
    /**
     * Test if a site configuration is valid.
     * @param siteName the site name.
     * @return true if the site configuration is valid, false otherwise.
     * @throws UnknownAmetysObjectException if the site doesn't exist.
     */
    public boolean isValid(String siteName) throws UnknownAmetysObjectException
    {
        if (siteName == null)
        {
            throw new IllegalArgumentException("Cannot determine if a null siteName is valid or not");
        }
        
        // Check if the site exists.
        if (!_siteManager.hasSite(siteName))
        {
            throw new UnknownAmetysObjectException ("Unknown site '" + siteName + "'. Can not check configuration.");
        }
        
        // Validate the site configuration now if it's not already done.
        if (!_isComplete.containsKey(siteName))
        {
            _isComplete.put(siteName, _validateSiteConfig(siteName));
        }
        
        return _isComplete.get(siteName);
    }
    
    /**
     * Reload a site's configuration.
     * @param siteName the site name.
     * @throws UnknownAmetysObjectException if the site doesn't exist.
     */
    public void reloadConfiguration(String siteName) throws UnknownAmetysObjectException
    {
        // Check if the site exists.
        _siteManager.getSite(siteName);
        
        // Reload the site configuration.
        _isComplete.put(siteName, _validateSiteConfig(siteName));
    }
    
    /**
     * Remove a site's configuration.
     * @param siteName the site name.
     */
    public void removeConfiguration(String siteName)
    {
        if (_isComplete.containsKey(siteName))
        {
            _isComplete.remove(siteName);
        }
    }
    
    /**
     * Get all the parameters for a given site.
     * @param siteName the site name.
     * @return the parameters
     */
    public Map<String, SiteParameter> getParameters(String siteName)
    {
        Map<String, SiteParameter> siteParams = new LinkedHashMap<>();
        
        Site site = _siteManager.getSite(siteName);
        SiteType siteType = _siteTypeEP.getExtension(site.getType());
        
        if (siteType == null)
        {
            throw new IllegalStateException("The site '" + siteName + "' is using un unknown type '" + site.getType() + "'");
        }
        
        for (SiteParameter parameter : _parameters.values())
        {
            if (parameter.isInSiteType(siteType.getName()))
            {
                siteParams.put(parameter.getName(), parameter);
            }
        }
        
        return siteParams;
    }
    
    /**
     * Get all the parameters of a given site, classified by category and group.
     * @param siteName the site name.
     * @return the parameters classified by category and group.
     */
    public Map<I18nizableText, Map<I18nizableText, List<SiteParameter>>> getCategorizedParameters(String siteName)
    {
        return _categorize(getParameters(siteName).values());
    }
    
    /**
     * Declare a site parameter.
     * @param pluginName The name of the plugin declaring the extension.
     * @param featureName the name of the feature
     * @param configuration The parameter configuration.
     * @throws ConfigurationException if configuration if not complete.
     */
    protected void _addParameter(String pluginName, String featureName, Configuration configuration) throws ConfigurationException
    {
        SiteParameter parameter = _parameterParser.parse(_cocoonManager, pluginName, configuration, this, null);
        
        String id = parameter.getName();
        
        if (!__PARAM_NAME_PATTERN.matcher(id).matches())
        {
            throw new ConfigurationException("The feature " + pluginName + "/" + featureName + " declared an invalid site parameter name '" + id + "'. This value is not permited: only [a-zA-Z][a-zA-Z0-9-_]* are allowed.", configuration);
        }
        
        if (_parameters.containsKey(id))
        {
            throw new ConfigurationException("In feature " + pluginName + "/" + featureName + " the parameter '" + id + "' is already declared. Parameter ids must be unique.", configuration);
        }
        
        _parameters.put(id, parameter);
        
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Site parameter added: " + id);
        }
    }
    
    /**
     * Validate the configuration of a site.
     * @param siteName the name of the site to check.
     * @return true if the site is correctly configured, false otherwise.
     */
    protected boolean _validateSiteConfig(String siteName)
    {
        if (getLogger().isDebugEnabled())
        {
            getLogger().debug("Validating the configuration of site '" + siteName + "'");
        }
        
        boolean siteValid = true;
        
        Iterator<SiteParameter> params = getParameters(siteName).values().iterator();
        while (params.hasNext() && siteValid)
        {
            siteValid = _validateParameter(params.next(), siteName);
        }
        
        return siteValid;
    }
    
    /**
     * Validate a parameter value for a given site.
     * @param parameter the site parameter to validate.
     * @param siteName the site name on which to check.
     * @return true if the parameter's value is valid, false otherwise.
     */
    protected boolean _validateParameter(SiteParameter parameter, String siteName)
    {
        String parameterId = parameter.getName();
        
        SiteParameter siteParameter = _parameters.get(parameterId);
        if (siteParameter == null)
        {
            getLogger().warn(String.format("Unable to get site parameter of id '%s' for site '%s': it is not a site's parameter", parameterId, siteName));
        }
        
        Site site = _siteManager.getSite(siteName);
        Object value = site.getValue(parameterId, true, null);
        
        // TODO RUNTIME-2897: call the validateValue without boolean when multiple values are managed in enumerators
        List<I18nizableText> errors = ModelHelper.validateValue(parameter, value, false);
        if (!errors.isEmpty())
        {
            if (getLogger().isWarnEnabled())
            {
                StringBuffer sb = new StringBuffer();
                
                sb.append("The parameter '").append(parameterId).append("' of site '").append(siteName).append("' is not valid with value '").append(parameter.getType().toString(value)).append("':");
                for (I18nizableText error : errors)
                {
                    sb.append("\n* " + error.toString());
                }
                sb.append("\nConfiguration is not initialized");
                
                getLogger().warn(sb.toString());
            }
            
            return false;
        }
        
        return true;
    }
    
    /**
     * Organize a collection of site parameters by categories and groups.
     * @param parameters a collection of site parameters.
     * @return a Map of parameters sorted first by category then group.
     */
    protected Map<I18nizableText, Map<I18nizableText, List<SiteParameter>>> _categorize(Collection<SiteParameter> parameters)
    {
        Map<I18nizableText, Map<I18nizableText, List<SiteParameter>>> categories = new TreeMap<>(new I18nizableTextTranslationComparator());

        // Classify parameters by groups and categories
        for (SiteParameter parameter : parameters)
        {
            I18nizableText categoryName = parameter.getDisplayCategory();
            I18nizableText groupName = parameter.getDisplayGroup();

            // Get the map of groups of the category
            Map<I18nizableText, List<SiteParameter>> category = categories.get(categoryName);
            if (category == null)
            {
                category = new TreeMap<>(new I18nizableTextKeyComparator());
                categories.put(categoryName, category);
            }

            // Get the map of parameters of the group
            List<SiteParameter> group = category.get(groupName);
            if (group == null)
            {
                group = new ArrayList<>();
                category.put(groupName, group);
            }

            group.add(parameter);
        }
        
        return categories;
    }
    
    /**
     * I18nizableText comparator for site parameters
     * General information category is the first one, then sort  the I18nizableText with their translation
     */
    class I18nizableTextTranslationComparator implements Comparator<I18nizableText>
    {
        @Override
        public int compare(I18nizableText t1, I18nizableText t2)
        {
            // The general informations category always goes first
            if (t1.getKey().equals(__GENERAL_INFORMATIONS_I18N_KEY))
            {
                if (t2.getKey().equals(__GENERAL_INFORMATIONS_I18N_KEY))
                {
                    return 0;
                }
                return -1;
            }

            if (t2.getKey().equals(__GENERAL_INFORMATIONS_I18N_KEY))
            {
                return 1;
            }
            
            String tt1 = _i18nUtils.translate(t1);
            if (tt1 == null)
            {
                return -1;
            }
            
            String tt2 = _i18nUtils.translate(t2);
            if (tt2 == null)
            {
                return 1;
            }
            
            return tt1.compareTo(tt2);
        }
    }
    
    public ModelItem getModelItem(String itemPath) throws UndefinedItemPathException
    {
        ModelItem item = _parameters.get(itemPath);
        if (item != null)
        {
            return item;
        }
        else
        {
            throw new UndefinedItemPathException("The parameter '" + itemPath + "' is not defined in sites.");
        }
    }
    
    public Collection< ? extends ModelItem> getModelItems()
    {
        return _parameters.values();
    }
    
    public String getId()
    {
        return StringUtils.EMPTY;
    }
    
    public String getFamilyId()
    {
        return this.getClass().getName();
    }
    
    /**
     * Parser for SiteParameter.
     */
    class SiteParameterParser extends CategorizedElementDefinitionParser
    {
        /**
         * Creates a categorized element definition parser for the skin.
         * @param elementTypeExtensionPoint the extension point to use to get available element types
         * @param enumeratorManager the enumerator component manager.
         * @param validatorManager the validator component manager.
         */
        public SiteParameterParser(AbstractThreadSafeComponentExtensionPoint<? extends ElementType> elementTypeExtensionPoint,
                ThreadSafeComponentManager<Enumerator> enumeratorManager, ThreadSafeComponentManager<Validator> validatorManager)
        {
            super(elementTypeExtensionPoint, enumeratorManager, validatorManager);
        }
        
        @Override
        protected String _getNameConfigurationAttribute()
        {
            return "id";
        }
        
        @Override
        public SiteParameter parse(ServiceManager serviceManager, String pluginName, Configuration definitionConfig, Model model, ModelItemGroup parent) throws ConfigurationException
        {
            SiteParameter<?> siteParameter = (SiteParameter) super.parse(serviceManager, pluginName, definitionConfig, model, parent);
            
            Set<String> siteTypes = new HashSet<>();
            String siteTypesStr = definitionConfig.getChild("site-types").getValue("");
            if (StringUtils.isNotEmpty(siteTypesStr))
            {
                siteTypes.addAll(Arrays.asList(StringUtils.split(siteTypesStr, ", ")));
                siteParameter.setSiteTypes(siteTypes);
            }
            
            return siteParameter;
        }
        
        @Override
        protected SiteParameter _createModelItem(Configuration definitionConfig) throws ConfigurationException
        {
            return new SiteParameter<>();
        }
    }
}