/*
 *  Copyright 2018 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.runtime.config;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;

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

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.context.Context;
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.cocoon.xml.XMLUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.xml.serializer.OutputPropertiesFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.I18nizableTextComparator;
import org.ametys.core.util.I18nizableTextKeyComparator;
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.Enumerator;
import org.ametys.runtime.model.I18nizableTextModelItemComparator;
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.View;
import org.ametys.runtime.model.checker.ItemChecker;
import org.ametys.runtime.model.disableconditions.DefaultDisableConditionsEvaluator;
import org.ametys.runtime.model.disableconditions.DisableConditions;
import org.ametys.runtime.model.disableconditions.DisableConditionsEvaluator;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.runtime.model.type.ModelItemTypeExtensionPoint;
import org.ametys.runtime.model.type.xml.XMLElementType;
import org.ametys.runtime.parameter.ValidationResult;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

/**
 * This manager handle the parameters of the application that have to be stored by the plugins.
 */
public final class ConfigManager implements Model, Contextualizable, Serviceable, Initializable
{
    // shared instance
    private static ConfigManager __manager;
 
    // Logger for traces
    private Logger _logger = LoggerFactory.getLogger(ConfigManager.class);
    private Logger _threadSafeComponentLogger = LoggerFactory.getLogger("runtime.plugin.threadsafecomponent");

    // Avalon stuff
    private ServiceManager _serviceManager;
    private Context _context;
    
    // ComponentManager for the disable conditions
    private ThreadSafeComponentManager<DisableConditions> _disableConditionsManager;
    // ComponentManager for the validators
    private ThreadSafeComponentManager<Validator> _validatorManager;
    // ComponentManager for the enumerators
    private ThreadSafeComponentManager<Enumerator> _enumeratorManager;
    // ComponentManager for the parameter checkers
    private ThreadSafeComponentManager<ItemChecker> _parameterCheckerManager;
    
    private Map<String, ConfigParameterInfo> _declaredParams;
    private Map<String, ConfigParameterInfo> _declaredParamCheckers;
    private Collection<String> _usedParamIds;
    private Map<String, ConfigParameterDefinitionWrapper> _configParameterWrappers;
    private Map<String, ConfigParameterCheckerDescriptor> _parameterCheckers;
    
    // The configuration model items
    private List<ModelItem> _categorizedDefinitions;
    private Map<String, ElementDefinition> _flatDefinitions;
    
    // Determines if the extension point is initialized
    private boolean _isInitialized;
    // Determines if all parameters are valued
    private boolean _isComplete;
    
    private ModelItemTypeExtensionPoint _configParameterTypeEP;
    private DisableConditionsEvaluator _disableConditionsEvaluator;
    
    private ConfigManager()
    {
        // empty constructor
    }

    /**
     * Returns the shared instance of the ConfigManager
     * @return the shared instance of the ConfigManager
     */
    public static ConfigManager getInstance()
    {
        if (__manager == null)
        {
            __manager = new ConfigManager();
        }

        return __manager;
    }

    @Override
    public void contextualize(Context context)
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _serviceManager = manager;
        _configParameterTypeEP = (ModelItemTypeExtensionPoint) _serviceManager.lookup(ModelItemTypeExtensionPoint.ROLE_CONFIG);
        _disableConditionsEvaluator = (DisableConditionsEvaluator) _serviceManager.lookup(DefaultDisableConditionsEvaluator.ROLE);
    }
    
    @Override
    public void initialize()
    {
        _usedParamIds = new ArrayList<>();
        _declaredParams = new HashMap<>();
        _configParameterWrappers = new HashMap<>();
        _declaredParamCheckers = new HashMap<>();
        _parameterCheckers = new HashMap<>();
        _flatDefinitions = new HashMap<>();
        
        _disableConditionsManager = new ThreadSafeComponentManager<>();
        _disableConditionsManager.setLogger(_threadSafeComponentLogger);
        _disableConditionsManager.contextualize(_context);
        _disableConditionsManager.service(_serviceManager);
        
        _validatorManager = new ThreadSafeComponentManager<>();
        _validatorManager.setLogger(_threadSafeComponentLogger);
        _validatorManager.contextualize(_context);
        _validatorManager.service(_serviceManager);
        
        _enumeratorManager = new ThreadSafeComponentManager<>();
        _enumeratorManager.setLogger(_threadSafeComponentLogger);
        _enumeratorManager.contextualize(_context);
        _enumeratorManager.service(_serviceManager);
        
        _parameterCheckerManager = new ThreadSafeComponentManager<>();
        _parameterCheckerManager.setLogger(_threadSafeComponentLogger);
        _parameterCheckerManager.contextualize(_context);
        _parameterCheckerManager.service(_serviceManager);
    }
    
    /**
     * Registers new available parameters.
     * The addFeatureConfig() method allows to select which ones are actually useful.
     * @param pluginName the name of the plugin defining the parameters
     * @param parameters the configuration parameters definition
     * @param parameterCheckers the parameters checkers definition
     */
    public void addPluginConfig(String pluginName, Map<String, ConfigParameterInfo> parameters, Map<String, ConfigParameterInfo> parameterCheckers)
    {
        _logger.debug("Adding parameters and parameters checkers for plugin {}.", pluginName);

        // declare parameters and parameter checkers configured in the plugin
        _declareParameters(parameters);
        _declareParameterCheckers(parameterCheckers);
    }

    /**
     * Registers a new parameter or references a globalConfig parameter.<br>
     * @param featureId the id of the feature defining the parameters
     * @param parameters the configuration parameters definition
     * @param parameterCheckers the parameters checkers definition
     * @param parameterReferences references to already defined parameters
     */
    public void addFeatureConfig(String featureId, Map<String, ConfigParameterInfo> parameters, Map<String, ConfigParameterInfo> parameterCheckers, Collection<String> parameterReferences)
    {
        _logger.debug("Selecting parameters for feature {}.", featureId);
        
        // declare parameters and parameter checkers configured in the feature
        _declareParameters(parameters);
        _declareParameterCheckers(parameterCheckers);

        // Add parameters declared in feature to the list of used parameters
        _usedParamIds.addAll(parameters.keySet());
        
        // Add referenced parameters to the list of used parameters
        _usedParamIds.addAll(parameterReferences);
    }
    
    private void _declareParameters(Map<String, ConfigParameterInfo> parameters)
    {
        for (String id : parameters.keySet())
        {
            ConfigParameterInfo info = parameters.get(id);
            
            // Check if the parameter is not already declared
            if (_declaredParams.containsKey(id))
            {
                throw new IllegalArgumentException("The config parameter '" + id + "' is already declared. Parameters ids must be unique");
            }

            // Add the new parameter to the list of declared ones
            _declaredParams.put(id, info);

            _logger.debug("Parameter added: {}", id);
        }
        
        _logger.debug("{} parameter(s) added", parameters.size());
    }
    
    private void _declareParameterCheckers(Map<String, ConfigParameterInfo> parameterCheckers)
    {
        for (String id : parameterCheckers.keySet())
        {
            ConfigParameterInfo info = parameterCheckers.get(id);
            
            // Check if the parameter checker is not already declared
            if (_declaredParamCheckers.containsKey(id))
            {
                throw new IllegalArgumentException("The config parameter checker '" + id + "' is already declared. Parameter checkers ids must be unique.");
            }

            // Add the new parameter checker to the list of declared ones
            _declaredParamCheckers.put(id, info);

            _logger.debug("Parameter checker added: {}", id);
        }
        
        _logger.debug("{} parameter checker(s) added", parameterCheckers.size());
    }

    /**
     * Ends the initialization of the config parameters, by checking against the
     * already valued parameters.<br>
     * If at least one parameter has no value, the application won't start.
     */
    public void parseAndValidate()
    {
        _logger.debug("Initialization");

        _isInitialized = false;
        _isComplete = true;

        ConfigParameterDefinitionParser parser = new ConfigParameterDefinitionParser(_configParameterTypeEP, _disableConditionsManager, _enumeratorManager, _validatorManager);
        _parseParameters(parser);
        
        ConfigParameterCheckerParser parameterCheckerParser = new ConfigParameterCheckerParser(_parameterCheckerManager);
        _parseParameterCheckers(parameterCheckerParser);
        
        _categorizeParameters();

        try
        {
            parser.lookupComponents();
            parameterCheckerParser.lookupComponents();
        }
        catch (Exception e)
        {
            throw new RuntimeException("Unable to lookup parameter local components", e);
        }
        
        _validateParametersForReading();

        _usedParamIds.clear();
        _declaredParams.clear();
        _declaredParamCheckers.clear();
        
        _isInitialized = true;

        Config.setInitialized(_isComplete);
        
        _logger.debug("Initialization ended");
    }

    private void _parseParameters(ConfigParameterDefinitionParser definitionParser)
    {
        ConfigParameterDefinitionWrapperParser parser = new ConfigParameterDefinitionWrapperParser(definitionParser);
        for (String id : _usedParamIds)
        {
            // Check if the parameter is not already used
            if (_configParameterWrappers.get(id) == null)
            {
                // Move the parameter from the unused list, to the used list
                ConfigParameterInfo parameterInfo = _declaredParams.get(id);
                
                if (parameterInfo == null)
                {
                    throw new RuntimeException("The parameter '" + id + "' is used but not declared");
                }
                
                ConfigParameterDefinitionWrapper configParameterWrapper = null;

                try
                {
                    configParameterWrapper = parser.parse(_serviceManager, parameterInfo.getPluginName(), parameterInfo.getConfiguration(), getInstance(), null);
                }
                catch (ConfigurationException ex)
                {
                    throw new RuntimeException("Unable to configure the config parameter : " + id, ex);
                }
                
                _configParameterWrappers.put(id, configParameterWrapper);
            }
        }
    }

    private void _parseParameterCheckers(ConfigParameterCheckerParser parameterCheckerParser)
    {
        for (String id : _declaredParamCheckers.keySet())
        {
            boolean invalidParameters = false;
            
            // Check if the parameter checker is not already used
            if (_parameterCheckers.get(id) == null)
            {
                ConfigParameterInfo info = _declaredParamCheckers.get(id);
                
                ConfigParameterCheckerDescriptor parameterChecker = null;
                try
                {
                    
                    parameterChecker = parameterCheckerParser.parseParameterChecker(info.getPluginName(), info.getConfiguration());
                }
                catch (ConfigurationException ex)
                {
                    throw new RuntimeException("Unable to configure the parameter checker: " + id, ex);
                }
                
                for (String linkedParameterPath : parameterChecker.getLinkedParamsPaths())
                {
                    ConfigParameterDefinitionWrapper linkedParameter = null;

                    // Linked parameters can be declared with an absolute path, in which case they are prefixed with '/
                    if (linkedParameterPath.startsWith(ModelItem.ITEM_PATH_SEPARATOR))
                    {
                        linkedParameter = _configParameterWrappers.get(linkedParameterPath.substring(ModelItem.ITEM_PATH_SEPARATOR.length()));
                    }
                    else
                    {
                        linkedParameter = _configParameterWrappers.get(linkedParameterPath);
                    }
                    
                    // If at least one parameter used is invalid, the parameter checker is invalidated
                    if (linkedParameter == null)
                    {
                        invalidParameters = true;
                        break;
                    }
                }
                
                if (invalidParameters)
                {
                    _logger.debug("All the configuration parameters associated to the parameter checker '{}' are not used.\nThis parameter checker will be ignored.", parameterChecker.getName());
                }
                else
                {
                    _parameterCheckers.put(id, parameterChecker);
                }
            }
        }
    }
    
    private void _categorizeParameters()
    {
        Collection<ConfigParameterDefinitionWrapper> categorizedParameterProxiesValues = _configParameterWrappers.values();
        _categorizedDefinitions = ConfigParameterDefinitionHelper.categorizeConfigParameters(categorizedParameterProxiesValues);
        _flatDefinitions = ConfigParameterDefinitionHelper.getFlatDefinitions(categorizedParameterProxiesValues);
        
        // Add parameter checkers to categories, groups and element definitions
        _addParameterCheckersToModelItems();
    }

    private void _addParameterCheckersToModelItems()
    {
        for (ConfigParameterCheckerDescriptor parameterChecker: _parameterCheckers.values())
        {
            I18nizableText uiCategory = parameterChecker.getUiRefCategory();
            if (uiCategory != null)
            {
                ModelItemGroup category = _getModelItemGroup(_categorizedDefinitions, uiCategory);
                if (category == null)
                {
                    _logger.warn("The category {} doesn't exist, thus the parameter checker {} will not be added.", uiCategory, parameterChecker.getName());
                }
                else
                {
                    I18nizableText uiGroup = parameterChecker.getUiRefGroup();
                    if (uiGroup == null)
                    {
                        category.addItemChecker(parameterChecker);
                    }
                    else
                    {
                        ModelItemGroup group = _getModelItemGroup(category.getChildren(), uiGroup);
                        if (group == null)
                        {
                            _logger.warn("The group {} doesn't exist,  thus the parameter checker {} will not be added.", uiGroup, parameterChecker.getName());
                        } 
                        else
                        {
                            group.addItemChecker(parameterChecker);
                        }
                    }
                } 
            }
            else
            {
                String uiParameterId = parameterChecker.getUiRefParamId();
                if (uiParameterId != null)
                {
                    ElementDefinition definition = _flatDefinitions.get(uiParameterId);
                    if (definition == null)
                    {
                        _logger.warn("The parameter {} doesn't exist, thus the parameter checker {} will not be added.", uiParameterId, parameterChecker.getName());
                    }
                    else
                    {
                        definition.addItemChecker(parameterChecker);
                    }
                }
            }
        }
    }

    private ModelItemGroup _getModelItemGroup(List<ModelItem> items, I18nizableText itemGroupLabel)
    {
        for (ModelItem item : items)
        {
            if (itemGroupLabel.equals(item.getLabel()) && item instanceof ModelItemGroup)
            {
                return (ModelItemGroup) item;
            }
        }
        
        return null;
    }
    
    private void _validateParametersForReading()
    {
        // Dispose potential previous parameters 
        Config.dispose();
        
        // Get configuration values
        Map<String, Object> values = null;
        try
        {
            Config.setModel(this);
            Map<String, DefinitionAndValue> definitionAndValues = Config.__read();
            values = Config.__extractValues(definitionAndValues);
        }
        catch (Exception e)
        {
            _logger.error("Cannot read the configuration file.", e);
            _isComplete = false;
        }
        
        if (_isComplete && values != null)
        {
            for (ElementDefinition definition : _flatDefinitions.values())
            {
                boolean isGroupSwitchOn = ModelHelper.isGroupSwitchOn(definition, values);
                boolean isDisabled = _disableConditionsEvaluator.evaluateDisableConditions(definition, definition.getName(), values);
                
                if (isGroupSwitchOn && !isDisabled)
                {
                    if (!values.containsKey(definition.getName()))
                    {
                        _logger.warn("The parameter '" + definition.getName() + "' is not valued. Configuration is not initialized.");
                        _isComplete = false;
                    }
                    else
                    {
                        Object value = values.get(definition.getName());
                        ValidationResult result = ModelHelper.validateValue(definition, value);
                        if (result.hasErrors())
                        {
                            if (_logger.isWarnEnabled())
                            {
                                StringBuilder sb = new StringBuilder("The parameter '" + definition.getName() + "' is not valid with value '" + value + "' :");
                                
                                for (I18nizableText error : result.getErrors())
                                {
                                    sb.append("\n* " + error.toString());
                                }
                                sb.append("\nConfiguration is not initialized");
                                
                                _logger.warn(sb.toString());
                            }
                            
                            _isComplete = false;
                        }
                    }
                    
                }
            }
            
        }
    }
    
    /**
     * Update the configuration file with the given values<br>
     * Values are untyped (all are of type String) and might be null.
     * @param values A map (key, value).
     * @param fileName the configuration file absolute path
     * @return errors The fields in error
     * @throws Exception If an error occurred while saving values
     */
    public Map<String, List<I18nizableText>> save(Map<String, Object> values, String fileName) throws Exception
    {
        // Retrieve the old values for password purposes
        Map<String, Object> oldValues = getOldValues();
        
        // Resolve each value and associate it to its definition
        Map<String, Object> resolvedValues = _resolveValues(values, oldValues);
        
        // Validate parameters
        Map<String, List<I18nizableText>> errorFields = CategorizedElementDefinitionHelper.validateValuesForWriting(resolvedValues, _flatDefinitions.values(), _disableConditionsEvaluator, _logger)
                                                                                          .getAllErrors();
        if (!errorFields.isEmpty())
        {
            return errorFields;
        }

        // SAX
        _saxConfigurationFile(fileName, resolvedValues);
        
        return Collections.EMPTY_MAP;
    }

    /**
     * Retrieves old values if the configuration is not well initialized
     * @return the old values
     */
    public Map<String, Object> getOldValues()
    {
        if (Config.getInstance() == null)
        {
            try
            {
                Map<String, DefinitionAndValue> oldDefinitionAndValues = Config.__read();
                return Config.__extractValues(oldDefinitionAndValues);
            }
            catch (Exception e)
            {
                return new HashMap<>();
            }
        }
        
        return null;
    }

    private Map<String, Object> _resolveValues(Map<String, Object> values, Map<String, Object> oldValues)
    {
        Map<String, Object> resolvedValues = new HashMap<>();
        for (Map.Entry<String, Object> value : values.entrySet())
        {
            ElementDefinition definition = _flatDefinitions.get(value.getKey());
            if (definition != null)
            {
                Object resolvedValue = _resolveValue(definition, value.getValue(), oldValues);
                resolvedValues.put(value.getKey(), resolvedValue);
            }
        }
        return resolvedValues;
    }
    
    /**
     * Resolve the given value for the parameter check
     * @param parameterName name of the parameter to resolve
     * @param value the value to resolve
     * @param oldValues the old values if the configuration is not initialized
     * @return the resolved value as a String
     */
    public String resolveValueForParameterChecker(String parameterName, Object value, Map<String, Object> oldValues)
    {
        ElementDefinition definition = _flatDefinitions.get(parameterName);
        
        if (definition == null)
        {
            return null;
        }
        
        Object resolvedValue = _resolveValue(definition, value, oldValues);
        return definition.getType().toString(resolvedValue);
    }
    
    private Object _resolveValue(ElementDefinition definition, Object value, Map<String, Object> oldValues)
    {
        String parameterId = definition.getName();
        ElementType type = definition.getType();
        Object resolvedValue = value;

        // keeps the value of an empty password field
        if (value == null && ModelItemTypeConstants.PASSWORD_ELEMENT_TYPE_ID.equals(type.getId()))
        {
            if (Config.getInstance() != null)
            {
                resolvedValue = Config.getInstance().getValue(parameterId);
            }
            else if (oldValues != null)
            {
                resolvedValue = oldValues.get(definition.getName());
            }
        }
        
        return resolvedValue;
    }
    
    private void _saxConfigurationFile(String fileName, Map<String, Object> values) throws TransformerFactoryConfigurationError, Exception
    {
        // create the result where to write
        File outputFile = new File(fileName);
        outputFile.getParentFile().mkdirs();
        
        try (OutputStream os = new FileOutputStream(fileName))
        {
            // create a transformer for saving sax into a file
            TransformerHandler th = ((SAXTransformerFactory) TransformerFactory.newInstance()).newTransformerHandler();
            
            StreamResult result = new StreamResult(os);
            th.setResult(result);

            // create the format of result
            Properties format = new Properties();
            format.put(OutputKeys.METHOD, "xml");
            format.put(OutputKeys.INDENT, "yes");
            format.put(OutputKeys.ENCODING, "UTF-8");
            format.put(OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, "2");
            th.getTransformer().setOutputProperties(format);

            // sax the configuration into the transformer
            _saxParameters(th, values);
        }
        catch (Exception e)
        {
            throw new Exception("An error occured while saving the config values.", e);
        }
    }

    private void _saxParameters(TransformerHandler handler, Map<String, Object> values) throws SAXException
    {
        handler.startDocument();
        XMLUtils.startElement(handler, "config");
        

        // Iterate over categorized parameters
        for (ModelItem category : _categorizedDefinitions)
        {
            if (!(category instanceof ModelItemGroup))
            {
                // Should not happen, categories are created in categorizeParameters method
                continue;
            }
            
            StringBuilder categoryLabel = new StringBuilder();
            categoryLabel.append("+\n      | ");
            categoryLabel.append(category.getLabel().toString());
            categoryLabel.append("\n      +");
            
            // Comment on current category
            XMLUtils.data(handler, "\n  ");
            handler.comment(categoryLabel.toString().toCharArray(), 0, categoryLabel.length());
            XMLUtils.data(handler, "\n");
            XMLUtils.data(handler, "\n");
            
            Iterator<ModelItem> groups = ((ModelItemGroup) category).getChildren().iterator();
            while (groups.hasNext())
            {
                ModelItem group = groups.next();
                if (!(group instanceof ModelItemGroup))
                {
                    // Should not happen, groups are created in categorizeParameters method
                    continue;
                }
                
                StringBuilder groupLabel = new StringBuilder();
                groupLabel.append(" ");
                groupLabel.append(group.getLabel().toString());
                groupLabel.append(" ");

                // Comment on current group
                XMLUtils.data(handler, "  ");
                handler.comment(groupLabel.toString().toCharArray(), 0, groupLabel.length());
                XMLUtils.data(handler, "\n  ");
                
                for (ModelItem definition : ((ModelItemGroup) group).getChildren())
                {
                    if (!(definition instanceof ElementDefinition))
                    {
                        // Should not happen, parameter references are created in categorizeParameters method
                        continue;
                    }
                    
                    Object value = values.get(definition.getName());
                    ElementType<Object> type = ((ElementDefinition) definition).getType();
                    
                    if (!(type instanceof XMLElementType))
                    {
                        // Should not happen, configuration parameters only work with XML element types
                        continue;
                    }
                    
                    ((XMLElementType<Object>) type).write(handler, definition.getName(), value);
                }
                
                if (groups.hasNext())
                {
                    XMLUtils.data(handler, "\n");
                }
            }
            
            XMLUtils.data(handler, "\n");
        }

        XMLUtils.endElement(handler, "config");
        handler.endDocument();
    }

    /**
     * Evaluate the {@link DisableConditions} of the given configuration parameter against the configuration values
     * @param definition the configuration parameter
     * @param config the {@link Config} instance
     * @return <code>true</code> if the parameter is disabled, <code>false</code> otherwise
     */
    public boolean evaluateDisableConditions(ElementDefinition definition, Config config)
    {
        return _disableConditionsEvaluator.evaluateDisableConditions(definition, definition.getName(), config);
    }

    public ModelItem getModelItem(String itemPath) throws UndefinedItemPathException
    {
        ModelItem item = _flatDefinitions.get(itemPath);
        if (item != null)
        {
            return item;
        }
        else
        {
            throw new UndefinedItemPathException("The parameter '" + itemPath + "' is not defined in the configuration.");
        }
    }
    
    /**
     * Retrieves all configuration parameters
     * @return all configuration parameters
     */
    public Collection<ElementDefinition> getConfigurationParameters()
    {
        return _flatDefinitions.values();
    }
    
    public Collection<ModelItem> getModelItems()
    {
        return _categorizedDefinitions;
    }
    
    /**
     * Retrieves the view of Configuration
     * @param i18nUtils the i18nUtils to use categories's sorting
     * @return the configuration's view
     */
    public View getView(I18nUtils i18nUtils)
    {
        Comparator<ModelItem> categoriesComparator = new I18nizableTextModelItemComparator(new I18nizableTextComparator(i18nUtils));
        Comparator<ModelItem> groupsComparator = new I18nizableTextModelItemComparator(new I18nizableTextKeyComparator());
        Comparator<ModelItem> elementsComparator = new ConfigParameterDefinitionComparator(_configParameterWrappers.values());
        
        return ConfigParameterDefinitionHelper.buildConfigParametersView(_categorizedDefinitions, categoriesComparator, groupsComparator, elementsComparator);
    }
    
    /**
     * Gets the parameter checker with its id
     * @param id the id of the parameter checker to get
     * @return the associated parameter checker descriptor
     */
    public ConfigParameterCheckerDescriptor getParameterChecker(String id)
    {
        return _parameterCheckers.get(id);
    }
    
    /**
     * Returns true if the model is initialized and all parameters are valued
     * @return true if the model is initialized and all parameters are valued
     */
    public boolean isComplete()
    {
        return _isInitialized && _isComplete;
    }
    
    /**
     * Returns true if the config file does not exist
     * @return true if the config file does not exist
     */
    public boolean isEmpty()
    {
        return !Config.fileExists();
    }
    
    /**
     * Dispose the manager before restarting it
     */
    public void dispose()
    {
        _isInitialized = false;
        _isComplete = true;

        _usedParamIds = null;
        _declaredParams = null;
        _configParameterWrappers = null;
        _declaredParamCheckers = null;
        _parameterCheckers = null;
        _flatDefinitions = null;
        
        if (_disableConditionsManager != null)
        {
            _disableConditionsManager.dispose();
            _disableConditionsManager = null;
        }
        if (_validatorManager != null)
        {
            _validatorManager.dispose();
            _validatorManager = null;
        }
        if (_enumeratorManager != null)
        {
            _enumeratorManager.dispose();
            _enumeratorManager = null;
        }
        if (_parameterCheckerManager != null)
        {
            _parameterCheckerManager.dispose();
            _parameterCheckerManager = null;
        }
    }

    public String getId()
    {
        return StringUtils.EMPTY;
    }

    public String getFamilyId()
    {
        return this.getClass().getName();
    }
}