/*
 *  Copyright 2017 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.core.ui.widgets.richtext;

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

import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

import org.ametys.core.ui.ClientSideElement;
import org.ametys.core.ui.ClientSideElement.ScriptFile;
import org.ametys.plugins.core.ui.util.ConfigurationHelper;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;

/**
 * A configurable implementation of {@link RichTextConfiguration} 
 * 
 * <tags category="cat1">
 *      <tag name="p" empty="CLOSE|OPEN|REMOVE_EMPTY_CONTENT|PADDING|REMOVE_EMPTY_ATTRIBUTES">
 *          <synonyms>
 *              <synonym>div</synonym>
 *          </synonyms>
 *          <attributes>
 *              <attribute name="align">
 *                  <default-value>left</default-value>
 *                  <values>
 *                      <value>left</value>
 *                      <value>right</value>
 *                  </values>
 *              </attribute>
 *              <!-- 'class' is a special attributes with additional possibilities (technical-values) -->
 *              <attribute name="class">
 *                  <default-value>para1</default-value>
 *                  <values>
 *                      <value>para1</value>
 *                      <value technical="true">para2</value>
 *                  </values>
 *              </attribute>
 *          </attributes>    
 *      </tag>
 * </tags>
 * <tags category="">
 *    ...
 * </tags>
 * <styles category="">
 *     <style name="paragraph">
 *         <group>
 *             <values>
 *                 <value rendering="h1.bigger">
 *                     <label i18n="false">Header 1 (bigger)</label>
 *                     <description i18n="false">Creates a bigger header of first level</description>
 *                     <cssclass>bigger-heading-1</cssclass> <!-- class name for backoffice button -->
 *                     <icon-small type='file'>img/h1bigger_16.png</icon-small>
 *                     <icon-medium type='file'>img/h1bigger_32.png</icon-medium>
 *                     <icon-large type='file'>img/h1bigger_48.png</icon-large>
 *                 </tagname>
 *             </values>
 *         </group>
 *     </style>
 * </styles>
 * <css category="">
 *     <file>css/file.css</file>
 * </css>
 * <validators category="">
 *     <validator>
 *         <class name="...">
 *             <config>...</config>
 *         </class>
 *         <scripts>
 *             <file>...>/file>
 *         </scripts>
 *     </validator>
 * </validators>
 * <validators category="">
 *     ...
 * </validators>
 * <convertors category="">
 *    <convertor>
 *         <class name="...">
 *             <config>...</config>
 *         </class>
 *         <scripts>
 *             <file>...>/file>
 *         </scripts>
 *     </convertor>
 * </convertors>
 * <convertors category="">
 *     ...
 * </convertors>
 */
public class StaticRichTextConfiguration extends AbstractLogEnabled implements RichTextConfiguration, Configurable, PluginAware
{
    /** The name of the plugin where thie extension was defined */ 
    protected String _pluginName;
    /** The feature in the plugin where thie extension was defined */ 
    protected String _featureName;
    /** The identifier of this extension */ 
    protected String _id;
    
    /** The handled tags classified by categories */
    protected Map<String, Map<String, RichTextConfigurationTag>> _handledTags;
    /** The css files to load by categories */
    protected Map<String, List<ScriptFile>> _cssFiles;
    /** The validators by categories */
    protected Map<String, Set<ClientSideElement>> _validators;
    /** The convertors by categories */
    protected Map<String, Set<ClientSideElement>> _convertors;
    /** The styles by categories */
    protected Map<String, Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>>> _styles;
    
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _handledTags = new HashMap<>();
        for (Configuration tagsConfiguration : configuration.getChildren("tags"))
        {
            String category = tagsConfiguration.getAttribute("category", "");
            if (_handledTags.containsKey(category))
            {
                throw new ConfigurationException("The tag category " + (StringUtils.isNotBlank(category) ? "'" + category + "'" : "<default>") + " has been defined twice", tagsConfiguration);
            }
            
            _handledTags.put(category, _configureTags(tagsConfiguration));
        }
        
        _cssFiles = new HashMap<>();
        for (Configuration cssConfiguration : configuration.getChildren("css"))
        {
            String category = cssConfiguration.getAttribute("category", "");
            if (_cssFiles.containsKey(category))
            {
                throw new ConfigurationException("The css category " + (StringUtils.isNotBlank(category) ? "'" + category + "'" : "<default>") + " has been defined twice", cssConfiguration);
            }
        
            _cssFiles.put(category, ConfigurationHelper.parsePluginResourceList(cssConfiguration, _pluginName, getLogger()));
        }
        
        _validators = new HashMap<>();
        for (Configuration validatorsConfiguration : configuration.getChildren("validators"))
        {
            String category = validatorsConfiguration.getAttribute("category", "");
            if (_validators.containsKey(category))
            {
                throw new ConfigurationException("The validators category " + (StringUtils.isNotBlank(category) ? "'" + category + "'" : "<default>") + " has been defined twice", validatorsConfiguration);
            }
        
            _validators.put(category, _configureValidators(validatorsConfiguration));
        }

        _convertors = new HashMap<>();
        for (Configuration convertorsConfiguration : configuration.getChildren("convertors"))
        {
            String category = convertorsConfiguration.getAttribute("category", "");
            if (_convertors.containsKey(category))
            {
                throw new ConfigurationException("The convertors category " + (StringUtils.isNotBlank(category) ? "'" + category + "'" : "<default>") + " has been defined twice", convertorsConfiguration);
            }
        
            _convertors.put(category, _configureConvertors(convertorsConfiguration));
        }
        
        _styles = _configureCategoryAndStyles(configuration);
    }

    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
        _featureName = featureName;
        _id = id;
    }
    
    /**
     * Configure the tags
     * @param tagsConfiguration The tags part of the configuration
     * @return The configured tags
     * @throws ConfigurationException If an error occurred
     */
    protected Map<String, RichTextConfigurationTag> _configureTags(Configuration tagsConfiguration) throws ConfigurationException
    {
        Map<String, RichTextConfigurationTag> tags = new HashMap<>();
        
        for (Configuration tagConfiguration : tagsConfiguration.getChildren("tag"))
        {
            RichTextConfigurationTag tag = new StaticRichTextConfigurationTag(tagConfiguration);
            
            if (tags.containsKey(tag.getTag()))
            {
                throw new ConfigurationException("The tag '" + tag.getTag() + "' cannot be defined twice in the same category", tagsConfiguration);
            }
            
            tags.put(tag.getTag(), tag);
        }
        
        return tags;
    }

    /**
     * Configure the validators
     * @param validatorsConfiguration The validators part of the configuration
     * @return The configured validators
     * @throws ConfigurationException If an error occurred
     */
    protected Set<ClientSideElement> _configureValidators(Configuration validatorsConfiguration) throws ConfigurationException
    {
        Set<ClientSideElement> validators = new HashSet<>();
        
        for (Configuration validatorConfiguration : validatorsConfiguration.getChildren("validator"))
        {
            validators.add(new StaticRichTextConfigurationClientSideElement(validatorConfiguration, _pluginName, getLogger()));
        }
        
        return validators;
    }
    
    /**
     * Configure the convertors
     * @param convertorsConfiguration The convertors part of the configuration
     * @return The configured convertors
     * @throws ConfigurationException If an error occurred
     */
    protected Set<ClientSideElement> _configureConvertors(Configuration convertorsConfiguration) throws ConfigurationException
    {
        Set<ClientSideElement> convertors = new HashSet<>();
        
        for (Configuration convertorConfiguration : convertorsConfiguration.getChildren("convertor"))
        {
            convertors.add(new StaticRichTextConfigurationClientSideElement(convertorConfiguration, _pluginName, getLogger()));
        }
        
        return convertors;
    }
    
    /**
     * Configure all the styles for all categories
     * @param configuration The styles configuration
     * @return The configured styles
     * @throws ConfigurationException If an error occurred
     */
    private Map<String, Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>>> _configureCategoryAndStyles(Configuration configuration) throws ConfigurationException
    {
        Map<String, Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>>> allStyles = new HashMap<>();
        for (Configuration stylesConfiguration : configuration.getChildren("styles"))
        {
            String category = stylesConfiguration.getAttribute("category", "");
            if (allStyles.containsKey(category))
            {
                throw new ConfigurationException("The style category " + (StringUtils.isNotBlank(category) ? "'" + category + "'" : "<default>") + " has been defined twice", stylesConfiguration);
            }
        
            allStyles.put(category, _configureStyles(stylesConfiguration));
        }
        return allStyles;
    }
    
    /**
     * Configure the styles for one category
     * @param stylesConfiguration The style configuration of the configuration
     * @return The configured styles
     * @throws ConfigurationException If an error occurred
     */
    protected Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>> _configureStyles(Configuration stylesConfiguration) throws ConfigurationException
    {
        Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>> oneStyles = new HashMap<>();
        
        for (Configuration styleConfiguration : stylesConfiguration.getChildren("style"))
        {
            String key = styleConfiguration.getAttribute("name");
            Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>> groups = new HashMap<>();
            oneStyles.put(key, groups);
            

            for (Configuration groupConfiguration : styleConfiguration.getChildren("group"))
            {
                RichTextConfigurationStyleGroup group = new StaticRichTextConfigurationStyleGroup(groupConfiguration, _pluginName);
                
                List<RichTextConfigurationStyle> values = new ArrayList<>();
                groups.put(group, values);
                
                for (Configuration valueConfiguration : groupConfiguration.getChild("values").getChildren("value"))
                {
                    values.add(new StaticRichTextConfigurationStyle(valueConfiguration, !"paragraph".equals(key), _pluginName, getLogger()));
                }
            }
        }
        
        return oneStyles;
    }
    
    public Set<String> getCategories()
    {
        Set<String> categories = new HashSet<>();
        categories.addAll(_handledTags.keySet());
        categories.addAll(_cssFiles.keySet());
        categories.addAll(_validators.keySet());
        categories.addAll(_convertors.keySet());
        return categories;
    }

    public Collection<RichTextConfigurationTag> getHandledTags(String category, Map<String, Object> contextParameters)
    {
        return _handledTags.get(category).values();
    }

    public List<ScriptFile> getCSSFiles(String category, Map<String, Object> contextParameters)
    {
        return _cssFiles.get(category);
    }

    public Set<ClientSideElement> getValidators(String category, Map<String, Object> contextParameters)
    {
        return _validators.get(category);
    }

    public Set<ClientSideElement> getConvertors(String category, Map<String, Object> contextParameters)
    {
        return _convertors.get(category);
    }
    
    public Map<String, Map<RichTextConfigurationStyleGroup, List<RichTextConfigurationStyle>>> getAvailableStyles(String category, Map<String, Object> contextualParameters)
    {
        return _styles.get(category);
    }

    /**
     * A configured implementation of the {@link RichTextConfigurationTag}
     */
    public static class StaticRichTextConfigurationTag implements RichTextConfigurationTag
    {
        /** The handled tag name */
        protected String _tagName;
        /** The empty behavior */
        protected EMPTY_TAG _emptyTag;
        /** The synonyms */
        protected Set<String> _synonyms;
        /** The handled attributes */
        protected Set<RichTextConfigurationAttribute> _attributes;
        
        /**
         * Create by values
         * @param tagName The tag name. Cannot be null.
         * @param emptyTag The behavior when empty. Can be null to use CLOSE
         * @param synonyms A set of synonyms
         * @param attributes A set of authorized attributes
         */
        public StaticRichTextConfigurationTag(String tagName, EMPTY_TAG emptyTag, Set<String> synonyms, Set<RichTextConfigurationAttribute> attributes)
        {
            _tagName = tagName;
            _emptyTag = emptyTag != null ? emptyTag : EMPTY_TAG.CLOSE;
            _synonyms = synonyms != null ? synonyms : Collections.EMPTY_SET;
            _attributes = attributes != null ? attributes : Collections.EMPTY_SET;
        }
        
        /**
         * Create by configuration
         * @param configuration The tag configuration
         * @throws ConfigurationException If an error occurred
         */
        protected StaticRichTextConfigurationTag(Configuration configuration) throws ConfigurationException
        {
            _tagName = configuration.getAttribute("name");
            
            try
            {
                _emptyTag = EMPTY_TAG.valueOf(configuration.getAttribute("empty", "CLOSE"));
            }
            catch (IllegalArgumentException e)
            {
                throw new ConfigurationException("The attribute empty does not accept the value '" + configuration.getAttribute("empty", "CLOSE") + "'. Should be one of <" + StringUtils.join(EMPTY_TAG.values(), "|") + ">", configuration, e);
            }
            
            _synonyms = new HashSet<>();
            for (Configuration synonymConfiguration : configuration.getChild("synonyms").getChildren("synonym"))
            {
                _synonyms.add(synonymConfiguration.getValue());
            }
            
            _attributes = new HashSet<>();
            for (Configuration attributeConfiguration : configuration.getChild("attributes").getChildren("attribute"))
            {
                RichTextConfigurationAttribute attribute = new StaticRichTextConfigurationAttribute(attributeConfiguration);
                _attributes.add(attribute);
            }
        }

        public String getTag()
        {
            return _tagName;
        }

        public EMPTY_TAG onEmptyTag()
        {
            return _emptyTag;
        }

        public Set<String> getSynonyms()
        {
            return _synonyms;
        }

        public Set<RichTextConfigurationAttribute> getAttributes()
        {
            return _attributes;
        }
    }
    
    /**
     * A configured implementation of the {@link StaticRichTextConfigurationAttribute}
     */
    public static class StaticRichTextConfigurationAttribute implements RichTextConfigurationAttribute
    {
        /** The name of the attribute */
        protected String _name;
        /** The default value */
        protected String _defaultValue;
        /** The possible values */
        protected Set<String> _authorizedValues;
        /** The technical values */
        protected Set<String> _technicalValues;

        /**
         * Create by values
         * @param name The attribute name. Cannot be null.
         * @param defaultValue The default value. Can be null
         * @param authorizedValues A non-null set of authorized values. Must contains the default value.
         * @param technicalValues  A non-null set of technical values. Must contains the default value.
         */
        public StaticRichTextConfigurationAttribute(String name, String defaultValue, Set<String> authorizedValues, Set<String> technicalValues)
        {
            _name = name;
            _defaultValue = defaultValue;
            _authorizedValues = authorizedValues != null ? authorizedValues : Collections.EMPTY_SET;
            _technicalValues = technicalValues != null ? technicalValues : Collections.EMPTY_SET;
        }
        
        /**
         * Create by configuration
         * @param configuration The tag configuration
         * @throws ConfigurationException If an error occurred
         */
        protected StaticRichTextConfigurationAttribute(Configuration configuration) throws ConfigurationException
        {
            _name = configuration.getAttribute("name");
            
            _defaultValue = configuration.getChild("default-value").getValue(null);
            
            _authorizedValues = new HashSet<>();
            _technicalValues = new HashSet<>();
            if (_defaultValue != null)
            {
                _authorizedValues.add(_defaultValue);
            }
            for (Configuration valueConfiguration : configuration.getChild("values").getChildren("value"))
            {
                if ("true".equals(valueConfiguration.getAttribute("technical", "false")))
                {
                    _technicalValues.add(valueConfiguration.getValue());
                }
                _authorizedValues.add(valueConfiguration.getValue());
            }
        }
        
        public String getName()
        {
            return _name;
        }
        
        public String getDefaultValue()
        {
            return _defaultValue;
        }

        public Set<String> getAuthorizedValues()
        {
            return _authorizedValues;
        }
        
        public Set<String> getTechnicalValues()
        {
            return _technicalValues;
        }
    }

    /**
     * A configured implementation of the {@link ClientSideElement}
     */
    protected static class StaticRichTextConfigurationClientSideElement implements ClientSideElement
    {
        /** The identifier */
        protected String _id;
        /** The plugin name */
        protected String _pluginName;
        /** The script */
        protected Script _script;
        
        /**
         * Create by configuration
         * @param configuration The tag configuration
         * @param pluginName The name of the plugin where it was declared
         * @param logger The logger
         * @throws ConfigurationException If an error occurred
         */
        protected StaticRichTextConfigurationClientSideElement(Configuration configuration, String pluginName, Logger logger) throws ConfigurationException
        {
            _id = org.ametys.core.util.StringUtils.generateKey();
            _pluginName = pluginName;
            
            Configuration classConfiguration = configuration.getChild("class");
            List<ScriptFile> scriptsImports = ConfigurationHelper.parsePluginResourceList(configuration.getChild("scripts"), getPluginName(), logger);
            List<ScriptFile> cssImports = ConfigurationHelper.parsePluginResourceList(configuration.getChild("css"), getPluginName(), logger);
            Map<String, Object> parameters = ConfigurationHelper.parsePluginParameters(configuration.getChild("class"), getPluginName(), logger);
            
            _script = new Script(_id, classConfiguration.getAttribute("name"), scriptsImports, cssImports, parameters);
        }

        public String getId()
        {
            return _id;
        }

        public List<Script> getScripts(Map<String, Object> contextParameters)
        {
            return getScripts(false, contextParameters);
        }

        public List<Script> getScripts(boolean ignoreRights, Map<String, Object> contextParameters)
        {
            return Collections.singletonList(_script);
        }

        public Map<String, String> getRights(Map<String, Object> contextParameters)
        {
            return Collections.EMPTY_MAP;
        }

        public String getPluginName()
        {
            return _pluginName;
        }

        public Map<String, List<String>> getDependencies()
        {
            return Collections.EMPTY_MAP;
        }
    }
    
    /**
     * A configured implementation of {@link RichTextConfigurationStyleGroup}
     */
    public static class StaticRichTextConfigurationStyleGroup implements RichTextConfigurationStyleGroup
    {
        /** The label */
        protected I18nizableText _label;
        /** The priority */
        protected int _priority;

        /**
         * Created by configuration
         * @param configuration The group configuration
         * @param pluginName The name of the plugin where it was declared
         * @throws ConfigurationException If an error occurred
         */
        protected StaticRichTextConfigurationStyleGroup(Configuration configuration, String pluginName) throws ConfigurationException
        {
            Configuration labelConfiguration = configuration.getChild("label");
            _label = I18nizableText.getI18nizableTextValue(labelConfiguration, "plugin." + pluginName, labelConfiguration.getValue());
            _priority = configuration.getChild("priority").getValueAsInteger(0);
        }
        
        /**
         * Created by calues
         * @param label The label
         * @param priority The priority
         */
        public StaticRichTextConfigurationStyleGroup(I18nizableText label, int priority)
        {
            _label = label;
            _priority = priority;
        }
        
        public I18nizableText getLabel()
        {
            return _label;
        }

        public int getPriority()
        {
            return _priority;
        }
    }
    
    /**
     * A configured implementation of {@link RichTextConfigurationStyle}
     */
    public static class StaticRichTextConfigurationStyle implements RichTextConfigurationStyle
    {
        /** The tag name */
        protected String _tagName;
        /** The editor css class name */
        protected String _className;
        
        /** The label */
        protected I18nizableText _label;
        /** The description */
        protected I18nizableText _description;
        /** The backoffice css class */
        protected String _buttonCSSClass;
        /** The icon for the button in small */
        protected String _buttonSmallIcon;
        /** The icon for the button in small */
        protected String _buttonMediumIcon;
        /** The icon for the button in small */
        protected String _buttonLargeIcon;
        
        /**
         * Create by configuration
         * @param configuration The tag configuration
         * @param isRenderingOnlyAClass In configuration rendering attribute can be only a class or a tag with an option ".class"
         * @param pluginName The name of the plugin where it was declared
         * @param logger The logger
         * @throws ConfigurationException If an error occurred
         */
        protected StaticRichTextConfigurationStyle(Configuration configuration, boolean isRenderingOnlyAClass, String pluginName, Logger logger) throws ConfigurationException
        {
            if (isRenderingOnlyAClass)
            {
                _className = configuration.getAttribute("rendering");
            }
            else
            {
                _tagName = configuration.getAttribute("rendering");
                int dotPosition = _tagName.indexOf('.');
                if (_tagName.contains("."))
                {
                    _className = _tagName.substring(dotPosition + 1);
                    _tagName = _tagName.substring(0, dotPosition);
                }
            }
            
            Map<String, Object> parsePluginParameters = ConfigurationHelper.parsePluginParameters(configuration, pluginName, logger);
            _label = (I18nizableText) parsePluginParameters.get("label");
            _description = (I18nizableText) parsePluginParameters.get("description");
            _buttonCSSClass = (String) parsePluginParameters.get("cssclass");
            _buttonSmallIcon = (String) parsePluginParameters.get("icon-small");
            _buttonMediumIcon = (String) parsePluginParameters.get("icon-medium");
            _buttonLargeIcon = (String) parsePluginParameters.get("icon-large");
        }

        /**
         * Creates by values
         * @param tagNameAndClassName The rendering for inline editor such as h1.big
         * @param label The label for the button
         * @param description The description for the button
         * @param buttonCSSClass The css for the button
         * @param buttonSmallIcon The small icon for the button
         * @param buttonMediumIcon The medium icon for the button
         * @param buttonLargeIcon The large icon for the button
         * @param isRenderingOnlyAClass In configuration rendering attribute can be only a class or a tag with an option ".class"
         */
        public StaticRichTextConfigurationStyle(String tagNameAndClassName, I18nizableText label, I18nizableText description, String buttonCSSClass, String buttonSmallIcon, String buttonMediumIcon, String buttonLargeIcon, boolean isRenderingOnlyAClass)
        {
            if (isRenderingOnlyAClass)
            {
                _className = tagNameAndClassName;
            }
            else
            {
                _tagName = tagNameAndClassName;
                int dotPosition = _tagName.indexOf('.');
                if (_tagName.contains("."))
                {
                    _className = _tagName.substring(dotPosition + 1);
                    _tagName = _tagName.substring(0, dotPosition);
                }
            }
            
            
            _label = label;
            _description = description;
            _buttonCSSClass = buttonCSSClass;
            _buttonSmallIcon = buttonSmallIcon;
            _buttonMediumIcon = buttonMediumIcon;
            _buttonLargeIcon = buttonLargeIcon;
        }

        public String getTagName()
        {
            return _tagName;
        }

        public String getClassName()
        {
            return _className;
        }

        public I18nizableText getButtonLabel()
        {
            return _label;
        }

        public I18nizableText getButtonDescription()
        {
            return _description;
        }

        public String getButtonCSSClass()
        {
            return _buttonCSSClass;
        }

        public String getButtonSmallIcon()
        {
            return _buttonSmallIcon;
        }

        public String getButtonMediumIcon()
        {
            return _buttonMediumIcon;
        }

        public String getButtonLargeIcon()
        {
            return _buttonLargeIcon;
        }
    }
}