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

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;

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.type.ElementType;
import org.ametys.runtime.parameter.Errors;
import org.ametys.runtime.parameter.Validator;

/**
 * Helper class for models
 */
public final class ModelHelper
{
    private ModelHelper()
    {
        // Empty constructor
    }
    
    /**
     * 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.getManagedClass().isInstance(value) && !type.getManagedClassArray().isInstance(value))
        {
            errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
        }
        
        Validator validator = definition.getValidator();
        if (validator != null)
        {
            validator.validate(value, errors);
            if (errors.hasErrors())
            {
                errorsList.addAll(errors.getErrors());
            }
        }
        
        if (value != null && checkEnumerated)
        {
            // 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)
                {
                    errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_LED_TO_EXCEPTION"));
                }
                
                if (entry == null)
                {
                    errorsList.add(new I18nizableText("plugin.core", "PLUGINS_CORE_ELEMENT_DEFINITION_VALUE_NOT_ALLOWED"));
                }
            }
        }
            
        return errorsList;
    }
}