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

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

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.ametys.runtime.config.DisableCondition;
import org.ametys.runtime.config.DisableCondition.OPERATOR;
import org.ametys.runtime.config.DisableConditions;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.Errors;
import org.ametys.runtime.parameter.Validator;

/**
 * Helper class for models
 */
public final class ModelHelper
{
    private static final Logger __LOGGER = LoggerFactory.getLogger(ModelHelper.class);
    
    private ModelHelper()
    {
        // Empty constructor
    }
    
    /**
     * Checks if there is a model item at the given relative path
     * @param path path of the model item. This path is relative to the given accessors. No matter if it is a definition or data path (with repeater entry positions)
     * @param itemAccessors model item accessors where to search if there is a model item
     * @return <code>true</code> if there is model item at this path, <code>false</code> otherwise
     * @throws IllegalArgumentException if the given path is null or empty
     */
    public static boolean hasModelItem(String path, Collection<? extends ModelItemAccessor> itemAccessors) throws IllegalArgumentException
    {
        try
        {
            getModelItem(path, itemAccessors);
            return true;
        }
        catch (UndefinedItemPathException e)
        {
            return false;
        }
    }
    
    /**
     * Retrieves the model item at the given relative path
     * @param path path of the model item to retrieve. This path is relative to the given accessors. No matter if it is a definition or data path (with repeater entry positions)
     * @param itemAccessors model item accessors where to search the model item
     * @return the model item
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if there is no item defined at the given path in given item accessors
     */
    public static ModelItem getModelItem(String path, Collection<? extends ModelItemAccessor> itemAccessors) throws IllegalArgumentException, UndefinedItemPathException
    {
        if (StringUtils.isEmpty(path))
        {
            throw new IllegalArgumentException("Unable to retrieve the model item at the given path. This path is empty.");
        }
        
        String definitionPath = getDefinitionPathFromDataPath(path);
        
        ModelItem item = null;
        for (ModelItemAccessor accessor : itemAccessors)
        {
            if (accessor.hasModelItem(definitionPath))
            {
                item = accessor.getModelItem(definitionPath);
                break;
            }
        }
        
        if (item != null)
        {
            return item;
        }
        else
        {
            String absolutePath = path;
            if (itemAccessors.size() == 1)
            {
                ModelItemAccessor accessor = itemAccessors.iterator().next();
                if (accessor instanceof ModelItemGroup)
                {
                    absolutePath = ((ModelItemGroup) accessor).getPath() + ModelItem.ITEM_PATH_SEPARATOR + path;
                }
            }
            
            throw new UndefinedItemPathException("Unable to retrieve the model item at path '" + absolutePath + "'. This path is not defined by the model.");
        }
    }
    
    /**
     * Retrieves all model items of given containers.
     * @param itemContainers The model items containers
     * @return the model items
     * @throws IllegalArgumentException if some models define a model item with the same name and this model item does not come from a common ancestor 
     */
    public static Collection<? extends ModelItem> getModelItems(Collection<? extends ModelItemContainer> itemContainers)
    {
        Map<String, ModelItem> items = new LinkedHashMap<>();

        for (ModelItemContainer itemContainer : itemContainers)
        {
            for (ModelItem currentItem : itemContainer.getModelItems())
            {
                final String currentItemName = currentItem.getName();
                if (items.containsKey(currentItemName))
                {
                    ModelItem existingItem = items.get(currentItemName);
                    
                    if (!currentItem.getModel().equals(existingItem.getModel()))
                    {
                        // The definition does not provide from a common ancestor
                        throw new IllegalArgumentException("The model item '" + currentItemName + "' defined in model '" + currentItem.getModel().getId() + "' is already defined in another model '"
                                + existingItem.getModel().getId() + "'");
                    }
                    continue;
                }

                items.put(currentItemName, currentItem);
            }
        }

        return items.values();
    }
    
    /**
     * Retrieve the list of successive model items represented by the given paths, indexed by path.
     * @param paths paths of the model items to retrieve. These paths are relative to the given accessors. No matter if they are definition or data paths (with repeater entry positions)
     * @param itemAccessors model item accessors where to search the model items
     * @return the list of successive model items, indexed by path
     * @throws IllegalArgumentException if one of the given paths is null or empty
     * @throws UndefinedItemPathException if there is no item defined at one of the given paths in given item accessors
     */
    public static Map<String, List<ModelItem>> getAllModelItemsInPaths(Set<String> paths, Collection<? extends ModelItemAccessor> itemAccessors) throws IllegalArgumentException, UndefinedItemPathException
    {
        Map<String, List<ModelItem>> result = new HashMap<>();
        
        for (String path : paths)
        {
            result.put(path, ModelHelper.getAllModelItemsInPath(path, itemAccessors));
        }
        
        return result;
    }
    
    /**
     * Retrieve the list of successive model items represented by the given path.
     * @param path path of the model items to retrieve. This path is relative to the given accessors. No matter if it is a definition or data path (with repeater entry positions)
     * @param itemAccessors model item accessors where to search the model items
     * @return the list of successive model items
     * @throws IllegalArgumentException if the given path is null or empty
     * @throws UndefinedItemPathException if there is no item defined at the given path in given item accessors
     */
    public static List<ModelItem> getAllModelItemsInPath(String path, Collection<? extends ModelItemAccessor> itemAccessors) throws IllegalArgumentException, UndefinedItemPathException
    {
        if (StringUtils.isEmpty(path))
        {
            throw new IllegalArgumentException("Unable to retrieve the model item at the given path. This path is empty.");
        }
        
        String definitionPath = getDefinitionPathFromDataPath(path);
        
        for (ModelItemAccessor itemAccessor : itemAccessors)
        {
            // If the current accessor has the model item at given path, no need to check in the other accessors
            // Given containers represent only one whole model, so a path can't refer to different definitions
            List<ModelItem> modelItemPath = _getAllModelItemsInPath(definitionPath, itemAccessor);
            if (!modelItemPath.isEmpty())
            {
                return modelItemPath;
            }
        }
        
        // No path has been found in the different containers
        throw new UndefinedItemPathException("Unable to retrieve the model items at path '" + definitionPath + "'. This path is not defined by the model.");
    }
    
    private static List<ModelItem> _getAllModelItemsInPath(String definitionPath, ModelItemAccessor itemAccessor)
    {
        List<ModelItem> definitions = new ArrayList<>();

        String[] pathSegments = StringUtils.split(definitionPath, ModelItem.ITEM_PATH_SEPARATOR);
        
        ModelItemAccessor currentModelItemAccessor = itemAccessor;
        for (int i = 0; i < pathSegments.length; i++)
        {
            ModelItem modelItem = currentModelItemAccessor.getChild(pathSegments[i]);
            if (modelItem != null)
            {
                definitions.add(modelItem);
            }
            else
            {
                return Collections.emptyList();
            }
            
            if (modelItem instanceof ModelItemAccessor)
            {
                currentModelItemAccessor = (ModelItemAccessor) modelItem;
            }
        }
        
        return definitions;
    }
    

    /**
     * Determines if a container of model items contains a model item of the given type
     * @param container the model item container
     * @param type the type identifier to find.
     * @return true if a model item of the given type is found
     */
    public static boolean hasModelItemOfType(ModelItemContainer container, String type)
    {
        for (ModelItem childItem : container.getModelItems())
        {
            if (type.equals(childItem.getType().getId()))
            {
                return true;
            }
            else if (childItem instanceof ModelItemGroup)
            {
                // recurse on repeater and composites
                if (hasModelItemOfType((ModelItemGroup) childItem, type))
                {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    /**
     * Find all model items of the given type
     * @param container the model item container
     * @param type the type identifier to find.
     * @return the list of {@link ModelItem}s of this type
     */
    public static List<ModelItem> findModelItemsByType(ModelItemContainer container, String type)
    {
        List<ModelItem> items = new ArrayList<>();
        
        for (ModelItem childItem : container.getModelItems())
        {
            if (type.equals(childItem.getType().getId()))
            {
                items.add(childItem);
            }
            else if (childItem instanceof ModelItemGroup)
            {
                // recurse on repeater and composites
                items.addAll(findModelItemsByType((ModelItemGroup) childItem, type));
            }
        }
        
        return items;
    }
    
    /**
     * Retrieves the given dataPath as a definition path (without the repeaterEntry positions)
     * @param dataPath the data path
     * @return the definition path
     */
    public static String getDefinitionPathFromDataPath(String dataPath)
    {
        return dataPath.replaceAll("\\[[0-9]+\\]", "");
    }
    
    /**
     * Checks if this item is in a group with a switch on
     * @param modelItem the item to check
     * @param values all items' values to get switchers' values
     * @return false if this item is part of a group with a switch to off, true otherwise 
     */
    public static boolean isGroupSwitchOn(ModelItem modelItem, Map<String, Object> values)
    {
        Pair<Boolean, ElementDefinition> isGroupActive = _isModelItemGroupActive(modelItem.getParent(), values);
        if (isGroupActive.getKey())
        {
            return true;
        }
        return modelItem.equals(isGroupActive.getValue());
    }
    
    private static Pair<Boolean, ElementDefinition> _isModelItemGroupActive(ModelItemGroup group, Map<String, Object> values)
    {
        if (group == null)
        {
            return new ImmutablePair<>(true, null);
        }
        
        ElementDefinition<Boolean> groupSwitch = group.getSwitcher();
        if (groupSwitch == null)
        {
            return _isModelItemGroupActive(group.getParent(), values);
        }
        
        Object value = values.get(groupSwitch.getName());
        
        if (value == null)
        {
            value = groupSwitch.getDefaultValue();
        }
        
        if (!(value instanceof Boolean))
        {
            throw new IllegalStateException("The switcher value of group " + group.getName() + " is null or not a boolean");
        }
        
        return (Boolean) value ? _isModelItemGroupActive(group.getParent(), values) : new ImmutablePair<>(false, groupSwitch);
    }
    
    /**
     * Recursively evaluate the {@link DisableConditions} against the given values
     * @param disableConditions the disable conditions to evaluate
     * @param definitionAndValues the values to evaluate
     * @param logger the logger for disable conditions evaluation logs
     * @return true if the disable conditions are true, false otherwise
     */
    public static boolean evaluateDisableConditions(DisableConditions disableConditions, Map<String, DefinitionAndValue> definitionAndValues, Logger logger)
    {
        if (!_hasDisableConditions(disableConditions))
        {
            return false;
        }
        
        boolean disabled;
        boolean andOperator = disableConditions.getAssociationType() == DisableConditions.ASSOCIATION_TYPE.AND;
        
        // initial value depends on OR or AND associations
        disabled = andOperator;
        
        for (DisableConditions subConditions : disableConditions.getSubConditions())
        {
            boolean result = evaluateDisableConditions(subConditions, definitionAndValues, logger);
            disabled = andOperator ?  disabled && result : disabled || result;
        }
        
        for (DisableCondition condition : disableConditions.getConditions())
        {
            boolean result = _evaluateCondition(condition, definitionAndValues, logger);
            disabled = andOperator ?  disabled && result : disabled || result;
        }
                
        return disabled;
    }

    private static boolean _hasDisableConditions(DisableConditions disableConditions)
    {
        return disableConditions != null && !disableConditions.getConditions().isEmpty() && disableConditions.getSubConditions().isEmpty();
    }
    
    private static boolean _evaluateCondition(DisableCondition condition, Map<String, DefinitionAndValue> definitionAndValues, Logger logger)
    {
        String id = condition.getId();
        DisableCondition.OPERATOR operator = condition.getOperator();
        String conditionValue = condition.getValue();
        
        DefinitionAndValue definitionAndValue = definitionAndValues.get(id);
        if (definitionAndValue == null || !(definitionAndValue.getDefinition() instanceof ElementDefinition))
        {
            logger.debug("Cannot evaluate the disable condition on the undefined element {}.\nReturning false.", id);
            return false;
        }
        
        ElementType type = ((ElementDefinition) definitionAndValue.getDefinition()).getType();
        Object compareValue = type.castValue(conditionValue);
        if (compareValue == null)
        {
            throw new IllegalStateException("Cannot convert the condition value '" + conditionValue + "' to a '" + type.getId() + "' for model item '" + id + "'");
        }
        
        try
        {
            Object value = definitionAndValue.getValue();
            if (value instanceof Collection)
            {
                if (operator == OPERATOR.EQ)
                {
                    for (Object v: (Collection) value)
                    {
                        if (_evaluateConditionValue(v, operator, compareValue))
                        {
                            // One entry matches
                            return true;
                        }
                    }
                
                    return false;
                }
                else
                {
                    for (Object v: (Collection) value)
                    {
                        if (!_evaluateConditionValue(v, operator, compareValue))
                        {
                            // One entry does not match
                            return false;
                        }
                    }
                
                    return true;
                }
            }
            else
            {
                return _evaluateConditionValue(value, operator, compareValue);
            }
        }
        catch (Exception e)
        {
            throw new IllegalStateException("An error occurred while comparing values in type'" + type + "' for model item '" + id + "'.", e);
        }
    }
    private static boolean _evaluateConditionValue(Object value, DisableCondition.OPERATOR operator, Object compareValue)
    {
        if ((value == null || value instanceof Comparable) && (compareValue == null || compareValue instanceof Comparable))
        {
            @SuppressWarnings("unchecked")
            Comparable<Object> comparableParameterValue = (Comparable<Object>) _emptyStringToNull(value);
            @SuppressWarnings("unchecked")
            Comparable<Object> comparableCompareValue = (Comparable<Object>) _emptyStringToNull(compareValue);
            
            int comparison;
            if (comparableParameterValue != null && comparableCompareValue != null)
            {
                comparison = comparableParameterValue.compareTo(comparableCompareValue);
            }
            else if (comparableCompareValue != null)
            {
                comparison = -1; // null comparableParameterValue is considered less than non-null comparableCompareValue
            }
            else if (comparableParameterValue != null)
            {
                comparison = 1; // non-null comparableParameterValue is considered greater than null comparableCompareValue
            }
            else
            {
                comparison = 0; // both are null
            }
            
            switch (operator)
            {
                case NEQ:
                    return comparison != 0;
                case GEQ:
                    return comparison >= 0;
                case GT:
                    return comparison > 0;
                case LT:
                    return comparison < 0;
                case LEQ:
                    return comparison <= 0;
                case EQ:
                default:
                    return comparison == 0;
            }
        }
        else
        {
            throw new IllegalStateException("Values '" + value + "' and '" + compareValue + "' are not comparable");
        }
    }
    
    private static Object _emptyStringToNull(Object compareValue)
    {
        if ("".equals(compareValue))
        {
            return null;
        }
        else
        {
            return  compareValue;
        }
    }

    /**
     * Validates the given value
     * @param definition The definition to use to validate the value
     * @param value the value to validate
     * @return the structure with errors information if the validation failed.
     */
    public static List<I18nizableText> validateValue(ElementDefinition definition, Object value)
    {
        return validateValue(definition, value, true);
    }
    
    /**
     * Validates the given value
     * @param definition The definition to use to validate the value
     * @param value the value to validate
     * @param checkEnumerated <code>true</code> true to make sure that the item with an enumerator has its value in the enumerated values
     * @return the structure with errors information if the validation failed.
     * TODO NEWATTRIBUTEAPI RUNTIME-2897: remove this method to always check enumerator when validating a value 
     */
    public static List<I18nizableText> validateValue(ElementDefinition definition, Object value, boolean checkEnumerated)
    {
        List<I18nizableText> errorsList = new ArrayList<>();
        Errors errors = new Errors();

        ElementType type = definition.getType();
        if (value != null && !type.isCompatible(value))
        {
            errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
        }
        else
        {
            Validator validator = definition.getValidator();
            if (validator != null)
            {
                validator.validate(value, errors);
                if (errors.hasErrors())
                {
                    errorsList.addAll(errors.getErrors());
                }
            }
            
            if (checkEnumerated)
            {
                if (definition.isMultiple())
                {
                    Object[] values = (Object[]) value;
                    if (values != null)
                    {  
                        for (Object singleValue : values)
                        {
                            _validateEnumeration(definition, singleValue, errorsList);
                        }
                    }
                    
                }
                else
                {
                    _validateEnumeration(definition, value, errorsList);
                }
            }
        }
        
        return errorsList;
    }
    
    private static void _validateEnumeration(ElementDefinition definition, Object value, List<I18nizableText> errorsList)
    {
        if (_checkValueEnumeration(value))
        {
            // Make sure that the item with an enumerator has its value in the enumerated values
            Enumerator<Object> enumerator = definition.getEnumerator();
            if (enumerator != null)
            {
                I18nizableText entry = null;
                try
                {
                    entry = enumerator.getEntry(value);
                }
                catch (Exception e)
                {
                    __LOGGER.warn("An error occured while checking enumerated value '{}' for '{}'", value, enumerator, e);
                    errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_LED_TO_EXCEPTION"));
                    return;
                }
                
                if (entry == null)
                {
                    errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
                }
            }
        }
    }
    
    private static boolean _checkValueEnumeration(Object value)
    {
        if (value == null)
        {
            return false;
        }
        else
        {
            return value instanceof String ? StringUtils.isNotEmpty((String) value) : true;
        }
    }
    
    /**
     * Stores a configuration and the name of the plugin in which is declared the configuration
     * @param configuration the configuration itself
     * @param pluginName the name of the plugin in which is declared the configuration
     */
    public record ConfigurationAndPluginName(Configuration configuration, String pluginName) { /* empty */ }
}