/*
 *  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.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.i18n.I18nizableText;
import org.ametys.runtime.model.disableconditions.DisableCondition;
import org.ametys.runtime.model.disableconditions.DisableConditions;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.parameter.ValidationResult;
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 accessors.
     * @param itemAccessors The model items accessors
     * @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 ModelItemAccessor> itemAccessors)
    {
        Map<String, ModelItem> items = new LinkedHashMap<>();

        for (ModelItemAccessor itemContainer : itemAccessors)
        {
            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(ModelItemAccessor 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(ModelItemAccessor 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);
    }
    
    /**
     * Retrieves the absolute path of the condition
     * @param condition the condition
     * @param relativePath the relative path for computing condition absolute path (path of the model item defining the condition, or path of an evaluated data)
     * @return the absolute path of the condition
     * @throws IllegalArgumentException if the path of the condition can not be computed from the given relative path
     */
    public static String getDisableConditionAbsolutePath(DisableCondition condition, String relativePath) throws IllegalArgumentException
    {
        String[] conditionPathSegments = StringUtils.split(condition.getId(), ModelItem.ITEM_PATH_SEPARATOR);
        String[] relativePathSegments = StringUtils.split(relativePath, ModelItem.ITEM_PATH_SEPARATOR);
        
        int nbParentSegmentInConditionPath = 0;
        String conditionPathSegment = conditionPathSegments[nbParentSegmentInConditionPath];
        while ("..".equals(conditionPathSegment))
        {
            nbParentSegmentInConditionPath++;
            conditionPathSegment = conditionPathSegments[nbParentSegmentInConditionPath];
        }
        
        int prefixLength = relativePathSegments.length - (nbParentSegmentInConditionPath + 1);
        if (prefixLength < 0)
        {
            String message = String.format("Unable to retrieve the condition absolute path from condition '%s' and relative path '%s'. The condition path has to many relative parents segments.", condition.getId(), relativePath);
            throw new IllegalArgumentException(message);
        }
        
        // Take the first segments of relative path
        String prefix = StringUtils.join(relativePathSegments, ModelItem.ITEM_PATH_SEPARATOR, 0, relativePathSegments.length - (nbParentSegmentInConditionPath + 1));
        // and the last ones of the condition path
        String suffix = StringUtils.join(conditionPathSegments, ModelItem.ITEM_PATH_SEPARATOR, nbParentSegmentInConditionPath, conditionPathSegments.length);
        
        return StringUtils.isNotBlank(prefix) ? prefix + ModelItem.ITEM_PATH_SEPARATOR + suffix : suffix;
    }
    
    /**
     * Check if the given model item contains non empty disable conditions 
     * @param modelItem the model item to check
     * @return <code>true</code> if a non empty condition has been found, <code>false</code> otherwise
     */
    public static boolean hasDisableConditions(ModelItem modelItem)
    {
        return hasDisableConditions(modelItem.getDisableConditions());
    }
    
    /**
     * Check if there is a non empty condition in the given conditions
     * @param disableConditions the disable conditions to check
     * @return <code>true</code> if a non empty condition has been found, <code>false</code> otherwise
     */
    public static boolean hasDisableConditions(DisableConditions disableConditions)
    {
        if (disableConditions == null)
        {
            return false;
        }

        if (!disableConditions.getConditions().isEmpty())
        {
            // a condition has been found
            return true;
        }
        
        return disableConditions.getSubConditions()
                                .stream()
                                // search for a non empty sub condition
                                .anyMatch(ModelHelper::hasDisableConditions);
    }

    /**
     * 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 ValidationResult 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 ValidationResult validateValue(ElementDefinition definition, Object value, boolean checkEnumerated)
    {
        ValidationResult result = new ValidationResult();

        ElementType type = definition.getType();
        if (value != null && !type.isCompatible(value))
        {
            result.addError(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
        }
        else
        {
            Validator validator = definition.getValidator();
            if (validator != null)
            {
                result.addResult(validator.validate(value));
            }
            
            if (checkEnumerated)
            {
                if (definition.isMultiple())
                {
                    Object[] values = (Object[]) value;
                    if (values != null)
                    {  
                        for (Object singleValue : values)
                        {
                            result.addResult(_validateEnumeration(definition, singleValue));
                        }
                    }
                    
                }
                else
                {
                    result.addResult(_validateEnumeration(definition, value));
                }
            }
        }
        
        return result;
    }
    
    private static ValidationResult _validateEnumeration(ElementDefinition definition, Object value)
    {
        ValidationResult result = new ValidationResult();
        
        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)
            {
                try
                {
                    I18nizableText entry = enumerator.getEntry(value);
                    if (entry == null)
                    {
                        result.addError(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
                    }
                }
                catch (Exception e)
                {
                    __LOGGER.warn("An error occured while checking enumerated value '{}' for '{}'", value, enumerator, e);
                    result.addError(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_LED_TO_EXCEPTION"));
                }
            }
        }
        
        return result;
    }
    
    private static boolean _checkValueEnumeration(Object value)
    {
        if (value == null)
        {
            return false;
        }
        else
        {
            return value instanceof String ? StringUtils.isNotEmpty((String) value) : true;
        }
    }
}