/*
 *  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.plugins.bpm;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.configuration.DefaultConfigurationBuilder;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.servlet.multipart.Part;
import org.apache.cocoon.servlet.multipart.PartOnDisk;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.xml.sax.SAXException;

import org.ametys.cms.FilterNameHelper;
import org.ametys.core.group.GroupIdentity;
import org.ametys.core.group.GroupManager;
import org.ametys.core.right.RightManager;
import org.ametys.core.right.RightManager.RightResult;
import org.ametys.core.ui.Callable;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.I18nUtils;
import org.ametys.core.util.JSONUtils;
import org.ametys.core.util.URLEncoder;
import org.ametys.plugins.bpm.jcr.JCRWorkflow;
import org.ametys.plugins.bpm.jcr.JCRWorkflowFactory;
import org.ametys.plugins.bpm.jcr.JCRWorkflowProcess;
import org.ametys.plugins.bpm.jcr.JCRWorkflowProcessFactory;
import org.ametys.plugins.bpm.workflowsdef.RegisterVariable;
import org.ametys.plugins.core.user.UserHelper;
import org.ametys.plugins.explorer.resources.ModifiableResource;
import org.ametys.plugins.explorer.resources.ModifiableResourceCollection;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.explorer.resources.actions.AddOrUpdateResourceHelper;
import org.ametys.plugins.explorer.resources.actions.AddOrUpdateResourceHelper.ResourceOperationMode;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.query.expression.Expression.Operator;
import org.ametys.plugins.workflow.store.JdbcWorkflowStore;
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.parameter.ParameterHelper;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;
import org.ametys.runtime.plugin.component.PluginAware;
import org.ametys.web.URIPrefixHandler;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PageQueryHelper;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.site.SiteManager;
import org.ametys.web.skin.Skin;
import org.ametys.web.skin.SkinsManager;
import org.ametys.web.tags.TagExpression;

import com.opensymphony.workflow.Workflow;
import com.opensymphony.workflow.WorkflowException;
import com.opensymphony.workflow.loader.StepDescriptor;
import com.opensymphony.workflow.loader.WorkflowDescriptor;
import com.opensymphony.workflow.spi.Step;
import com.opensymphony.workflow.spi.WorkflowEntry;

/**
 * Manager for retrieving, creation, edition and suppression of workflows, and retrieving information on workflows definitions
 */
public class BPMWorkflowManager extends AbstractLogEnabled implements Component, Serviceable, Initializable, Contextualizable, PluginAware
{
    /** Avalon Role */
    public static final String ROLE = BPMWorkflowManager.class.getName();
    
    /** Right to create a new workflow */
    public static final String RIGHT_WORKFLOW_CREATE = "BPM_Rights_Workflow_Create";
    /** Right to edit any workflow */
    public static final String RIGHT_WORKFLOW_EDIT = "BPM_Rights_Workflow_Edit";
    /** Right to delete any workflow */
    public static final String RIGHT_WORKFLOW_DELETE = "BPM_Rights_Workflow_Delete";
    
    /** Right to manage processes */
    public static final String RIGHTS_PROCESS_MANAGE_PROCESSES = "BPM_Rights_Workflow_Manage_Processes";
    
    /** Tag for the create process page */
    public static final String PAGE_TAG_CREATEPROCESS = "CREATE_PROCESS";
    /** Tag for the process dashboard page */
    public static final String PAGE_TAG_PROCESS_DASHBOARD = "PROCESS_DASHBOARD";
    
    /** The fixed id for the edit workflow action on processus */
    public static final int WORKFLOW_ACTION_EDIT = 2;

    
    /** The plugin root node name */
    public static final String BPM_ROOT_NODE = "bpm";
    /** The BPM Workflows node name*/
    public static final String BPMWORKFLOW_ROOT_NODE = "ametys:workflows";
    /** The processes node name under each workflow */
    public static final String BPMPROCESSES_ROOT_NODE = "ametys:processes";
    
    private static final String _BPM_PROCESS_TEMPLATE = "bpm-process";
    
    private AmetysObjectResolver _resolver;
    private WorkflowProvider _workflowProvider;
    private CurrentUserProvider _currentUserProvider;
    private RightManager _rightManager;
    private JSONUtils _jsonUtils;
    private UserHelper _userHelper;
    private AddOrUpdateResourceHelper _addOrUpdateResourceHelper;
    private WorkflowHelper _workflowHelper;

    private Map<String, Map<String, Object>> _workflowDefinitionsCache;
    
    private Context _context;

    private SkinsManager _skinsManager;

    private AmetysObjectResolver _ametysObjectResolver;

    private SiteManager _siteManager;

    private GroupManager _groupManager;
    
    private URIPrefixHandler _uriPrefixHandler;

    private String _pluginName;

    private I18nUtils _i18nUtils;

    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _currentUserProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _rightManager = (RightManager) manager.lookup(RightManager.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
        _userHelper = (UserHelper) manager.lookup(UserHelper.ROLE);
        _addOrUpdateResourceHelper = (AddOrUpdateResourceHelper) manager.lookup(AddOrUpdateResourceHelper.ROLE);
        _workflowHelper = (WorkflowHelper) manager.lookup(WorkflowHelper.ROLE);
        _skinsManager = (SkinsManager) manager.lookup(SkinsManager.ROLE);
        _ametysObjectResolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _siteManager = (SiteManager) manager.lookup(SiteManager.ROLE);
        _groupManager = (GroupManager) manager.lookup(GroupManager.ROLE);
        _uriPrefixHandler = (URIPrefixHandler) manager.lookup(URIPrefixHandler.ROLE);
        _i18nUtils = (I18nUtils) manager.lookup(I18nUtils.ROLE);
    }
    
    @Override
    public void initialize() throws Exception
    {
        _workflowDefinitionsCache = new HashMap<>();
    }
    
    public void setPluginInfo(String pluginName, String featureName, String id)
    {
        _pluginName = pluginName;
    }
    
    /**
     * Get the list of workflow definitions
     * @return The list of workflow definitions, mapped by name and label
     */
    @Callable
    public Map<String, Object> getWorkflowDefinitions()
    {
        Map<String, Object> result = new HashMap<>();
        Workflow workflow = _workflowProvider.getExternalWorkflow(JdbcWorkflowStore.ROLE);
        String[] workflowNames = workflow.getWorkflowNames();
        
        Map<String, Object> workflowBuffer = new HashMap<> ();
        List<Map<String, Object>> workflowsList = new ArrayList<> ();
        
        for (String workflowName : workflowNames)
        {
            if (workflowName.startsWith("bpm-"))
            {
                Map<String, Object> workflowDefinitionData = _getWorkflowDefinitionData(workflowName);
                if (workflowDefinitionData != null)
                {
                    workflowBuffer = new HashMap<>();
                    workflowBuffer.put("value", workflowName);
                    workflowBuffer.put("label", new I18nizableText("application", "WORKFLOW_" + workflowName));
                    workflowsList.add(workflowBuffer);
                }
            }
        }
        
        result.put("workflowDefinition", workflowsList);
        result.put("success", true);
        return result;
    }
    
    /**
     * Retrieve the value of a variable from a workflow
     * @param workflowId The workflow id
     * @param variableName The variable name
     * @return The value
     */
    public Object getWorkflowVariable(String workflowId, String variableName)
    {
        JCRWorkflow workflow = _resolver.resolveById(workflowId);
        return workflow.getVariable(variableName);
    }
    
    /**
     * Retrieve the list of variables from a workflow definition
     * @param workflowDefId The workflow definition id
     * @return The list of variables, with their attributes such as the label, type, multiple, if defined
     */
    @Callable
    public Map<String, Object> getWorkflowDefinitionVariables(String workflowDefId)
    {
        Map<String, Object> result = new HashMap<>();
        Map<String, Object> workflowDefinitionData = _getWorkflowDefinitionData(workflowDefId);
        boolean success = false;
        if (workflowDefinitionData != null && workflowDefinitionData.containsKey("variables"))
        {
            @SuppressWarnings("unchecked")
            Map<String, Map<String, String>> variables = (Map<String, Map<String, String>>) workflowDefinitionData.get("variables");
            if (variables != null)
            {
                success = true;
                result.put("variables", variables);
            }
        }
        result.put("success", success);
        return result;
    }
    
    /**
     * Retrieve the list of workflows
     * @return The list of workflows
     */
    @Callable
    public Map<String, Object> getWorkflows()
    {
        Map<String, Object> result = new HashMap<>();
        List<Map<String, Object>> workflows = new ArrayList<>();
        
        try
        {
            ModifiableTraversableAmetysObject workflowsRootNode = _getWorkflowsRootNode(false);
            AmetysObjectIterable<AmetysObject> children = workflowsRootNode.getChildren();
            for (AmetysObject child : children)
            {
                if (child instanceof JCRWorkflow)
                {
                    JCRWorkflow workflow = (JCRWorkflow) child;
                    String workflowDefinition = workflow.getWorkflowDefinition();
                    Map<String, Object> workflowJson = _workflowToJson(workflow, _getWorkflowDefinitionData(workflowDefinition));
                    if (workflowJson != null)
                    {
                        workflows.add(workflowJson);
                    }
                }
            }
        }
        catch (UnknownAmetysObjectException e)
        {
            // no workflows root node yet, ignore
        }
        
        result.put("workflows", workflows);
        return result;
    }
    
    /**
     * Retrieve the list of workflows availables to the current user, in JSON format
     * @return The list of workflows
     */
    public List<Map<String, Object>> getWorkflowsAvailables()
    {
        List<Map<String, Object>> workflows = new ArrayList<>();
        
        try
        {
            ModifiableTraversableAmetysObject workflowsRootNode = _getWorkflowsRootNode(false);
            AmetysObjectIterable<AmetysObject> children = workflowsRootNode.getChildren();
            for (AmetysObject child : children)
            {
                if (child instanceof JCRWorkflow)
                {
                    JCRWorkflow workflow = (JCRWorkflow) child;
                    if (isUserAllowedOnWorkflow(workflow))
                    {
                        String workflowDefinition = workflow.getWorkflowDefinition();
                        Map<String, Object> workflowJson = _workflowToJson(workflow, _getWorkflowDefinitionData(workflowDefinition));
                        if (workflowJson != null)
                        {
                            workflows.add(workflowJson);
                        }
                    }
                }
            }
        }
        catch (UnknownAmetysObjectException e)
        {
            // no workflows root node yet, ignore
        }
        
        return workflows;
    }
    
    /**
     * Retrieve the data of a workflow, in JSON format. Contains both the values of the workflow, and the workflow variables definitions
     * @param workflowId The workflow id
     * @return The data of a workflow
     */
    @Callable
    public Map<String, Object> getWorkflowData(String workflowId)
    {
        Map<String, Object> result = new HashMap<>();
        
        JCRWorkflow workflow = _resolver.resolveById(workflowId);
        String workflowDefinition = workflow.getWorkflowDefinition();
        Map<String, Object> workflowDefinitionData = _getWorkflowDefinitionData(workflowDefinition);
        result.put("workflow", _workflowToJson(workflow, workflowDefinitionData));
        if (workflowDefinitionData != null)
        {
            result.put("variables", workflowDefinitionData.get("variables"));
        }
        result.put("success", true);
        return result;
    }
    
    /**
     * Add a new workflow
     * @param values The values for the new workflow. Must contains a "name", "workflowDef" and any variables mandatory for the workflowDef
     * @return The result, with the new workflow id if successful
     * @throws IllegalAccessException If a user with insufficient rights try to execute this method
     */
    @Callable (right = RIGHT_WORKFLOW_CREATE)
    public Map<String, Object> addWorkflow(Map<String, Object> values) throws IllegalAccessException
    {
        ModifiableTraversableAmetysObject workflowsRoot = _getWorkflowsRootNode(true);
        
        String workflowDef = (String) values.getOrDefault("workflowDef", null);
        String name = (String) values.getOrDefault("title", null);
        
        if (StringUtils.isEmpty(workflowDef) || StringUtils.isEmpty(name))
        {
            throw new IllegalArgumentException("Missing mandatory arguments for creating a new workflow");
        }
        
        String originalName = FilterNameHelper.filterName(name);
        // Find unique name
        String uniqueName = originalName;
        int index = 2;
        while (workflowsRoot.hasChild(uniqueName))
        {
            uniqueName = originalName + "-" + (index++);
        }

        JCRWorkflow workflow = (JCRWorkflow) workflowsRoot.createChild(uniqueName, JCRWorkflowFactory.WORKFLOW_NODE_TYPE);
        workflow.setWorkflowDefinition(workflowDef);
        _setWorkflowValues(workflow, values);
        
        workflow.saveChanges();
        
        Map<String, Object> result = new HashMap<>();
        result.put("id", workflow.getId());
        
        return result;
    }
    
    /**
     * Edit a workflow values
     * @param workflowId The workflow
     * @param values The values
     * @return The result, with the workflow id if successful
     * @throws IllegalAccessException If a user with insufficient rights try to execute this method
     */
    @Callable
    public Map<String, Object> editWorkflow(String workflowId, Map<String, Object> values) throws IllegalAccessException
    {
        JCRWorkflow workflow = _resolver.resolveById(workflowId);
        
        UserIdentity currentUser = _currentUserProvider.getUser();
        if ((currentUser == null || !currentUser.equals(workflow.getOwner())) && _rightManager.currentUserHasRight(RIGHT_WORKFLOW_EDIT, null) != RightResult.RIGHT_ALLOW)
        {
            throw new IllegalAccessException("User '" + _currentUserProvider.getUser().toString() + "' tried to create a process with insufficient rights");
        }
        
        _setWorkflowValues(workflow, values);
        if (workflow.needsSave())
        {
            workflow.saveChanges();
        }
        
        Map<String, Object> result = new HashMap<>();
        result.put("id", workflow.getId());
        
        return result;
    }
    
    /**
     * Delete a list of workflow
     * @param workflowIds The workflows
     * @return The result
     */
    @Callable
    public Map<String, Object> deleteWorkflow(List<String> workflowIds)
    {
        Map<String, Object> result = new HashMap<>();
        List<JCRWorkflow> workflows = new ArrayList<>();
        for (String workflowId : workflowIds)
        {
            JCRWorkflow workflow = _resolver.resolveById(workflowId);
            UserIdentity owner = workflow.getOwner();
            if ((owner != null && owner.equals(_currentUserProvider.getUser())) || _rightManager.currentUserHasRight(RIGHT_WORKFLOW_DELETE, null) == RightResult.RIGHT_ALLOW)
            {
                List<Object> workflowProcessus = getWorkflowProcessus(workflow);
                if (workflowProcessus.size() == 0)
                {
                    workflows.add(workflow);
                }
            }
        }
        
        List<String> workflowDeletedIds = new ArrayList<>();
        for (JCRWorkflow workflow : workflows)
        {
            ModifiableAmetysObject parent = (ModifiableAmetysObject) workflow.getParent();
            workflowDeletedIds.add(workflow.getId());
            workflow.remove();
            parent.saveChanges();
        }
        result.put("ids", workflowDeletedIds);
        
        result.put("success", true);
        return result;
    }
    
    /**
     * Retrieve the list of process created from a workflow
     * @param workflowId The workflow
     * @return The list of process
     */
    @Callable (right = RIGHTS_PROCESS_MANAGE_PROCESSES)
    public Map<String, Object> getWorkflowProcesses(String workflowId)
    {
        Map<String, Object> result = new HashMap<>();
        JCRWorkflow workflow = _resolver.resolveById(workflowId);
        result.put("processes", getWorkflowProcessus(workflow).stream().map(process -> _processToJson((JCRWorkflowProcess) process)).collect(Collectors.toList()));
        return result;
    }
    
    /**
     * Retrieve the list of process created from a workflow
     * @param workflow The workflow
     * @return The list of process
     */
    public List<Object> getWorkflowProcessus(JCRWorkflow workflow)
    {
        try
        {
            ModifiableTraversableAmetysObject processesRoot = _getProcessesRootNode(workflow, false);
            return processesRoot.getChildren().stream().collect(Collectors.toList());
        }
        catch (UnknownAmetysObjectException e)
        {
            // no processes for the workflow
        }
        return new ArrayList<>();
    }
    
    
    /**
     * Create a new process
     * @param workflowId The workflow used by the process
     * @param title The process title
     * @param site The site on which the process was created
     * @param description The process description
     * @param uploadedAttachments The process attachments
     * @return The new process
     * @throws WorkflowException If an error occurred creating the workflow
     * @throws IllegalAccessException If the user is not allowed
     */
    public JCRWorkflowProcess createProcess(String workflowId, String title, String site, String description, List<PartOnDisk> uploadedAttachments) throws WorkflowException, IllegalAccessException
    {
        JCRWorkflow workflow = _resolver.resolveById(workflowId);
        
        if (!isUserAllowedOnWorkflow(workflow))
        {
            throw new IllegalAccessException("User '" + _currentUserProvider.getUser().toString() + "' tried to create a process with insufficient rights");
        }
        
        ModifiableTraversableAmetysObject processesRoot = _getProcessesRootNode(workflow, true);
        
        String originalName = FilterNameHelper.filterName(title);
        // Find unique name
        String uniqueName = originalName;
        int index = 2;
        while (processesRoot.hasChild(uniqueName))
        {
            uniqueName = originalName + "-" + (index++);
        }

        JCRWorkflowProcess process = (JCRWorkflowProcess) processesRoot.createChild(uniqueName, JCRWorkflowProcessFactory.WORKFLOW_PROCESS_NODE_TYPE);
        process.setCreator(_currentUserProvider.getUser());
        process.setWorkflow(workflowId);
        process.setCreationDate(new Date());
        _setProcessValues(process, title, site, description, uploadedAttachments);
        
        // create workflow with entry id
        Workflow workflowStore = _workflowProvider.getAmetysObjectWorkflow(process, true);
        
        String workflowName = workflow.getWorkflowDefinition();
        int initialActionId = _workflowHelper.getInitialAction(workflowName); 
        
        // Add the workflow used by the process in the request, to be used by any RegisterVariable of the workflow definition 
        Request request = ContextHelper.getRequest(_context);
        request.setAttribute("workflowId", process.getWorkflow());
        
        Map<String, Object> inputs = new HashMap<>();
        inputs.put("workflowId", workflowId);
        inputs.put("process", process);
        long workflowInstanceId = workflowStore.initialize(workflowName, initialActionId, inputs);
        process.setWorkflowId(workflowInstanceId);
        Step currentStep = (Step) workflowStore.getCurrentSteps(process.getWorkflowId()).iterator().next();
        process.setCurrentStepId(currentStep.getStepId());
        process.saveChanges();
        
        return process;
    }
    

    /**
     * Edit a process
     * @param processId The process id
     * @param title The title
     * @param description The description
     * @param uploadedAttachments The list of new attachments uploaded
     * @param attachmentsUntouched The list of untouched attachments names
     * @throws WorkflowException If an error occurred while executing the workflow action 
     */
    public void editProcess(String processId, String title, String description, List<PartOnDisk> uploadedAttachments, List<String> attachmentsUntouched) throws WorkflowException
    {
        JCRWorkflowProcess process = _resolver.resolveById(processId);
        
        Workflow workflowStore = _workflowProvider.getAmetysObjectWorkflow(process, true);
        Map<String, Object> inputs = new HashMap<>();
        inputs.put("process", process);
        
        inputs.put("title", title);
        inputs.put("description", description);
        inputs.put("uploadedAttachments", uploadedAttachments);
        inputs.put("attachmentsUntouched", attachmentsUntouched);
        
        // Add the workflow used by the process in the request, to be used by any RegisterVariable of the workflow definition 
        Request request = ContextHelper.getRequest(_context);
        request.setAttribute("workflowId", process.getWorkflow());
        
        workflowStore.doAction(process.getWorkflowId(), WORKFLOW_ACTION_EDIT, inputs);
    }
    
    /**
     * Retrieve a process
     * @param workflowName The workflow name
     * @param processName The process name
     * @return The process
     */
    public JCRWorkflowProcess getProcess(String workflowName, String processName)
    {
        try
        {
            ModifiableTraversableAmetysObject workflowsRoot = _getWorkflowsRootNode(false);
            JCRWorkflow workflow = workflowsRoot.getChild(workflowName);
            ModifiableTraversableAmetysObject processesRoot = _getProcessesRootNode(workflow, false);
            if (processesRoot.hasChild(processName))
            {
                return processesRoot.getChild(processName);
            }
        }
        catch (UnknownAmetysObjectException e)
        {
            // No workflow or process created with this workflowId and processId
            return null;
        }
        
        return null;
    }
    
    /**
     * Determines if the process is complete
     * @param process The process
     * @return True if the process is complete
     */
    public boolean isComplete(JCRWorkflowProcess process)
    {
        AmetysObjectWorkflow aoWorkflow = _workflowProvider.getAmetysObjectWorkflow(process, true);
        if (aoWorkflow != null)
        {
            int entryState = aoWorkflow.getEntryState(process.getWorkflowId());
            return entryState ==  WorkflowEntry.COMPLETED;
        }
        
        // FIXME on final step the workflow is compelte but deleted ...
        return false;
    }
    
    /**
     * Determines if the process can be deleted by the current user
     * @param process The process
     * @return True if the process can be deleted
     */
    public boolean canDelete(JCRWorkflowProcess process)
    {
        if (_rightManager.currentUserHasRight(RIGHTS_PROCESS_MANAGE_PROCESSES, null) == RightResult.RIGHT_ALLOW)
        {
            // A super admin can delete a process at all time
            return true;
        }
        
        // Otherwise a process can be deleted only by the creator if is complete
        return isComplete(process) && process.getCreator().equals(_currentUserProvider.getUser());
    }

    /**
     * Delete a process
     * @param process The process to delete
     * @throws IllegalAccessException If a user tries to delete a process without being allowed 
     */
    public void deleteProcess(JCRWorkflowProcess process) throws IllegalAccessException
    {
        if (_rightManager.currentUserHasRight(RIGHTS_PROCESS_MANAGE_PROCESSES, null) != RightResult.RIGHT_ALLOW)
        {
            Workflow workflowStore = _workflowProvider.getAmetysObjectWorkflow(process, true);
            int entryState = workflowStore.getEntryState(process.getWorkflowId());
            if (entryState !=  WorkflowEntry.COMPLETED || !process.getCreator().equals(_currentUserProvider.getUser()))
            {
                throw new IllegalAccessException("User '" + _currentUserProvider.getUser() + "' tried to delete a process without sufficient rights."); 
            }
        }
        
        ModifiableAmetysObject parent = process.getParent();
        process.remove();
        parent.saveChanges();
    }

    /**
     * Delete a list of processes
     * @param processes The processes to delete
     * @return The result
     * @throws IllegalAccessException If a user tries to delete a process without being allowed 
     */
    @Callable (right = RIGHTS_PROCESS_MANAGE_PROCESSES)
    public Map<String, Object> deleteProcesses(List<String> processes) throws IllegalAccessException
    {
        Map<String, Object> result = new HashMap<>();
        List<String> processesDeletedIds = new ArrayList<>();
        for (String processId : processes)
        {
            JCRWorkflowProcess process = _resolver.resolveById(processId);
            ModifiableAmetysObject parent = (ModifiableAmetysObject) process.getParent();
            processesDeletedIds.add(process.getId());
            process.remove();
            parent.saveChanges();
        }

        result.put("ids", processesDeletedIds);
        result.put("success", true);
        return result;
    }
    
    /**
     * Get the url of a process page
     * @param process The process
     * @param siteName The current site name. Can not be null.
     * @param lang The current language. Can not be null.
     * @param absolute true to get absolute url.
     * @return the url of process page
     */
    public String getProcessPageUrl(JCRWorkflowProcess process, String siteName, String lang, boolean absolute)
    {
        StringBuilder sb = new StringBuilder();
        
        if (absolute)
        {
            sb.append(_uriPrefixHandler.getAbsoluteUriPrefix(siteName));
        }
        else
        {
            sb.append(_uriPrefixHandler.getUriPrefix(siteName));
        }
        
        sb.append("/")
            .append(lang)
            .append("/_plugins/")
            .append(_pluginName)
            .append("/")
            .append(getTemplateForProcessPage(siteName, lang))
            .append("/process/");
        
        JCRWorkflow workflow = _resolver.resolveById(process.getWorkflow());
        
        sb.append(URLEncoder.encodePath(workflow.getName()))
            .append("/")
            .append(URLEncoder.encodePath(process.getName()))
            .append(".html");
        
        return sb.toString();
    }
    
    /**
     * Get the page with PROCESS_DASHBOARD tag
     * @param siteName The current site name
     * @param lang The language
     * @return The page or null if not found.
     */
    public Page getDashboardPage (String siteName, String lang)
    {
        TagExpression tagExpression = new TagExpression(Operator.EQ, PAGE_TAG_PROCESS_DASHBOARD);
        
        String pathQuery = PageQueryHelper.getPageXPathQuery(siteName, lang, null, tagExpression, null);
        AmetysObjectIterable<Page> page = _ametysObjectResolver.query(pathQuery);
        
        if (page.getSize() == 0)
        {
            return null;
        }
        
        return page.iterator().next();
    }
    
    /**
     * Get the page with CREATE_PROCESS tag
     * @param siteName The current site name
     * @param lang The language
     * @return The page or null if not found.
     */
    public Page getCreateProcessPage (String siteName, String lang)
    {
        TagExpression tagExpression = new TagExpression(Operator.EQ, PAGE_TAG_CREATEPROCESS);
        
        String pathQuery = PageQueryHelper.getPageXPathQuery(siteName, lang, null, tagExpression, null);
        AmetysObjectIterable<Page> page = _ametysObjectResolver.query(pathQuery);
        
        if (page.getSize() == 0)
        {
            return null;
        }
        
        return page.iterator().next();
    }
    
    /**
     * Get the template to use for process rendering
     * @param siteName The site containing the page
     * @param lang The sitemap of the page
     * @return The template to use for process rendering
     */
    public String getTemplateForProcessPage(String siteName, String lang)
    {
        Site site = _siteManager.getSite(siteName);
        
        String skinName = site.getSkinId();
        Skin skin = _skinsManager.getSkin(skinName);
        Set<String> templates = skin.getTemplates();
        
        // First look for the template bpm-process
        if (templates.contains(_BPM_PROCESS_TEMPLATE))
        {
            return _BPM_PROCESS_TEMPLATE;
        }

        // Otherwise, returns the template used by create process page
        Page createProcessPage = getCreateProcessPage(siteName, lang);
        if (createProcessPage != null)
        {
            return createProcessPage.getTemplate();
        }
        
        // Otherwise, fallback to the template page if exists
        if (templates.contains("page"))
        {
            return "page";
        }
        
        // Finally, fallback to the first template
        return templates.iterator().next();
    }
    
    /**
     * Test if the current user is present in any variable of the workflow
     * @param workflow The workflow
     * @return True if the user is in the workflow variables
     */
    @SuppressWarnings("unchecked")
    public boolean isUserInWorkflowVariables(JCRWorkflow workflow)
    {
        Map<String, Object> workflowDefinitionData = _getWorkflowDefinitionData(workflow.getWorkflowDefinition());
        
        if (workflowDefinitionData != null && workflowDefinitionData.containsKey("variables"))
        {
            Map<String, Map<String, String>> variables = (Map<String, Map<String, String>>) workflowDefinitionData.get("variables");
            UserIdentity currentUser = _currentUserProvider.getUser();
            
            boolean userInVariables = variables.entrySet().stream()
                .filter(e -> "user".equals(e.getValue().getOrDefault("type", null)))
                .map(e -> workflow.getVariable(e.getKey()))
                .filter(var -> var != null && var instanceof String)
                .map(var -> _jsonUtils.convertJsonToList((String) var))
                .map(usersList ->
                {
                    return usersList.stream()
                        .map(userData ->
                        {
                            Map<String, String> user = (Map<String, String>) userData;
                            String login = user.get("login");
                            String populationId = user.get("populationId");
                            return new UserIdentity(login, populationId);
                        })
                        .filter(user -> user != null && user.equals(currentUser))
                        .findAny();
                })
                .filter(optionalUser -> optionalUser.isPresent())
                .findAny()
                .isPresent();

            return userInVariables;
        }
        return false;
    }

    /**
     * Get the list of processes accessibles to the current user
     * @return The list of processes
     */
    public Set<JCRWorkflowProcess> getUserProcesses()
    {
        Set<JCRWorkflowProcess> processes = new HashSet<>();
        UserIdentity user = _currentUserProvider.getUser();
        if (user == null)
        {
            return processes;
        }
        
        if (_rightManager.currentUserHasRight(RIGHTS_PROCESS_MANAGE_PROCESSES, null) == RightResult.RIGHT_ALLOW)
        {
            // return all processes as we have the right to manage all of them
            AmetysObjectIterable<JCRWorkflowProcess> processesOwned = _ametysObjectResolver.query("//element(*, ametys:workflowProcess)");
            Iterator<JCRWorkflowProcess> it = processesOwned.iterator();
            while (it.hasNext())
            {
                processes.add(it.next());
            }
            return processes;
        }
        
        // retrieve processes of which we are the creator
        String xpath = String.format("//element(*, ametys:workflowProcess)[@ametys:creator/ametys:login='%s' and @ametys:creator/ametys:population='%s']", user.getLogin(), user.getPopulationId());
        AmetysObjectIterable<JCRWorkflowProcess> processesOwned = _ametysObjectResolver.query(xpath);
        Iterator<JCRWorkflowProcess> it = processesOwned.iterator();
        while (it.hasNext())
        {
            processes.add(it.next());
        }
        
        // add processes for which we are in the workflow variables
        ModifiableTraversableAmetysObject workflowsRootNode = _getWorkflowsRootNode(false);
        AmetysObjectIterable<AmetysObject> children = workflowsRootNode.getChildren();
        for (AmetysObject child : children)
        {
            if (child instanceof JCRWorkflow)
            {
                JCRWorkflow workflow = (JCRWorkflow) child;
                try
                {
                    ModifiableTraversableAmetysObject processesRootNode = _getProcessesRootNode(workflow, false);
                    AmetysObjectIterable<JCRWorkflowProcess> workflowChildren = processesRootNode.getChildren();
                    if (workflowChildren.getSize() > 0 && isUserInWorkflowVariables(workflow))
                    {
                        AmetysObjectIterator<JCRWorkflowProcess> it2 = workflowChildren.iterator();
                        while (it2.hasNext())
                        {
                            processes.add(it2.next());
                        }
                    }
                }
                catch (UnknownAmetysObjectException e)
                {
                    // No process for workflow, do nothing
                }
            }
        }
        
        return processes;
    }

    /**
     * Check if the current user is allowed to create a process from the workflow 
     * @param workflow The workflow
     * @return True if the user is allowed
     */
    public boolean isUserAllowedOnWorkflow(JCRWorkflow workflow)
    {
        UserIdentity user = _currentUserProvider.getUser();
        if (user != null)
        {
            if (user.equals(workflow.getOwner()) || ArrayUtils.contains(workflow.getAllowedUsers(), user))
            {
                return true;
            }
            
            GroupIdentity[] allowedGroups = workflow.getAllowedGroups();
            for (GroupIdentity userGroup : _groupManager.getUserGroups(user))
            {
                if (ArrayUtils.contains(allowedGroups, userGroup))
                {
                    return true;
                }
            }
        
        }
        return false;
    }

    @SuppressWarnings("unchecked")
    private void _setWorkflowValues(JCRWorkflow workflow, Map<String, Object> values)
    {
        String title = (String) values.get("title");
        String description = (String) values.getOrDefault("description", null);
        Map<String, Object> owner = (Map<String, Object>) values.getOrDefault("owner", null);
        List<Map<String, Object>> allowedUsersValue = (List<Map<String, Object>>) values.getOrDefault("allowedUsers", null);
        List<Map<String, Object>> allowedGroupsValue = (List<Map<String, Object>>) values.getOrDefault("allowedGroups", null);
        Map<String, Object> variables = (Map<String, Object>) values.getOrDefault("variables", null);

        workflow.setTitle(title);
        workflow.setDescription(description);
        workflow.setOwner(owner != null ? _convertJsonToUser(owner) : null);

        if (allowedUsersValue != null)
        {
            Set<UserIdentity> allowedUsers = new HashSet<>();
            for (Object obj : allowedUsersValue)
            {
                UserIdentity user = _convertJsonToUser((Map<String, Object>) obj);
                if (user != null)
                {
                    allowedUsers.add(user);
                }
            }
            
            workflow.setAllowedUsers(allowedUsers.toArray(new UserIdentity[allowedUsers.size()]));
        }
        
        if (allowedGroupsValue != null)
        {
            Set<GroupIdentity> allowedGroups = new HashSet<>();
            for (Object obj : allowedGroupsValue)
            {
                Map<String, Object> grantedUser = (Map<String, Object>) obj;
                String groupId = (String) grantedUser.get("groupId");
                String groupDirectory = (String) grantedUser.get("groupDirectory");
                
                if (groupId != null && groupDirectory != null)
                {
                    allowedGroups.add(new GroupIdentity(groupId, groupDirectory));
                }
            }

            workflow.setAllowedGroups(allowedGroups.toArray(new GroupIdentity[allowedGroups.size()]));
        }
        
        for (Entry<String, Object> entry : variables.entrySet())
        {
            workflow.setVariable(entry.getKey(), entry.getValue());
        }
    }
    
    private void _setProcessValues(JCRWorkflowProcess process, String title, String site, String description, List<PartOnDisk> uploadedAttachments)
    {
        if (title != null)
        {
            process.setTitle(title);
        }
        
        if (site != null)
        {
            process.setSite(site);
        }
        
        process.setDescription(description);
        
        ResourceCollection rootAttachments = process.getRootAttachments(true);
        if (rootAttachments instanceof ModifiableResourceCollection)
        {
            for (Part attachment : uploadedAttachments)
            {
                _addOrUpdateResourceHelper.performResourceOperation(attachment, (ModifiableResourceCollection) rootAttachments, ResourceOperationMode.ADD);
            }
        }
    }

    private UserIdentity _convertJsonToUser(Map<String, Object> user)
    {
        String login = (String) user.get("login");
        String populationId = (String) user.get("populationId");
        
        if (login != null && populationId != null)
        {
            return new UserIdentity(login, populationId);
        }
        
        return null;
    }
    
    private Map<String, Object> _workflowToJson(JCRWorkflow workflow, Map<String, Object> workflowDefinitionData)
    {
        if (workflow == null)
        {
            return null;
        }
        
        Map<String, Object> jsonData = new HashMap<>();
        
        jsonData.put("id", workflow.getId());
        jsonData.put("title", workflow.getTitle());
        Map<String, Object> workflowBuffer = new HashMap<>();
        workflowBuffer.put("value", workflow.getWorkflowDefinition());
        workflowBuffer.put("label", new I18nizableText("application", "WORKFLOW_" + workflow.getWorkflowDefinition()));
        if (workflowDefinitionData == null)
        {
            workflowBuffer.put("missing", true);
        }
        jsonData.put("workflowDefinition", workflowBuffer);
        jsonData.put("description", workflow.getDescription());
        jsonData.put("owner", _userHelper.user2json(workflow.getOwner(), true));
        jsonData.put("allowedUsers", Arrays.stream(workflow.getAllowedUsers()).map(ud -> _userHelper.user2json(ud, true)).collect(Collectors.toList()));
        jsonData.put("allowedGroups", _groups2Json(workflow.getAllowedGroups()));
        if (workflowDefinitionData != null && workflowDefinitionData.containsKey("variables"))
        {
            @SuppressWarnings("unchecked")
            Map<String, Map<String, String>> variables = (Map<String, Map<String, String>>) workflowDefinitionData.get("variables");
            if (variables != null)
            {
                jsonData.put("variables", variables.keySet().stream().filter(key -> workflow.getVariable(key) != null).collect(Collectors.toMap(Function.identity(), key -> workflow.getVariable(key))));
            }
        }
        
        jsonData.put("process", getWorkflowProcessus(workflow).size());
        
        return jsonData;
    }

    private List<Map<String, Object>> _groups2Json(GroupIdentity[] groups)
    {
        List<Map<String, Object>> json = new ArrayList<>();
        for (GroupIdentity group : groups)
        {
            Map<String, Object> groupJson = new HashMap<>();
            groupJson.put("groupId", group.getId());
            groupJson.put("groupDirectory", group.getDirectoryId());
            json.add(groupJson);
        }
        return json;
    }

    /**
     * Gets the root of contents
     * @param create <code>true</code> to create automatically the root when missing.
     * @return the root of workflows
     * @throws UnknownAmetysObjectException If root node does not exist
     */
    protected ModifiableTraversableAmetysObject _getWorkflowsRootNode(boolean create)
    {
        ModifiableTraversableAmetysObject pluginsNode = _resolver.resolveByPath("/ametys:plugins/");
        
        boolean needSave = false;
        if (!pluginsNode.hasChild(BPM_ROOT_NODE))
        {
            if (create)
            {
                pluginsNode.createChild(BPM_ROOT_NODE, "ametys:unstructured");
                needSave = true;
            }
            else
            {
                throw new UnknownAmetysObjectException("Node '/ametys:plugins/" + BPM_ROOT_NODE + "' is missing");
            }
        }
        
        ModifiableTraversableAmetysObject bpmNode = pluginsNode.getChild(BPM_ROOT_NODE);
        if (!bpmNode.hasChild(BPMWORKFLOW_ROOT_NODE))
        {
            if (create)
            {
                bpmNode.createChild(BPMWORKFLOW_ROOT_NODE, "ametys:unstructured");
                needSave = true;
            }
            else
            {
                throw new UnknownAmetysObjectException("Node '/ametys:plugins/" + BPM_ROOT_NODE + "/" + BPMWORKFLOW_ROOT_NODE + "' is missing");
            }
        }
        
        if (needSave)
        {
            pluginsNode.saveChanges();
        }
        
        return bpmNode.getChild(BPMWORKFLOW_ROOT_NODE);
    }

    /**
     * Gets the root of processes of a workflow
     * @param workflow The workflow
     * @param create <code>true</code> to create automatically the root when missing.
     * @return the root of processes
     * @throws UnknownAmetysObjectException If root node does not exist
     */
    protected ModifiableTraversableAmetysObject _getProcessesRootNode(JCRWorkflow workflow, boolean create)
    {
        boolean needSave = false;
        if (!workflow.hasChild(BPMPROCESSES_ROOT_NODE))
        {
            if (create)
            {
                workflow.createChild(BPMPROCESSES_ROOT_NODE, "ametys:unstructured");
                needSave = true;
            }
            else
            {
                throw new UnknownAmetysObjectException("Node '" + BPMPROCESSES_ROOT_NODE + "' is missing for workflow '" + workflow.getId() + "'");
            }
        }
        
        if (needSave)
        {
            workflow.saveChanges();
        }
        
        return workflow.getChild(BPMPROCESSES_ROOT_NODE);
    }
    

    /**
     * Get the list of variables and their properties for a workflow definition
     * @param workflowDefId The workflow definition id
     * @return The list of variables properties, mapped by variable id
     */
    protected Map<String, Object> _getWorkflowDefinitionData(String workflowDefId)
    {
        if (_workflowDefinitionsCache.containsKey(workflowDefId))
        {
            return _workflowDefinitionsCache.get(workflowDefId);
        }
        
        Map<String, Object> workflowDefinitionData = new HashMap<>();
        
        Map<String, Map<String, Object>> variables = new HashMap<>();
        Workflow externalWorkflow = _workflowProvider.getExternalWorkflow(JdbcWorkflowStore.ROLE);
        if (!ArrayUtils.contains(externalWorkflow.getWorkflowNames(), workflowDefId))
        {
            return null;
        }
        WorkflowDescriptor workflowDescriptor = externalWorkflow.getWorkflowDescriptor(workflowDefId);
        if (workflowDescriptor == null)
        {
            return null;
        }
        
        String workflowXml = workflowDescriptor.asXML();
        
        try (InputStream is = new ByteArrayInputStream(workflowXml.getBytes()))
        {
            Configuration workflowConfiguration = new DefaultConfigurationBuilder().build(is);

            Configuration[] registers = workflowConfiguration.getChild("registers", true).getChildren("register");
            if (registers.length > 0)
            {
                variables.putAll(_getWorkflowDefinitionRegisters(registers));
            }
        }
        catch (ConfigurationException | IOException | SAXException e)
        {
            getLogger().warn("Unable to retrieve the workflow definition xml file for '" + workflowDefId + "'", e);
            return null;
        }
        
        workflowDefinitionData.put("variables", variables);
        _workflowDefinitionsCache.put(workflowDefId, workflowDefinitionData);
        return workflowDefinitionData;
    }

    private Map< ? extends String, ? extends Map<String, Object>> _getWorkflowDefinitionRegisters(Configuration[] registers) throws ConfigurationException
    {
        Map<String, Map<String, Object>> variables = new HashMap<>();
        
        for (Configuration register : registers)
        {
            String variableName = null;
            if ("avalon".equals(register.getAttribute("type", null)))
            {
                Map<String, Object> variableValues = new HashMap<>();
                boolean matchRole = false;
                for (Configuration arg : register.getChildren("arg"))
                {
                    String argName = arg.getAttribute("name", null);
                    String argValue = arg.getValue();
                    if (argName != null)
                    {
                        if ("role".equals(argName))
                        {
                            matchRole = RegisterVariable.class.getName().equals(argValue);
                        }
                        else if ("variableId".equals(argName))
                        {
                            variableName = argValue;
                        }
                        else
                        {
                            if ("label".equals(argName) || "description".equals(argName))
                            {
                                variableValues.put(argName, new I18nizableText(null, argValue));
                            }
                            else
                            {
                                variableValues.put(argName, argValue);
                            }
                        }
                    }
                }
                
                if (matchRole && StringUtils.isNotEmpty(variableName))
                {
                    variables.put(variableName, variableValues);
                }
            }
        }
        
        return variables;
    }
    
    private Map<String, Object> _processToJson(JCRWorkflowProcess process)
    {
        Map<String, Object> jsonData = new HashMap<>();
        
        jsonData.put("id", process.getId());
        jsonData.put("title", process.getTitle());
        jsonData.put("creationDate", ParameterHelper.valueToString(process.getCreationDate()));
        jsonData.put("description", process.getDescription());
        jsonData.put("creator", _userHelper.user2json(process.getCreator(), true));
        
        List<Map<String, String>> attachmentsList = new ArrayList<>();
        
        ResourceCollection rootAttachments = process.getRootAttachments(false);
        if (rootAttachments != null)
        {
            AmetysObjectIterable<ModifiableResource> attachments = rootAttachments.getChildren();
            JCRWorkflow workflow = _resolver.resolveById(process.getWorkflow());
            
            String attachmentPathPrefix = workflow.getName() + "/" + process.getName() + "/_attachments/";
            
            for (ModifiableResource attachment : attachments)
            {
                Map<String, String> attachmentData = new HashMap<>();
                
                String name = attachment.getName();
                attachmentData.put("name", name);
                attachmentData.put("path", attachmentPathPrefix + name);
                
                attachmentsList.add(attachmentData);
            }
        }
        
        jsonData.put("attachments", attachmentsList);

        AmetysObjectWorkflow aoWorkflow = _workflowProvider.getAmetysObjectWorkflow(process, true);
        try
        {
            String workflowName = aoWorkflow.getWorkflowName(process.getWorkflowId());
            if (workflowName != null)
            {
                WorkflowDescriptor workflowDescriptor = aoWorkflow.getWorkflowDescriptor(workflowName);
                StepDescriptor step = workflowDescriptor.getStep((int) process.getCurrentStepId());
                jsonData.put("currentStep", _i18nUtils.translate(new I18nizableText(null, step.getName())));
            }
        }
        catch (AmetysRepositoryException e)
        {
            // no workflow node for process
        }
        
        return jsonData;
    }


}