/*
 *  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.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.runtime.config.Config;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.UnknownTypeException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ElementType;
import org.ametys.runtime.model.type.ModelItemType;
import org.ametys.runtime.parameter.Validator;
import org.ametys.runtime.plugin.ExtensionPoint;

/**
 * The definition of a single model item (parameter, attribute)
 * @param <T> Type of the element value
 */
public class DefaultElementDefinition<T> extends AbstractModelItem implements ElementDefinition<T>
{
    /** The definition logger */
    protected Logger _logger = LoggerFactory.getLogger(this.getClass());
    
    private ElementType<T> _type;
    private Enumerator<T> _enumerator;
    private String _customEnumerator;
    private Configuration _enumeratorConfiguration;
    private Validator _validator;
    private String _customValidator;
    private Configuration _validatorConfiguration;
    private boolean _isMultiple;
    private List<Pair<String, Object>> _parsedDefaultValues;

    /**
     * Default constructor.
     */
    public DefaultElementDefinition()
    {
        super();
    }
    
    /**
     * Constructor used to create simple models and items 
     * @param name the name of the definition
     * @param isMultiple the element multiple status
     * @param type the type of the definition
     */
    public DefaultElementDefinition(String name, boolean isMultiple, ElementType<T> type)
    {
        super(name);
        _type = type;
        _isMultiple = isMultiple;
    }
    
    /**
     * Constructor by copying an existing {@link ElementDefinition}.
     * @param definitionToCopy The {@link ElementDefinition} to copy
     */
    public DefaultElementDefinition(ElementDefinition<T> definitionToCopy)
    {
        super(definitionToCopy);
        
        // ElementDefinition
        setType(definitionToCopy.getType());
        
        // Enumerator
        setEnumerator(definitionToCopy.getEnumerator());
        setCustomEnumerator(definitionToCopy.getCustomEnumerator());
        setEnumeratorConfiguration(definitionToCopy.getEnumeratorConfiguration());
        
        // Validator
        setValidator(definitionToCopy.getValidator());
        setCustomValidator(definitionToCopy.getCustomValidator());
        setValidatorConfiguration(definitionToCopy.getValidatorConfiguration());
        
        // Other
        setParsedDefaultValues(definitionToCopy._getParsedDefaultValues());
        setMultiple(definitionToCopy.isMultiple());
    }
    
    @Override
    public ElementType<T> getType()
    {
        return _type;
    }

    @SuppressWarnings("unchecked")
    public void setType(ModelItemType type)
    {
        if (type instanceof ElementType)
        {
            _type = (ElementType<T>) type;
        }
        else
        {
            throw new IllegalArgumentException("Unable to set the type '" + type.getClass() + "' on the element type '" + getName() + "'");
        }
    }
    
    public Enumerator<T> getEnumerator()
    {
        return _enumerator;
    }

    public void setEnumerator(Enumerator<T> enumerator)
    {
        _enumerator = enumerator;
    }
    
    public String getCustomEnumerator()
    {
        return _customEnumerator;
    }
    
    public void setCustomEnumerator(String customEnumerator)
    {
        this._customEnumerator = customEnumerator;
    }

    public Configuration getEnumeratorConfiguration()
    {
        return _enumeratorConfiguration;
    }
    
    public void setEnumeratorConfiguration(Configuration enumeratorConfiguration)
    {
        _enumeratorConfiguration = enumeratorConfiguration;
    }

    public Validator getValidator()
    {
        if (isEditable())
        {
            return _validator;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator");
        }
    }

    public void setValidator(Validator validator)
    {
        if (isEditable())
        {
            _validator = validator;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator");
        }
    }
    
    public String getCustomValidator()
    {
        if (isEditable())
        {
            return _customValidator;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator");
        }
    }
    
    public void setCustomValidator(String customValidator)
    {
        if (isEditable())
        {
            this._customValidator = customValidator;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator");
        }
    }
    
    public Configuration getValidatorConfiguration()
    {
        if (isEditable())
        {
            return _validatorConfiguration;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator configuration");
        }
    }
    
    @Override
    public String getWidget()
    {
        if (isEditable())
        {
            return super.getWidget();
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a widget");
        }
    }
    
    @Override
    public void setWidget(String widget)
    {
        if (isEditable())
        {
            super.setWidget(widget);
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a widget");
        }
    }
    
    @Override
    public Map<String, I18nizableText> getWidgetParameters()
    {
        if (isEditable())
        {
            return super.getWidgetParameters();
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have widget parameters");
        }
    }
    
    @Override
    public void setWidgetParameters(Map<String, I18nizableText> params)
    {
        if (isEditable())
        {
            super.setWidgetParameters(params);
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have widget parameters");
        }
    }
    
    public void setValidatorConfiguration(Configuration validatorConfiguration)
    {
        if (isEditable())
        {
            _validatorConfiguration = validatorConfiguration;
        }
        else
        {
            throw new UnsupportedOperationException("The definition '" + getPath() + "' is not editable, it cannot have a validator configuration");
        }
    }
    
    @SuppressWarnings("unchecked")
    public <X> X getDefaultValue()
    {
        if (_parsedDefaultValues != null)
        {
            if (isMultiple())
            {
                Object defaultValuesAsArray = Array.newInstance(getType().getManagedClass(), _parsedDefaultValues.size());
                int index = 0;
                for (Pair<String, Object> parsedDefaultValue : _parsedDefaultValues)
                {
                    // Compute the parsed default value according to the default value type 
                    T defaultValue = _getDefaultValue(parsedDefaultValue.getLeft(), parsedDefaultValue.getRight());
                    Array.set(defaultValuesAsArray, index, defaultValue);
                    index++;
                }

                return (X) defaultValuesAsArray;
            }
            else
            {
                if (!_parsedDefaultValues.isEmpty())
                {
                    if (_parsedDefaultValues.size() > 1)
                    {
                        _logger.warn("the data '" + this + "' is single, only the first declared default value will be used");
                    }
                    
                    // Compute the parsed default value according to the default value type
                    Pair<String, Object> parsedDefaultValue = _parsedDefaultValues.get(0);
                    return (X) _getDefaultValue(parsedDefaultValue.getLeft(), parsedDefaultValue.getRight());
                }
                else 
                {
                    return null;
                }
            }
        }
        else
        {
            return null;
        }
    }
    
    /**
     * Retrieves the default value from the parsed one, according to the type of the default value
     * @param parsedDefaultValue the parsed default value (can be an {@link I18nizableText}, a config parameter name, ... depending on the default value type)
     * @param defaultValueType the type of the default value
     * @return the default value.
     */
    @SuppressWarnings("unchecked")
    protected T _getDefaultValue(String defaultValueType, Object parsedDefaultValue)
    {
        if (CONFIG_DEFAULT_VALUE_TYPE.equals(defaultValueType))
        {
            assert parsedDefaultValue instanceof String;
            return Config.getInstance().getValue((String) parsedDefaultValue);
        }
        else
        {
            return (T) parsedDefaultValue;
        }
    }
    
    public void setParsedDefaultValues(List<Pair<String, Object>> parsedDefaultValues)
    {
        _parsedDefaultValues = parsedDefaultValues;
    }
    
    public void setDefaultValue(T defaultValue)
    {
        _parsedDefaultValues = List.of(new ImmutablePair<>(null, defaultValue));
    }
    
    public List<Pair<String, Object>> _getParsedDefaultValues()
    {
        return _parsedDefaultValues;
    }

    public boolean isMultiple()
    {
        return _isMultiple;
    }
    
    public void setMultiple(boolean isMultiple)
    {
        _isMultiple = isMultiple;
    }

    @Override
    protected Map<String, Object> _toJSON(DefinitionContext context) throws ProcessingException
    {
        Map<String, Object> result = super._toJSON(context);
        
        result.put("multiple", isMultiple());
        
        if (getType() != null)
        {
            result.put("type", getType().getId());
            result.put("default-value", getType().valueToJSONForClient(getDefaultValue(), DataContext.newInstance()));
        }
        
        
        if (getValidator() != null)
        {
            result.put("validation", getValidator().getConfiguration());
        }
        
        if (getEnumerator() != null)
        {
            List<Map<String, Object>> enumeration = new ArrayList<>();
            
            try
            {
                Map<T, I18nizableText> entries = getEnumerator().getTypedEntries();
                for (Map.Entry<T, I18nizableText> entry : entries.entrySet())
                {
                    Map<String, Object> option = new HashMap<>();
                    option.put("value", getType().valueToJSONForClient(entry.getKey(), DataContext.newInstance()));
                    option.put("label", entry.getValue());
                    enumeration.add(option);
                }
            }
            catch (Exception e)
            {
                throw new ProcessingException("Unable to enumerate entries with enumerator: " + getEnumerator(), e);
            }
            
            result.put("enumeration", enumeration);
            result.put("enumerationConfig", getEnumerator().getConfiguration());
        }
        
        return result;
    }
    
    @Override
    public void toSAX(ContentHandler contentHandler, DefinitionContext context) throws SAXException
    {
        super.toSAX(contentHandler, context);
        
        if (getType() != null)
        {
            getType().valueToSAX(contentHandler, "default-value", getDefaultValue(), DataContext.newInstance());

            if (getEnumerator() != null)
            {
                XMLUtils.startElement(contentHandler, "enumeration");

                try
                {
                    Map<T, I18nizableText> entries = getEnumerator().getTypedEntries();
                    for (Map.Entry<T, I18nizableText> entry : entries.entrySet())
                    {
                        XMLUtils.startElement(contentHandler, "entry");

                        getType().valueToSAX(contentHandler, "value", entry.getKey(), DataContext.newInstance());
                        entry.getValue().toSAX(contentHandler, "label");

                        XMLUtils.endElement(contentHandler, "entry");
                    }
                }
                catch (Exception e)
                {
                    throw new SAXException("Unable to enumerate entries with enumerator: " + getEnumerator(), e);
                }

                XMLUtils.endElement(contentHandler, "enumeration");
            }
        }
        
        if (getValidator() != null)
        {
            XMLUtils.startElement(contentHandler, "validation");
            
            Map<String, Object> configuration = getValidator().getConfiguration();
            
            for (Map.Entry<String, Object> entry : configuration.entrySet())
            {
                _validatorConfigurationObjectToSAX(contentHandler, entry.getKey(), entry.getValue());
            }
            
            XMLUtils.endElement(contentHandler, "validation");
        }
    }
    
    @SuppressWarnings("unchecked")
    private static void _validatorConfigurationObjectToSAX(ContentHandler handler, String name, Object value) throws SAXException
    {
        if (value instanceof I18nizableText)
        {
            ((I18nizableText) value).toSAX(handler, name);
        }
        else if (value instanceof Collection)
        {
            for (Object item : (Collection) value)
            {
                if (item != null)
                {
                    _validatorConfigurationObjectToSAX(handler, name, item);
                }
            }
        }
        else if (value instanceof Map)
        {
            XMLUtils.startElement(handler, name);
            for (Map.Entry<String, Object> subEntry : ((Map<String, Object>) value).entrySet())
            {
                _validatorConfigurationObjectToSAX(handler, subEntry.getKey(), subEntry.getValue());
            }
            XMLUtils.endElement(handler, name);
        }
        else if (value instanceof Object[])
        {
            for (Object item : (Object[]) value)
            {
                if (item != null)
                {
                    _validatorConfigurationObjectToSAX(handler, name, item);
                }
            }
        }
        else
        {
            XMLUtils.createElement(handler, name, String.valueOf(value));
        }
    }
    
    /**
     * Creates a {@link DefaultElementDefinition}
     * @param name the definition's name
     * @param isMultiple the definition's cardinality
     * @param typeId the definition's type identifier
     * @param availableTypesExtensionPoint the role of the extension point containing all available types for this {@link DefaultElementDefinition}
     * @return the created {@link DefaultElementDefinition}
     * @throws UnknownTypeException if the given type identifier is not available in the extension point
     * @throws BadItemTypeException if the given type identifier can not be used for an {@link ElementDefinition}
     * @throws ServiceException if an error occurs while getting the extension point of available types
     */
    @SuppressWarnings("unchecked")
    public static DefaultElementDefinition of(String name, boolean isMultiple, String typeId, String availableTypesExtensionPoint) throws UnknownTypeException, BadItemTypeException, ServiceException
    {
        ExtensionPoint<ModelItemType> availableTypes = (ExtensionPoint<ModelItemType>) __serviceManager.lookup(availableTypesExtensionPoint);
        if (!availableTypes.hasExtension(typeId))
        {
            throw new UnknownTypeException("The type '" + typeId + "' (used for data '" + name + "') is not available for the given extension point.");
        }
        else
        {
            ModelItemType type = availableTypes.getExtension(typeId);
            if (!(type instanceof ElementType))
            {
                throw new BadItemTypeException("The type '" + typeId + "' (used for data '" + name + "') can not be used for an element definition.");
            }
            else
            {
                return new DefaultElementDefinition(name, isMultiple, (ElementType) type);
            }
        }
    }
}