/*
 *  Copyright 2010 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.cms.clientsideelement;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfiguration;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.collections.ListUtils;
import org.slf4j.LoggerFactory;

import org.ametys.cms.content.ContentHelper;
import org.ametys.core.ui.ClientSideElement;
import org.ametys.core.ui.MenuClientSideElement;
import org.ametys.core.ui.StaticClientSideElement;
import org.ametys.core.ui.StaticFileImportsClientSideElement;
import org.ametys.core.user.UserManager;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.StringUtils;
import org.ametys.plugins.core.ui.util.ConfigurationHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.workflow.support.WorkflowHelper;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.plugin.component.ThreadSafeComponentManager;

import com.opensymphony.workflow.loader.ActionDescriptor;
import com.opensymphony.workflow.loader.StepDescriptor;
import com.opensymphony.workflow.loader.WorkflowDescriptor;

/**
 * This element creates multiple toggle buttons representing a workflow.
 * A menu represent workflow actions.
 * 
 * The awaited configuration is:
 *          <workflow name="WORKFLOWNAME">
 *              <action>
 *                  <menu-1-label>I18N_KEY</menu-1-label>
 *              </action>
 * 
 *              <workflow-actions mode="exclude">
 *                  <action>22</action>
 *                  <action>222</action>
 *              </workflow-actions>
 * 
 *              <workflow-steps mode="include">
 *                  <step>1</step>
 *                  <step>2</step>
 *              </workflow-steps>
 * 
 *              <steps>
 *                  <step id="1">
 *                      <workflow-actions mode="include">
 *                          <action>2</action>
 *                      </workflow-actions>
 * 
 *                      <comments mode="include">
 *                          <action>3</action>
 *                      </comments>
 * 
 *                      <action>
 *                          <menu-1-label />
 *                      </action>
 *                  </step>
 * 
 *              </steps>
 *          </workflow>
 * 
 * Where WORKFLOWNAME is the name of the workflow such as 'content'. MANDATORY
 * Where <action> is optional to override the default configuration of every step button and step menu
 *  The attribute name="..." is optional to specify the JS class used.
 * Where <workflow-actions< is optional to restrict the available actions in the menu. Default value is <workflow-actions mode="exclude"/>
 *  The attribute mode="include" indicates that the list of actions ids will replace the one automatically determined (even if it only can by a sublist). Listing ids here ensure that no new actions will appear in this menu if the workflow is modified.
 *  The attribute mode="exclude" (default value) indicates that the list of actions ids will be removed from the one automatically determined (it only can by a sublist of it). Listing ids here ensure that when the workflow has a new action it will be added here.
 * Where <steps> is optional and allows you to configure each step specifically.
 *  The <step> id attribute is MANDATORY
 *  The <workflow-actions> is identical to the one at the root of <workflow> but only for this specific step
 *  Where <comments< is identical to <workflow-actions< but to display to the user a dialog box to enter comments. The workflow has to support comments on that action. To avoid comments, set <comments mode="include"/>
 *  The <action> is identical to the one at the root of <workflow> but only for this specific step
 * 
 * 
 * Here is a declaration sample in a plugin.xml file
 * 
 *          <extension id="org.ametys.cms.workflow.WorkflowSteps"
 *                     point="org.ametys.core.ui.RibbonControlsManager"
 *                     class="org.ametys.cms.clientsideelement.WorkflowStepsClientSideElement">
 *              <workflow name="content">
 *                  <steps>
 *                      <step id="1"> <!-- Draft -->
 *                          <workflow-actions mode="exclude">
 *                              <action>2</action><!-- Edit -->
 *                          </workflow-actions>
 * 
 *                          <comments mode="include">
 *                              <action>3</action><!-- propose -->
 *                          </comments>
 *                      </step>
 *                  </steps>
 *              </workflow>
 *          </extension>
 *
 * Default configuration is proposed upon the StaticFileImportsClientSideElement.
 * - default js class is "Ametys.plugins.cms.content.controller.WorkflowMenu"
 * - default js files are loaded : /plugins/cms/resources/js/Ametys/plugins/cms/content/controller/WorkflowMenu.js and /plugins/cms/resources/js/Ametys/plugins/cms/content/actions/WorkflowAction.js
 * - default js parameters are
 *      - label (to the i18nkey application:WORFKLOW_STEP_NAME)
 *      - description (to the i18nkey application:WORFKLOW_STEP_NAME_DESCRIPTION)
 *      - footerDescription (to the i18nkey application:WORFKLOW_STEP_NAME_FOOTER)
 *      - selection-target-id (to ^content$)
 *      - icon-small, icon-medium, icon-large (to /plugins/cms/resources_workflow/WORFKLOW_STEP_NAME-small.png for an application i18nkey, or /plugins/PLUGINNAME/resources/img/workflow/WORFKLOW_STEP_NAME-small.png for a plugin i18nkey)
 *      - workflow-step (tp the value configured avove)
 *      - workflow-name (to the value configured above)
 *      - selection-enable-multiselection (true)
 *      - selection-description-empty : i18nkey plugin.cms:CONTENT_WORKFLOW_NOSELECTION_DESCRIPTION
 *      - selection-description-nomatch : i18nkey plugin.cms:CONTENT_WORKFLOW_NOMATCH_DESCRIPTION
 *      - selection-description-multiselectionforbidden : i18nkey plugin.cms:CONTENT_WORKFLOW_NOMULTISELECT_DESCRIPTION
 * - additionnal js parameters are
 *      - noaction-available-description : i18nkey for description when no actions are available, plugin.cms:CONTENT_WORKFLOW_NOACTIONAVAILABLE_DESCRIPTION
 *      - refreshing-description : i18nkey for description when refreshing, plugin.cms:CONTENT_WORKFLOW_REFRESH_DESCRIPTION
 *      - contentselected-start-description : i18nkey for description of the current content selection (start of the description) : plugin.cms:CONTENT_WORKFLOW_DESCRIPTION_BEGIN
 *      - contentselected-end-description : i18nkey for description of the current content selection (end of the description) : plugin.cms:CONTENT_WORKFLOW_DESCRIPTION_END
 *      - editing-description : i18nkey for description when the content is beeing edited : plugin.cms:CONTENT_WORKFLOW_EDITING_DESCRIPTION
 * So there is no need to define a <class> by default or import js files.
 * Additionnal i18nkeys used are plugin.cms:CONTENT_WORKFLOW_DESCRIPTION and plugin.cms:CONTENT_WORKFLOW_LOCKED_DESCRIPTION
 */
public class WorkflowStepsClientSideElement extends StaticFileImportsClientSideElement implements MenuClientSideElement
{
    /** The client side element component manager for menu items. */
    protected ThreadSafeComponentManager<ClientSideElement> _menuItemManager;
    /** The service manager */
    protected ServiceManager _smanager;
    /** Runtime users manager */
    protected UserManager _userManager;
    /** Workflow provider */
    protected WorkflowProvider _workflowProvider;
    /** Workflow helper */
    protected WorkflowHelper _workflowHelper;
    /** Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    /** The content helper */
    protected ContentHelper _contentHelper;
    /** The referenced client side element */
    protected List<ClientSideElement> _referencedClientSideElement;
    /** The menu items */
    protected Map<String, List<ClientSideElement>> _menuItems;
    /** The unresolved items */
    protected Map<String, List<String>> _unresolvedMenuItems;
    /** The scripts */
    protected List<Script> _scripts;
    /** The i18n utils */
    protected I18nUtils _i18nUtils;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _smanager = manager;
        _userManager = (UserManager) manager.lookup(UserManager.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _workflowHelper = (WorkflowHelper) manager.lookup(WorkflowHelper.ROLE);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _contentHelper = (ContentHelper) manager.lookup(ContentHelper.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
    }
    
    @Override
    public void configure(Configuration configuration) throws ConfigurationException
    {
        _menuItemManager = new ThreadSafeComponentManager<>();
        _menuItemManager.setLogger(LoggerFactory.getLogger("cms.plugin.threadsafecomponent"));
        _menuItemManager.service(_smanager);

        // Menu items
        _referencedClientSideElement = new ArrayList<>();
        _unresolvedMenuItems = new HashMap<>();
        _menuItems = new HashMap<>();
        
        super.configure(configuration);
        
        _configureWorkflow(configuration);
    }
    
    /**
     * Read the workflow configuration, to set up the scripts.
     * @param configuration The configuration
     * @throws ConfigurationException If an error occurs
     */
    protected void _configureWorkflow(Configuration configuration) throws ConfigurationException
    {
        Configuration workflowConfiguration = configuration.getChild("workflow", false);
        if (workflowConfiguration != null)
        {
            String workflowName = workflowConfiguration.getAttribute("name");
            
            Configuration actionsConfiguration = workflowConfiguration.getChild("workflow-actions", true);
            List<Integer> actions = new ArrayList<>();
            boolean actionsIncludeMode = "include".equals(actionsConfiguration.getAttribute("mode", "exclude"));
            for (Configuration action : actionsConfiguration.getChildren("action"))
            {
                actions.add(action.getValueAsInteger());
            }
            
            Configuration stepsConfiguration = workflowConfiguration.getChild("workflow-steps", true);
            List<Integer> steps = new ArrayList<>();
            boolean stepsIncludeMode = "include".equals(stepsConfiguration.getAttribute("mode", "exclude"));
            for (Configuration action : stepsConfiguration.getChildren("step"))
            {
                steps.add(action.getValueAsInteger());
            }
            
            Map<Integer, Configuration> specificStepConfig = new HashMap<>();
            for (Configuration stepConfiguration : workflowConfiguration.getChild("steps", true).getChildren("step"))
            {
                Integer id = stepConfiguration.getAttributeAsInteger("id");
                specificStepConfig.put(id, stepConfiguration);
            }
            
            WorkflowDescriptor workflowDescriptor = _workflowHelper.getWorkflowDescriptor(workflowName);
            
            if (workflowDescriptor == null)
            {
                throw new ConfigurationException("Unknown workflow name '" + workflowName + "' specified in configuration", workflowConfiguration);
            }
            
            List<Integer> allowedStepIds = _getAllowedSteps(workflowDescriptor, stepsIncludeMode, steps);
            List<Integer> allowedActionIds = _getAllowedActions(workflowDescriptor, allowedStepIds, actionsIncludeMode, actions);
            
            _configureScripts(workflowConfiguration, allowedStepIds, specificStepConfig, allowedActionIds, workflowDescriptor);
        }
    }

    /**
     * Get the steps allowed for the current workflow
     * @param workflowDescriptor The workflow descriptor
     * @param stepsIncludeMode True if the step listed should be the only steps included, false if they should be excluded from all available workflow's steps.
     * @param configuredSteps A list of step ids.
     * @return The steps allowed.
     */
    protected List<Integer> _getAllowedSteps(WorkflowDescriptor workflowDescriptor, boolean stepsIncludeMode, List<Integer> configuredSteps)
    {
        List<Integer> workflowStepIds = workflowDescriptor.getSteps().stream()
                                                                     .mapToInt(step -> ((StepDescriptor) step).getId())
                                                                     .boxed()
                                                                     .collect(Collectors.toList());

        if (stepsIncludeMode)
        {
            List<Integer> stepsToRemove = new ArrayList<>();
            for (Integer stepId : configuredSteps)
            {
                if (!workflowStepIds.contains(stepId))
                {
                    getLogger().warn("Unknown step id '" + stepId + "' for workflow '" + workflowDescriptor.getName() + "', in workflow-steps configuration of extension '" + this.getId() + "', it will be ignored");
                    stepsToRemove.add(stepId);
                }
            }
            configuredSteps.removeAll(stepsToRemove);
            
            return configuredSteps;
        }
        else
        {
            List<Integer> unknownStepIds = new ArrayList<>(configuredSteps);
            unknownStepIds.removeAll(workflowStepIds);
            for (Integer stepId : unknownStepIds)
            {
                getLogger().warn("Unknown step id '" + stepId + "' for workflow '" + workflowDescriptor.getName() + "', in workflow-steps configuration of extension '" + this.getId() + "', it will be ignored");
            }
            
            workflowStepIds.removeAll(configuredSteps);
            return workflowStepIds;
        }
    }

    /**
     * Get the actions allowed for the current workflow and only for the specified steps.
     * @param workflowDescriptor The workflow descriptor
     * @param stepIds The list of steps specified
     * @param actionsIncludeMode True if the action listed should be the only actions included, false if they should be excluded from all available workflow's actions.
     * @param configuredActions A list of actions ids.
     * @return The actions allowed.
     */
    @SuppressWarnings("unchecked")
    protected List<Integer> _getAllowedActions(WorkflowDescriptor workflowDescriptor, List<Integer> stepIds, boolean actionsIncludeMode, List<Integer> configuredActions)
    {
        if (actionsIncludeMode)
        {
            return configuredActions;
        }
        else
        {
            // get the list of action ids for the allowed steps.
            List<Integer> workflowActionIds = stepIds.stream()
                                                     .map(stepId -> workflowDescriptor.getStep(stepId).getActions())
                                                     .flatMap(actionsLists -> ((List<ActionDescriptor>) actionsLists).stream())
                                                     .distinct()
                                                     .mapToInt(ActionDescriptor::getId)
                                                     .boxed()
                                                     .collect(Collectors.toList());
            
            workflowActionIds.removeAll(configuredActions);
            return workflowActionIds;
        }
    }
    
    /**
     * Configure the list of Scripts, for each step available to the workflow.
     * @param workflowConfiguration The configuration
     * @param stepIds The list of steps
     * @param stepsConfiguration The parameters for each step
     * @param allowedActionIds The list of globally allowed actions for this workflow
     * @param workflowDescriptor The descriptor for the current workflow
     * @throws ConfigurationException If an error occurs
     */
    protected void _configureScripts(Configuration workflowConfiguration, List<Integer> stepIds, Map<Integer, Configuration> stepsConfiguration, List<Integer> allowedActionIds, WorkflowDescriptor workflowDescriptor) throws ConfigurationException
    {
        _scripts = new ArrayList<>();
        
        Map<String, Object> defaultParameters = null;
        String defaultClassName = "";
        
        Configuration actionConfiguration = workflowConfiguration.getChild("action", true);
        defaultClassName = actionConfiguration.getAttribute("name", _getDefaultMenuClassName());
        defaultParameters = ConfigurationHelper.parsePluginParameters(actionConfiguration, getPluginName(), getLogger());
        
        for (Integer stepId : stepIds)
        {
            Map<String, Object> parameters;
            String className;
            
            Configuration stepConfiguration = null;
            
            if (stepsConfiguration.containsKey(stepId))
            {
                stepConfiguration = stepsConfiguration.get(stepId);
                parameters = ConfigurationHelper.parsePluginParameters(stepConfiguration, getPluginName(), getLogger());
                className = stepConfiguration.getAttribute("name", defaultClassName);
            }
            else
            {
                parameters = new HashMap<>();
                parameters.putAll(defaultParameters);
                className = defaultClassName;
            }

            _configureWorkflowStep(workflowDescriptor, stepId, parameters, stepConfiguration, allowedActionIds);
            _configureParameters(parameters);
            
            List<ScriptFile> scriptFiles = new ArrayList<>(_script.getScriptFiles());
            List<ScriptFile> cssFiles = new ArrayList<>(_script.getCSSFiles());
            Script script = new Script(this.getId() + "-" + stepId, this.getId(), className, scriptFiles, cssFiles, parameters);
            
            _scripts.add(script);
            
            if (stepConfiguration != null && stepConfiguration.getChild("action", false) != null)
            {
                _configureMenuItems(script, stepConfiguration.getChild("action", false));
            }
            else
            {
                _configureMenuItems(script, actionConfiguration);
            }
        }
    }
    
    /**
     * Get the default class name for workflow menu
     * @return the default class name
     */
    protected String _getDefaultMenuClassName()
    {
        return "Ametys.plugins.cms.content.controller.WorkflowMenu";
    }
    
    /**
     * Get the default class name for workflow action
     * @return the default class name
     */
    protected String _getDefaultActionClassName()
    {
        return "Ametys.plugins.cms.content.actions.WorkflowAction.doAction";
    }

    /**
     * Configure the parameters specific to the workflow, for the given step
     * @param workflowDescriptor The descriptor of the workflow
     * @param stepId The step
     * @param stepParameters The parameters of the step
     * @param stepConfiguration The step configuration
     * @param allowedActionIds The list of globally allowed actions
     * @throws ConfigurationException If an error occurs
     */
    protected void _configureWorkflowStep(WorkflowDescriptor workflowDescriptor, Integer stepId, Map<String, Object> stepParameters, Configuration stepConfiguration, List<Integer> allowedActionIds) throws ConfigurationException
    {
        stepParameters.put("workflow-name", workflowDescriptor.getName());
        stepParameters.put("workflow-step", stepId);
        stepParameters.put("workflow-step-name", _workflowHelper.getStepName(workflowDescriptor.getName(), stepId));
        
        List<Integer> currentStepActions = workflowDescriptor.getStep(stepId)
                                                             .getActions()
                                                             .stream()
                                                             .mapToInt(action -> ((ActionDescriptor) action).getId())
                                                             .boxed()
                                                             .collect(Collectors.toList());
        List<Integer> allowedStepActions = ListUtils.intersection(currentStepActions, allowedActionIds);

        List<Integer> stepActions = new ArrayList<>();
        List<Integer> commentIds = new ArrayList<>();
        
        if (stepConfiguration != null)
        {
            Configuration stepWorkflowActions = stepConfiguration.getChild("workflow-actions", false);
            if (stepWorkflowActions != null)
            {
                stepActions.addAll(_configureWorkflowStepActions(workflowDescriptor.getName(), stepId, currentStepActions, allowedStepActions, stepWorkflowActions));
            }
            else
            {
                stepActions.addAll(allowedStepActions);
            }
            
            Configuration stepWorkflowComments = stepConfiguration.getChild("comments", false);
            if (stepWorkflowComments != null)
            {
                commentIds.addAll(_configureWorkflowStepActions(workflowDescriptor.getName(), stepId, currentStepActions, allowedStepActions, stepWorkflowComments));
            }
            else
            {
                commentIds.addAll(allowedStepActions);
            }
        }
        else
        {
            stepActions.addAll(allowedStepActions);
            commentIds.addAll(allowedStepActions);
        }
        
        stepParameters.put("workflow-actions-ids", stepActions);
        stepParameters.put("workflow-comments-ids", commentIds);
    }

    /**
     * Get the list of actions available for a step, from the configuration
     * @param workflowName The name of the current workflow
     * @param stepId The step
     * @param currentStepActions All the actions available for this step
     * @param allowedStepActions The actions allowed by the configuration for this step
     * @param stepActionsConfiguration The configuration for the step actions
     * @return The list of actions for the step
     * @throws ConfigurationException If an error occurs
     */
    protected List<Integer> _configureWorkflowStepActions(String workflowName, Integer stepId, List<Integer> currentStepActions, List<Integer> allowedStepActions, Configuration stepActionsConfiguration) throws ConfigurationException
    {
        List<Integer> stepActions = new ArrayList<>();
        
        boolean actionsIncludeMode = "include".equals(stepActionsConfiguration.getAttribute("mode", "exclude"));
        if (actionsIncludeMode)
        {
            // include mode, add all listed action if they are available for the current step.
            for (Configuration workflowAction : stepActionsConfiguration.getChildren("action"))
            {
                int action = workflowAction.getValueAsInteger();
                if (currentStepActions.contains(action))
                {
                    stepActions.add(action);
                }
                else
                {
                    getLogger().warn("Unknown action id '" + action + "' for step '" + stepId + "', for workflow '"
                            + workflowName + "', in steps configuration of extension '" + this.getId() + "', it will be ignored");
                }
            }
        }
        else
        {
            // exclude mode, add all allowed step actions but the ones listed
            stepActions.addAll(allowedStepActions);
            for (Configuration workflowAction : stepActionsConfiguration.getChildren("action"))
            {
                Integer action = workflowAction.getValueAsInteger();
                if (allowedStepActions.contains(action))
                {
                    stepActions.remove(action);
                }
                else
                {
                    getLogger().warn("Unknown action id '" + action + "' for step '" + stepId + "', for workflow '"
                            + workflowName + "', in steps configuration of extension '" + this.getId() + "', it will be ignored");
                }
            }
        }
        
        return stepActions;
    }

    @Override
    public List<ClientSideElement> getReferencedClientSideElements(Map<String, Object> contextParameters)
    {
        if (hasRight(getRights(contextParameters)))
        {
            return _referencedClientSideElement;
        }
        else
        {
            return List.of();
        }
    }
    
    @Override
    public List<Script> getScripts(boolean ignoreRights, Map<String, Object> contextParameters)
    {
        try
        {
            _resolveMenuItems();
        }
        catch (Exception e)
        {
            throw new IllegalStateException("Unable to lookup client side element local components", e);
        }
        
        
        List<Script> newScripts = new ArrayList<>();
        for (Script script : _scripts)
        {
            Script newScript = new Script(script);
            Map<String, Object> parameters = newScript.getParameters();
            
            for (String key : parameters.keySet())
            {
                Object value = parameters.get(key);
                if (value instanceof I18nizableText)
                {
                    parameters.put(key, StringUtils.escapeHTML(_i18nUtils.translate((I18nizableText) value)));
                }
            }
            
            if (_menuItems.containsKey(script.getId()))
            {
                List<String> menuItems = new ArrayList<>();
                for (ClientSideElement element : _menuItems.get(script.getId()))
                {
                    menuItems.add(element.getId());
                }
                parameters.put("menu-items", menuItems);
            }

            newScripts.add(newScript);
        }
        return newScripts;
    }
    
    @Override
    protected Script _configureScript(Configuration configuration) throws ConfigurationException
    {
        Script script = super._configureScript(configuration);
        List<ScriptFile> scriptFiles = new ArrayList<>();
        scriptFiles.add(new ScriptFile("/plugins/cms/resources/js/Ametys/plugins/cms/content/controller/WorkflowMenu.js"));
        scriptFiles.add(new ScriptFile("/plugins/cms/resources/js/Ametys/plugins/cms/content/actions/WorkflowAction.js"));
        script.getScriptFiles().addAll(scriptFiles);

        return script;
    }

    /**
     * Configure parameters recursively
     * @param parameters The parameters map to fill
     * @throws ConfigurationException The configuration is incorrect
     */
    protected void _configureParameters(Map<String, Object> parameters) throws ConfigurationException
    {
        String workflowStepName = (String) parameters.get("workflow-step-name");
        
        // Default label
        if (parameters.get("label") == null)
        {
            parameters.put("label", new I18nizableText("application", workflowStepName));
        }
        
        // Default description
        if (parameters.get("description") == null)
        {
            parameters.put("description", new I18nizableText("application", workflowStepName + "_DESCRIPTION"));
        }
        
        // Default footer description
        if (parameters.get("footerDescription") == null)
        {
            parameters.put("footerDescription", new I18nizableText("application", workflowStepName + "_FOOTER"));
        }
        
        // Selection target type
        if (parameters.get("selection-target-id") == null)
        {
            parameters.put("selection-target-id", _getSelectionTargetId());
            // DO NOT add selection-target-parameter with workflow name : the button is show/hide according the workflow name on client side
        }
        
        // Default icons
        String[] icons = new String[]{"-small", "-medium", "-large"};
        for (String icon : icons)
        {
            if (parameters.get("icon" + icon) == null)
            {
                I18nizableText workflowStepNameText = new I18nizableText("application", workflowStepName);
                if ("application".equals(workflowStepNameText.getCatalogue()))
                {
                    parameters.put("icon" + icon, new I18nizableText("/plugins/" + _getDefaultPluginName() + "/resources_workflow/" + workflowStepNameText.getKey() + icon + ".png"));
                }
                else
                {
                    String pluginName = workflowStepNameText.getCatalogue().substring("plugin.".length());
                    parameters.put("icon" + icon, new I18nizableText("/plugins/" + pluginName + "/resources/img/workflow/" + workflowStepNameText.getKey() + icon + ".png"));
                }
            }
        }
        
        // Multiselection enabled
        if (!parameters.containsKey("selection-enable-multiselection"))
        {
            parameters.put("selection-enable-multiselection", true);
        }
        
        _configureDefaultDescriptions(parameters);
    }
    
    /**
     * Get the default plugin name
     * @return the default plugin name
     */
    protected String _getDefaultPluginName()
    {
        return "cms";
    }
    
    /**
     * Get the selection target id (can be a Regexp)
     * @return the selection target id
     */
    protected String _getSelectionTargetId()
    {
        return "^content$";
    }
    
    /**
     * Configure the menu items
     * @param script The parameters map to fill
     * @param configuration The items configuration
     */
    @SuppressWarnings("unchecked")
    protected void _configureMenuItems(Script script, Configuration configuration)
    {
        Map<String, Object> parameters = script.getParameters();
        for (int actionId : (List<Integer>) parameters.get("workflow-actions-ids"))
        {
            String id = script.getId() + ".workflow-action-" + actionId;
            
            String actionName = _workflowHelper.getActionName((String) parameters.get("workflow-name"), actionId);
            
            DefaultConfiguration conf = new DefaultConfiguration("extension");
            conf.setAttribute("id", id);
            
            DefaultConfiguration classConf = new DefaultConfiguration("class");
            classConf.setAttribute("name", "Ametys.ribbon.element.ui.ButtonController");
            
            // Label
            _addActionLabelConfiguration(configuration, classConf, actionId, actionName);
            
            // Description
            _addActionDescriptionConfiguration(configuration, classConf, actionId, actionName);
            
            // Workflow action id
            DefaultConfiguration wActionConf = new DefaultConfiguration("workflow-action-id");
            wActionConf.setValue(actionId);
            classConf.addChild(wActionConf);
            
            // Action
            DefaultConfiguration actionConf = new DefaultConfiguration("action");
            actionConf.setValue(configuration.getChild("menu-" + actionId + "-action").getValue(_getDefaultActionClassName()));
            classConf.addChild(actionConf);
            
            // Comment
            _addActionCommentConfiguration(configuration, classConf, actionId, actionName, parameters);
            
            _additionalMenuItemConfiguration(configuration, classConf, actionId, parameters);
            
            conf.addChild(classConf);
            
            _menuItemManager.addComponent(_pluginName, null, id, EscapeHTMLI18nizableTextClientSideElement.class, conf);
            if (!_unresolvedMenuItems.containsKey(script.getId()))
            {
                _unresolvedMenuItems.put(script.getId(), new ArrayList<>());
            }
            _unresolvedMenuItems.get(script.getId()).add(id);
        }
    }
    
    /**
     * Add the action label configuration
     * @param configuration the parent configuration
     * @param classConf the class configuration
     * @param actionId the action id
     * @param actionName the action name
     */
    protected void _addActionLabelConfiguration(Configuration configuration, DefaultConfiguration classConf, int actionId, String actionName)
    {
        DefaultConfiguration labelConf = new DefaultConfiguration("label");
        labelConf.setAttribute("i18n", configuration.getChild("menu-" + actionId + "-label").getAttribute("i18n", "true"));
        labelConf.setValue(configuration.getChild("menu-" + actionId + "-label").getValue(actionName));
        classConf.addChild(labelConf);
    }
    
    /**
     * Add the action description configuration
     * @param configuration the parent configuration
     * @param classConf the class configuration
     * @param actionId the action id
     * @param actionName the action name
     */
    protected void _addActionDescriptionConfiguration(Configuration configuration, DefaultConfiguration classConf, int actionId, String actionName)
    {
        DefaultConfiguration descConf = new DefaultConfiguration("description");
        descConf.setAttribute("i18n", configuration.getChild("menu-" + actionId + "-description").getAttribute("i18n", "true"));
        descConf.setValue(configuration.getChild("menu-" + actionId + "-description").getValue(actionName + "_DESCRIPTION"));
        classConf.addChild(descConf);
    }
    
    /**
     * Add the action comment configuration
     * @param configuration the parent configuration
     * @param classConf the class configuration
     * @param actionId the action id
     * @param actionName the action name
     * @param parameters the script parameters
     */
    @SuppressWarnings("unchecked")
    protected void _addActionCommentConfiguration(Configuration configuration, DefaultConfiguration classConf, int actionId, String actionName, Map<String, Object> parameters)
    {
        DefaultConfiguration commentConf = new DefaultConfiguration("comment");
        commentConf.setValue(configuration.getChild("menu-" + actionId + "-comment").getValueAsBoolean(((List<Integer>) parameters.get("workflow-comments-ids")).contains(actionId)));
        classConf.addChild(commentConf);
    }
    
    /**
     * Additional configuration for menu items
     * @param itemConf The item configuration
     * @param classConf The class configuration
     * @param actionId The workflow action id
     * @param parameters The script parameters
     */
    protected void _additionalMenuItemConfiguration (Configuration itemConf, DefaultConfiguration classConf, int actionId, Map<String, Object> parameters)
    {
        // Nothing to do
    }
    
    /**
     * Configure the default description
     * @param parameters The parameters
     */
    protected void _configureDefaultDescriptions(Map<String, Object> parameters)
    {
        // Empty selection
        if (!parameters.containsKey("selection-description-empty"))
        {
            parameters.put("selection-description-empty", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_NOSELECTION_DESCRIPTION"));
        }
        
        // No match selection
        if (!parameters.containsKey("selection-description-nomatch"))
        {
            parameters.put("selection-description-nomatch", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_NOMATCH_DESCRIPTION"));
        }
        
        // Multiselection forbidden
        if (!parameters.containsKey("selection-description-multiselectionforbidden"))
        {
            parameters.put("selection-description-multiselectionforbidden", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_NOMULTISELECT_DESCRIPTION"));
        }
        
        // No available action
        if (!parameters.containsKey("noaction-available-description"))
        {
            parameters.put("noaction-available-description", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_NOACTIONAVAILABLE_DESCRIPTION"));
        }
        
        // Refreshing
        if (!parameters.containsKey("refreshing-description"))
        {
            parameters.put("refreshing-description", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_REFRESH_DESCRIPTION"));
        }
        
        // Content selected
        if (!parameters.containsKey("contentselected-start-description"))
        {
            parameters.put("contentselected-start-description", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_DESCRIPTION_BEGIN"));
        }
        if (!parameters.containsKey("contentselected-end-description"))
        {
            parameters.put("contentselected-end-description", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_DESCRIPTION_END"));
        }
        
        // Editing
        if (!parameters.containsKey("editing-description"))
        {
            parameters.put("editing-description", new I18nizableText("plugin.cms", "CONTENT_WORKFLOW_EDITING_DESCRIPTION"));
        }
    }
    
    private void _resolveMenuItems() throws Exception
    {
        if (_unresolvedMenuItems != null)
        {
            _menuItemManager.initialize();
            
            for (String scriptId : _unresolvedMenuItems.keySet())
            {
                for (String id : _unresolvedMenuItems.get(scriptId))
                {
                    ClientSideElement element;
                    try
                    {
                        element = _menuItemManager.lookup(id);
                    }
                    catch (ComponentException e)
                    {
                        throw new Exception("Unable to lookup client side element role: '" + id + "'", e);
                    }
                    
                    if (!_menuItems.containsKey(scriptId))
                    {
                        _menuItems.put(scriptId, new ArrayList<>());
                    }
                    _menuItems.get(scriptId).add(element);
                    _referencedClientSideElement.add(element);
                }
            }
        }
        
        _unresolvedMenuItems = null;
    }
    
    /**
     * A static client side element where all i18n parameters will be translated and html escaped
     */
    public static final class EscapeHTMLI18nizableTextClientSideElement extends StaticClientSideElement
    {
        private I18nUtils _i18nUtils;

        @Override
        public void service(ServiceManager smanager) throws ServiceException
        {
            super.service(smanager);
            _i18nUtils = (I18nUtils) smanager.lookup(I18nUtils.ROLE);
        }
        
        @Override
        public List<Script> getScripts(boolean ignoreRights, Map<String, Object> contextParameters)
        {
            List<Script> scripts = super.getScripts(ignoreRights, contextParameters);
            if (scripts == null)
            {
                return null;
            }
            
            List<Script> newScripts = new ArrayList<>();
            for (Script script : scripts)
            {
                Script newScript = new Script(script);
                Map<String, Object> parameters = newScript.getParameters();
                
                for (String key : parameters.keySet())
                {
                    Object value = parameters.get(key);
                    if (value instanceof I18nizableText)
                    {
                        parameters.put(key, StringUtils.escapeHTML(_i18nUtils.translate((I18nizableText) value)));
                    }
                }
                newScripts.add(newScript);
            }
            return newScripts;
        }
    }
}