/*
 *  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.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeSet;

import org.slf4j.Logger;

import org.ametys.runtime.i18n.I18nizableText;

/**
 * Helper for {@link CategorizedElementDefinitionProxy}
 */
public final class CategorizedElementDefinitionHelper
{
    private CategorizedElementDefinitionHelper()
    {
        //Nothing
    }
    
    /**
     * Get definitions of all elements parsed in this {@link CategorizedElementDefinitionProxy} {@link Collection}, as a flat map.
     * @param elements a {@link Collection} of {@link CategorizedElementDefinitionProxy}
     * @return a map with the definition name as key, containing all definitions
     */
    public static Map<String, ElementDefinition> getFlatDefinitions(Collection<CategorizedElementDefinitionProxy> elements)
    {
        Map<String, ElementDefinition> flatDefinitions = new HashMap<>();
        for (CategorizedElementDefinitionProxy element : elements)
        {
            ElementDefinition definition = element.getDefinition();
            flatDefinitions.put(definition.getName(), definition);
        }
        return flatDefinitions;
    }
    
    /**
     * Categorize the ModlItems based on the informations in the {@link CategorizedElementDefinitionProxy} collection
     * Category and groups are not sorted, only definitions, based on the position.
     * Sorting of category and groups have to be done when the view is created (each usage can be different)
     * @param elements collection of categorized elements
     * @return a list of {@link ModelItem} with the correct tree (category/group/definitions)
     */
    public static List<ModelItem> categorize(Collection<CategorizedElementDefinitionProxy> elements)
    {
        Map<I18nizableText, Map<I18nizableText, List<CategorizedElementDefinitionProxy>>> categories = categorizeToMap(elements);
        //This list is not sorted, only definition are sorted, not groups.
        //Groups should be sorted elsewhere (when creating the view for example)
        List<ModelItem> modelItems = new ArrayList<>();
        for (Entry<I18nizableText, Map<I18nizableText, List<CategorizedElementDefinitionProxy>>> categoryEntry : categories.entrySet())
        {
            ModelItemGroup category = new ModelItemGroup();
            category.setLabel(categoryEntry.getKey());
            modelItems.add(category);
            Map<I18nizableText, List<CategorizedElementDefinitionProxy>> values = categoryEntry.getValue();
            for (Entry<I18nizableText, List<CategorizedElementDefinitionProxy>> groupEntry : values.entrySet())
            {
                ModelItemGroup group = new ModelItemGroup();
                group.setLabel(groupEntry.getKey());
                category.addChild(group);
                
                Collection<CategorizedElementDefinitionProxy> orderedDefinitions = orderDefinitions(groupEntry.getValue());
                for (CategorizedElementDefinitionProxy orderedDefinition : orderedDefinitions)
                {
                    ElementDefinition definition = orderedDefinition.getDefinition();
                    definition.setParent(group);
                    
                    group.addChild(definition, orderedDefinition.isGroupSwitch());
                }
            }
        }
        return modelItems;
    }
    
    /**
     * Organize a collection of skin parameters by categories and groups.
     * @param elements a collection of elements.
     * @return a Map of parameters sorted first by category then group.
     */
    protected static Map<I18nizableText, Map<I18nizableText, List<CategorizedElementDefinitionProxy>>> categorizeToMap(Collection<CategorizedElementDefinitionProxy> elements)
    {
        Map<I18nizableText, Map<I18nizableText, List<CategorizedElementDefinitionProxy>>> categories = new HashMap<>();

        // Classify parameters by groups and categories
        for (CategorizedElementDefinitionProxy parameter : elements)
        {
            I18nizableText displayCategory = parameter.getDisplayCategory();
            I18nizableText displayGroup = parameter.getDisplayGroup();

            // Get the map of groups of the category
            Map<I18nizableText, List<CategorizedElementDefinitionProxy>> category = categories.get(displayCategory);
            if (category == null)
            {
                category = new HashMap<>();
                categories.put(displayCategory, category);
            }

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

            group.add(parameter);
        }
        
        return categories;
    }
    
    /**
     * Order definitions, based on their position
     * @param definitions {@link Collection} of {@link CategorizedElementDefinitionProxy}
     * @return an ordered {@link Collection} of {@link CategorizedElementDefinitionProxy}
     */
    protected static Collection<CategorizedElementDefinitionProxy> orderDefinitions(Collection<CategorizedElementDefinitionProxy> definitions)
    {
        return orderDefinitions(definitions, null, null);
    }
    /**
     * Order definitions, based on their position
     * @param definitions {@link Collection} of {@link CategorizedElementDefinitionProxy}
     * @param categoryLabel label of the category to filter (null to avoid filter)
     * @param groupLabel label of the group (null to avoid filter)
     * @return an ordered {@link Collection} of {@link CategorizedElementDefinitionProxy}
     */
    protected static Collection<CategorizedElementDefinitionProxy> orderDefinitions(Collection<CategorizedElementDefinitionProxy> definitions, I18nizableText categoryLabel, I18nizableText groupLabel)
    {
        Collection<CategorizedElementDefinitionProxy> orderedParameters = new TreeSet<>(new Comparator<CategorizedElementDefinitionProxy>()
        {
            public int compare(CategorizedElementDefinitionProxy o1, CategorizedElementDefinitionProxy o2)
            {
                int positionComparison = ((Long) o1.getPosition()).compareTo(o2.getPosition());
                if (o1.getPosition() < 0 && o2.getPosition() < 0)
                {
                    positionComparison = 0;
                }
                else if (o1.getPosition() < 0 && o2.getPosition() >= 0)
                {
                    positionComparison = 1;
                }
                else if (o2.getPosition() < 0)
                {
                    positionComparison = -1;
                }
                
                if (positionComparison != 0)
                {
                    return positionComparison;
                }
                return o1.getDefinition().compareTo(o2.getDefinition());
            }
        });
        for (CategorizedElementDefinitionProxy parameterProxy : definitions)
        {
            boolean areCategoryAndGroupCoherent = true;
            if (categoryLabel != null)
            {
                areCategoryAndGroupCoherent &= categoryLabel.equals(parameterProxy.getDisplayCategory());
            }
            if (groupLabel != null)
            {
                areCategoryAndGroupCoherent &= groupLabel.equals(parameterProxy.getDisplayGroup());
            }
            if (areCategoryAndGroupCoherent)
            {
                orderedParameters.add(parameterProxy);
            }
        }
        return orderedParameters;
    }
    
    /**
     * Validate parameters before writing
     * @param definitionAndValues a map of all parameters and their values
     * @param flatDefinitions flat definition of {@link ElementDefinition} from the model file
     * @param logger a logger
     * @return a map containing the potential errors
     * @deprecated TODO NEWATTRIBUTEAPI_CONFIG RUNTIME-2851 remove this method when it is not necessary anymore to have the flat definitions
     */
    @Deprecated
    public static Map<String, List<I18nizableText>> validateValuesForWriting (Map<String, DefinitionAndValue> definitionAndValues, Map<String, ElementDefinition> flatDefinitions, Logger logger)
    {
        Map<String, List<I18nizableText>> errorFields = new HashMap<>();
        
        for (ElementDefinition definition : flatDefinitions.values())
        {
            boolean isGroupSwitchOn = ModelHelper.isGroupSwitchOn(definition, DefinitionAndValue.extractValues(definitionAndValues));
            boolean isDisabled = ModelHelper.evaluateDisableConditions(definition.getDisableConditions(), definitionAndValues, logger);
            
            if (isGroupSwitchOn && !isDisabled)
            {
                Object value = null;
                DefinitionAndValue definitionAndValue = definitionAndValues.get(definition.getName());
                if (definitionAndValue != null)
                {
                    value = definitionAndValue.getValue();
                }
                
                List<I18nizableText> errors = ModelHelper.validateValue(definition, value);
                
                if (!errors.isEmpty())
                {
                    logger.warn("The configuration parameter '{}' is not valid", definition.getName());
                    errorFields.put(definition.getName(), errors);
                }
            }
        }
        
        if (!errorFields.isEmpty())
        {
            logger.debug("Failed to save configuration because of invalid parameter values");
        }
        return errorFields;
    }
    
    /**
     * Validate parameters before writing
     * @param definitionAndValues a map of all parameters and their values
     * @param logger a logger
     * @return a map containing the potential errors
     */
    public static Map<String, List<I18nizableText>> validateValuesForWriting (Map<String, DefinitionAndValue> definitionAndValues, Logger logger)
    {
        Map<String, List<I18nizableText>> errorFields = new HashMap<>();
        for (Entry<String, DefinitionAndValue> entry : definitionAndValues.entrySet())
        {
            DefinitionAndValue definitionAndValue = entry.getValue();
            ModelItem definition = definitionAndValue.getDefinition();
            if (definition instanceof ElementDefinition)
            {
                ElementDefinition elementDefinition = (ElementDefinition) definition;
                boolean isGroupSwitchOn = ModelHelper.isGroupSwitchOn(elementDefinition, DefinitionAndValue.extractValues(definitionAndValues));
                boolean isDisabled = ModelHelper.evaluateDisableConditions(elementDefinition.getDisableConditions(), definitionAndValues, logger);
                
                if (isGroupSwitchOn && !isDisabled)
                {
                    Object value = definitionAndValue.getValue();
                    
                    List<I18nizableText> errors = ModelHelper.validateValue(elementDefinition, value);
                    
                    if (!errors.isEmpty())
                    {
                        logger.warn("The configuration parameter '{}' is not valid", elementDefinition.getName());
                        errorFields.put(elementDefinition.getName(), errors);
                    }
                }
            }
        }
        
        if (!errorFields.isEmpty())
        {
            logger.debug("Failed to save configuration because of invalid parameter values");
        }
        return errorFields;
    }
    
    /**
     * Generate the wiew for a list of {@link ModelItem}, using comparators to sort the categories and the groups
     * This works only on the very specific categories/group/fieldset hierarchy and an {@link IllegalArgumentException} will be thrown if the hierarchy is incorrect.
     * @param categories list of {@link ModelItem}
     * @param categoriesComparator {@link Comparator} used for the categories (can be null to keep order)
     * @param groupsComparator {@link Comparator} for the groups (can be null to keep order)
     * @return A {@link View} ordered from the {@link ModelItem} using the {@link Comparator}
     * @throws IllegalArgumentException the hierarchy of the categories/groups/elements is incorrect
     */
    public static View buildViewFromCategories(Collection<? extends ModelItem> categories, Comparator<? super ModelItem> categoriesComparator, Comparator<? super ModelItem> groupsComparator) throws IllegalArgumentException
    {
        View view = new View();
        
        Collection<? extends ModelItem> sorted = _sort(categories, categoriesComparator);
        
        for (ModelItem modelItem : sorted)
        {
            view.addViewItem(_buildCategoryViewItem(modelItem, groupsComparator));
        }
        return view;
    }
    
    /**
     * sort a model item list using comparator
     * @param items list of items to sort
     * @param comparator a comparator, can be null to avoid sort
     * @return a sorted list (or a copy of the list if the comparator is null)
     */
    private static Collection<? extends ModelItem> _sort(Collection<? extends ModelItem> items, Comparator<? super ModelItem> comparator)
    {
        if (comparator == null)
        {
            return items;
        }
        else
        {
            List<ModelItem> sorted = new ArrayList<>(items);
            sorted.sort(comparator);
            return sorted;
        }
    }
    
    private static ModelViewItemGroup _buildCategoryViewItem(ModelItem category, Comparator<? super ModelItem> groupsComparator) throws IllegalArgumentException
    {
        if (category instanceof ModelItemGroup)
        {
            ModelItemGroup modelGroup = (ModelItemGroup) category;
            ModelViewItemGroup categoryViewItem = new ModelViewItemGroup();
            categoryViewItem.setRole(ViewItemGroup.TAB_ROLE);
            categoryViewItem.setDefinition(modelGroup);
            
            Collection<? extends ModelItem> groups = _sort(modelGroup.getChildren(), groupsComparator);
            
            for (ModelItem group : groups)
            {
                categoryViewItem.addViewItem(_buildGroupViewItem(group));
            }
            return categoryViewItem;
        }
        else
        {
            throw new IllegalArgumentException("Category " + category.getPath() + " should be an instance of ModelItemGroup");
        }
    }
    
    private static ModelViewItemGroup _buildGroupViewItem(ModelItem modelItem) throws IllegalArgumentException
    {
        if (modelItem instanceof ModelItemGroup)
        {
            ModelItemGroup modelGroup = (ModelItemGroup) modelItem;
            ModelViewItemGroup groupViewItem = new ModelViewItemGroup();
            groupViewItem.setRole(ViewItemGroup.FIELDSET_ROLE);
            groupViewItem.setDefinition(modelGroup);
            List<ModelItem> items = modelGroup.getChildren(); // They are already sorted
            for (ModelItem item : items)
            {
                groupViewItem.addViewItem(_buildElementViewItem(item));
            }
            return groupViewItem;
        }
        else
        {
            throw new IllegalArgumentException("Group " + modelItem.getPath() + " should be an instance of ModelItemGroup");
        }
    }
    
    private static ModelViewItem _buildElementViewItem(ModelItem modelItem) throws IllegalArgumentException
    {
        if (modelItem instanceof ElementDefinition)
        {
            ElementDefinition definition = (ElementDefinition) modelItem;
            
            ViewElement parameterViewItem = new ViewElement();
            parameterViewItem.setDefinition(definition);
            return parameterViewItem;
        }
        else
        {
            throw new IllegalArgumentException("Item " + modelItem.getPath() + " should be an instance of ElementDefinition");
        }
    }
}