/*
 *  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.Arrays;
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.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.workflow.AbstractContentWorkflowComponent;
import org.ametys.core.ui.Callable;
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.User;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.UserManager;
import org.ametys.plugins.core.ui.util.ConfigurationHelper;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.support.WorkflowHelper;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
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;
import com.opensymphony.workflow.spi.Step;

/**
 * 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;
    
    @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);
    }
    
    @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);
        }

        for (Script script : _scripts)
        {
            Map<String, Object> parameters = script.getParameters();
            
            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);
            }
        }
        
        return _scripts;
    }
    
    @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
            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);
            
            // Description
            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);
            
            // 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
            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);
            
            _additionalMenuItemConfiguration(configuration, classConf, actionId, parameters);
            
            conf.addChild(classConf);
            
            _menuItemManager.addComponent(_pluginName, null, id, StaticClientSideElement.class, conf);
            if (!_unresolvedMenuItems.containsKey(script.getId()))
            {
                _unresolvedMenuItems.put(script.getId(), new ArrayList<>());
            }
            _unresolvedMenuItems.get(script.getId()).add(id);
        }
    }
    
    /**
     * 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"));
        }
    }

    /**
     * Get the workflow state of contents
     * @param contentsId The ids of contents to test workflow status
     * @param scriptId The script id
     * @return The workflow state
     */
    @Callable
    public Map<String, Object> getWorkflowState(List<String> contentsId, String scriptId)
    {
        List<Map<String, Object>> contents = new ArrayList<>();
        boolean invalidWorkflowForAllContents = true;
        
        for (String contentId : contentsId)
        {
            Content content = _resolver.resolveById(contentId);
            
            if (content instanceof WorkflowAwareContent)
            {
                WorkflowAwareContent waContent = (WorkflowAwareContent) content;
                AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(waContent);
                
                for (Script script : _scripts)
                {
                    if (script.getId().equals(scriptId))
                    {
                        long wId = waContent.getWorkflowId();
                        String workflowName = (String) script.getParameters().get("workflow-name");
                        if (!workflow.getWorkflowName(wId).equals(workflowName))
                        {
                            continue;
                        }
                        
                        invalidWorkflowForAllContents = false;
                        
                        List<Step> steps = workflow.getCurrentSteps(wId);
                        List<Integer> stepIds = new ArrayList<>();
                        for (Step step : steps)
                        {
                            stepIds.add(step.getStepId());
                        }
                        
                        Integer workflowStepId = (Integer) script.getParameters().get("workflow-step");
                        if (stepIds.contains(workflowStepId))
                        {
                            Map<String, Object> contentParams = _getContentParameters(content, workflow, script, wId);
                            contents.add(contentParams);
                        }
                    }
                }
            }
        }
        
        Map<String, Object> results = new HashMap<>();
        results.put("contents", contents);
        
        if (invalidWorkflowForAllContents)
        {
            results.put("invalidWorkflow", true);
        }
        return results;
    }

    @SuppressWarnings("unchecked")
    private Map<String, Object> _getContentParameters(Content content, AmetysObjectWorkflow workflow, Script script, long wId)
    {
        Map<String, Object> contentParams = new HashMap<>();
        contentParams.put("id", content.getId());
        contentParams.put("title", _contentHelper.getTitle(content));
        
        String i18nKey = "CONTENT_WORKFLOW_DESCRIPTION";
        
        List<String> workflowI18nParameters = new ArrayList<>();
        workflowI18nParameters.add(_contentHelper.getTitle(content));
        
        boolean isLocked = false;
        if (content instanceof LockableAmetysObject)
        {
            LockableAmetysObject lockableContent = (LockableAmetysObject) content;
            if (lockableContent.isLocked() && !LockHelper.isLockOwner(lockableContent, _currentUserProvider.getUser()))
            {
                i18nKey = "CONTENT_WORKFLOW_LOCKED_DESCRIPTION";
                
                UserIdentity currentLockerIdentity = lockableContent.getLockOwner();
                User currentLocker = currentLockerIdentity != null ? _userManager.getUser(currentLockerIdentity.getPopulationId(), currentLockerIdentity.getLogin()) : null;
   
                workflowI18nParameters.add(currentLocker != null ? currentLocker.getFullName() : "");
                workflowI18nParameters.add(currentLockerIdentity != null ? currentLockerIdentity.getLogin() : "Anonymous");
                
                isLocked = true;
            }
        }
        
        contentParams.put("description", new I18nizableText("plugin.cms", i18nKey, workflowI18nParameters));
        contentParams.put("locked", isLocked);
   
        Map<String, Object> vars = new HashMap<>();
        vars.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
        vars.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String> ());
   
        int[] availableActions = workflow.getAvailableActions(wId, vars);
        Arrays.sort(availableActions);
        
        List<Integer> activeActions = new ArrayList<>();
        for (int actionId : (List<Integer>) script.getParameters().get("workflow-actions-ids"))
        {
            if (Arrays.binarySearch(availableActions, actionId) >= 0)
            {
                activeActions.add(actionId);
            }
        }
        contentParams.put("actions", activeActions);
        
        return contentParams;
    }
    
    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;
    }
}