/*
 *  Copyright 2014 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.workflow;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.apache.avalon.framework.component.Component;
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.logger.AbstractLogEnabled;
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.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.user.UserIdentity;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.plugins.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.model.ModelItem;

import com.opensymphony.workflow.InvalidActionException;
import com.opensymphony.workflow.WorkflowException;
 
/**
 * A component to do workflow actions on Content
 */
public class ContentWorkflowHelper extends AbstractLogEnabled implements Serviceable, Contextualizable, Component
{
    /** The component role */
    public static final String ROLE = ContentWorkflowHelper.class.getName();
    
    /** Component to get the current user */
    protected CurrentUserProvider _userProvider;
    
    /** Workflow instance. */
    protected WorkflowProvider _workflowProvider;

    /** The observation manager */
    protected ObservationManager _observationManager;
    
    private Context _context;


    @Override
    public void contextualize(Context context) throws ContextException
    {
        _context = context;
    }
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        _userProvider = (CurrentUserProvider) manager.lookup(CurrentUserProvider.ROLE);
        _workflowProvider = (WorkflowProvider) manager.lookup(WorkflowProvider.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
    }
    
    /**
     * Creates a content using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param contentTitle The new title
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @param languageCode The language code of the new content (such as 'fr', 'en'...)
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, String contentTitle, String[] contentTypes, String[] mixins, String languageCode) throws AmetysRepositoryException, WorkflowException
    {
        return createContent(workflowName, initialActionId, contentName, contentTitle, contentTypes, mixins, languageCode, null, null);
    }
    
    /**
     * Creates a multilingual content with a multilingual title using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param titleVariants The title's variants
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, Map<String, String> titleVariants, String[] contentTypes, String[] mixins) throws AmetysRepositoryException, WorkflowException
    {
        return createContent(workflowName, initialActionId, contentName, titleVariants, contentTypes, mixins, null, null);
    }

    /**
     * Creates a content using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param contentTitle The new title
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @param languageCode The language code of the new content (such as 'fr', 'en'...)
     * @param parentContentId If the new content is a subcontent, the parent content identifier.
     * @param parentContentMetadatapath If the new content is a subcontent, the path of the metadata where the new content will take place in its parent
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content

     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, String contentTitle, String[] contentTypes, String[] mixins, String languageCode, String parentContentId, String parentContentMetadatapath) throws AmetysRepositoryException, WorkflowException
    {
        Map<String, Object> inputs = new HashMap<>();
        return createContent(workflowName, initialActionId, contentName, contentTitle, contentTypes, mixins, languageCode, parentContentId, parentContentMetadatapath, inputs);
    }
    
    /**
     * Creates a multilingual content with a multilingual title using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param titleVariants The title's variants
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @param parentContentId If the new content is a subcontent, the parent content identifier.
     * @param parentContentMetadatapath If the new content is a subcontent, the path of the metadata where the new content will take place in its parent
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, Map<String, String> titleVariants, String[] contentTypes, String[] mixins, String parentContentId, String parentContentMetadatapath) throws AmetysRepositoryException, WorkflowException
    {
        Map<String, Object> inputs = new HashMap<>();
        return createContent(workflowName, initialActionId, contentName, titleVariants, contentTypes, mixins, parentContentId, parentContentMetadatapath, inputs);
    }
    
    /**
     * Creates a content using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param contentTitle The new title
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @param languageCode The language code of the new content (such as 'fr', 'en'...)
     * @param parentContentId If the new content is a subcontent, the parent content identifier.
     * @param parentContentMetadatapath If the new content is a subcontent, the path of the metadata where the new content will take place in its parent
     * @param inputs The parameters to transmit to the workflow functions. Cannot be null. 
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content

     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, String contentTitle, String[] contentTypes, String[] mixins, String languageCode, String parentContentId, String parentContentMetadatapath, Map<String, Object> inputs) throws AmetysRepositoryException, WorkflowException 
    {
        _getCommonInputsForCreation(inputs, contentName, contentTypes, mixins, parentContentId, parentContentMetadatapath);
        inputs.put(CreateContentFunction.CONTENT_TITLE_KEY, contentTitle);
        inputs.put(CreateContentFunction.CONTENT_LANGUAGE_KEY, languageCode);
        
        return _doInitialize(workflowName, contentName, initialActionId, inputs);
    }
    
    /**
     * Creates a multilingual content with a multilingual title using the workflow (with the CreateContentFunction).
     * @param workflowName The name of the workflow to create
     * @param initialActionId The workflow action id that creates content
     * @param contentName The new name
     * @param titleVariants The title's variants
     * @param contentTypes The new content types. Cannot be null. Cannot be empty.
     * @param mixins The new mixins. Can be null. Can be empty.
     * @return The workflow result map. See the create content function used to get the new content. Can be under the key CreateContentFunction.CONTENT_KEY, and the id under the key "contentId"
     * @param parentContentId If the new content is a subcontent, the parent content identifier.
     * @param parentContentMetadatapath If the new content is a subcontent, the path of the metadata where the new content will take place in its parent
     * @param inputs The parameters to transmit to the workflow functions. Cannot be null. 
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> createContent(String workflowName, int initialActionId, String contentName, Map<String, String> titleVariants, String[] contentTypes, String[] mixins, String parentContentId, String parentContentMetadatapath, Map<String, Object> inputs) throws AmetysRepositoryException, WorkflowException
    {
        _getCommonInputsForCreation(inputs, contentName, contentTypes, mixins, parentContentId, parentContentMetadatapath);
        inputs.put(CreateContentFunction.CONTENT_TITLE_VARIANTS_KEY, titleVariants);
        
        return _doInitialize(workflowName, contentName, initialActionId, inputs);
    }
    
    @SuppressWarnings("unchecked")
    private Map<String, Object> _doInitialize(String workflowName, String contentName, int initialActionId, Map<String, Object> inputs) throws WorkflowException
    {
        try
        {
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow();
            workflow.initialize(workflowName, initialActionId, inputs);
            
            return (Map<String, Object>) inputs.get(AbstractWorkflowComponent.RESULT_MAP_KEY);
        }
        catch (WorkflowException e)
        {
            getLogger().error("An error occured while creating workflow '" + workflowName + "' with action '" + initialActionId + "' to creates content '" + contentName + "'", e);
            throw e;
        }
    }
    
    private void _getCommonInputsForCreation(Map<String, Object> inputs, String contentName, String[] contentTypes, String[] mixins, String parentContentId, String parentContentMetadatapath)
    {
        inputs.put(CreateContentFunction.CONTENT_NAME_KEY, contentName);
        inputs.put(CreateContentFunction.CONTENT_TYPES_KEY, contentTypes);
        inputs.put(CreateContentFunction.CONTENT_MIXINS_KEY, mixins);
        inputs.put(CreateContentFunction.PARENT_CONTENT_ID_KEY, parentContentId);
        inputs.put(CreateContentFunction.PARENT_CONTENT_METADATA_PATH_KEY, parentContentMetadatapath);
        
        Map<String, Object> results = new HashMap<>();
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, results);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
    }
    
    /**
     * Determines if the workflow action is available
     * @param content the content to consider.
     * @param actionId the workflow action id to check
     * @return <code>true</code> if the wortkflow action is available
     */
    public boolean isAvailableAction(WorkflowAwareContent content, int actionId)
    {
        int[] actionIds = getAvailableActions(content);
        return ArrayUtils.contains(actionIds, actionId);
    }
    
    /**
     * Get the available workflow actions for the content
     * @param content The content to consider. Cannot be null.
     * @return The array of actions ids that are available now
     */
    public int[] getAvailableActions(WorkflowAwareContent content)
    {
        Map<String, Object> inputs = new HashMap<>();
        return getAvailableActions(content, inputs);
    }
    
    /**
     * Get the available workflow actions for the content
     * @param content The content to consider. Cannot be null.
     * @param inputs The parameters to transmit to the workflow functions. Cannot be null. 
     * @return The array of actions ids that are available now
     */
    public int[] getAvailableActions(WorkflowAwareContent content, Map<String, Object> inputs)
    {
        AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(content);
        long wId = content.getWorkflowId();
        
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String> ());
        
        return workflow.getAvailableActions(wId, inputs);
    }
    
    /**
     * Do a workflow action on a content.
     * @param content The content to act on. Cannot be null.
     * @param actionId The id of the workflow action to do
     * @return The results of the functions
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> doAction(WorkflowAwareContent content, int actionId) throws AmetysRepositoryException, WorkflowException
    {
        Map<String, Object> inputs = new HashMap<>();
        return doAction(content, actionId, inputs);
    }
    
    /**
     * Do a workflow action on a content.
     * @param content The content to act on. Cannot be null.
     * @param actionId The id of the workflow action to do
     * @param inputs The parameters to transmit to the workflow functions. Cannot be null. The special key AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY will be filled with the parent context if null (this means that if your are in a request dispatched, you will automatically get the js parameters).
     * @return The results of the functions
     * @throws WorkflowException If an error occurred while doing the action on the workflow
     * @throws AmetysRepositoryException If cannot get the workflow identifier of the content
     */
    public Map<String, Object> doAction(WorkflowAwareContent content, int actionId, Map<String, Object> inputs) throws AmetysRepositoryException, WorkflowException
    {
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("User " + _getUser() + " try to perform action " + actionId + " on content " + content.getId());
        }

        Map<String, Object> results = new HashMap<>();
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, results);
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<String>());
        
        if (inputs.get(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY) == null)
        {
            Map objectModel = ContextHelper.getObjectModel(_context);
            @SuppressWarnings("unchecked")
            Map<String, Object> jsParameters = (Map<String, Object>) objectModel.get(ObjectModelHelper.PARENT_CONTEXT);
            inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, jsParameters);
        }

        try
        {
            Request request = ContextHelper.getRequest(_context);
            request.setAttribute(Content.class.getName(), content);
            
            AmetysObjectWorkflow workflow = _workflowProvider.getAmetysObjectWorkflow(content);
            workflow.doAction(content.getWorkflowId(), actionId, inputs);
        }
        catch (InvalidActionException e)
        {
            getLogger().error("An error occured while do workflow action '" + actionId + "' on content '" + content.getId() + "'", e);
            throw e; 
        }
        
        return results;
    }

    private UserIdentity _getUser()
    {
        return _userProvider.getUser();
    }
    
    /**
     * Remove metadata from content and apply changes
     * @param contentToEdit the content to edit
     * @param valuePath the value path of the metadata to remove
     * @param actionId the workflow action id to execute if changes have been made
     * @param comment the comment of the action. Can be null.
     * @return true if changes are made
     * @throws WorkflowException if failed to remove metadata
     */
    public boolean removeMetadata(WorkflowAwareContent contentToEdit, String valuePath, int actionId, String comment) throws WorkflowException
    {
        ModifiableCompositeMetadata metadataHolder = contentToEdit.getMetadataHolder();
        String metadataName = valuePath;
        if (StringUtils.contains(valuePath, ModelItem.ITEM_PATH_SEPARATOR))
        {
            metadataName = StringUtils.substringAfterLast(valuePath, ModelItem.ITEM_PATH_SEPARATOR);
            String compositeValuePath = StringUtils.substringBeforeLast(valuePath, ModelItem.ITEM_PATH_SEPARATOR);
            metadataHolder = _getCompositeFromValuePath(contentToEdit, compositeValuePath);
        }
        
        if (metadataHolder.hasMetadata(metadataName))
        {
            if (!isAvailableAction(contentToEdit, actionId))
            {
                throw new InvalidActionException("Invalid workflow action '" + actionId + "' on content '" + contentToEdit.getId() + "': unable to remove metadata '" + valuePath + "'");
            }
            
            metadataHolder.removeMetadata(metadataName);

            _applyChanges(contentToEdit, actionId, comment);
            return true;
        }

        return false;
    }
    
    /**
     * Remove string value of multiple metadata from content and apply changes
     * @param contentToEdit the content to edit
     * @param valuePath the value path of the metadata
     * @param valueToRemove the value to remove
     * @param actionId the workflow action id to execute if changes have been made
     * @param comment the comment of the action. Can be null.
     * @return true if changes are made
     * @throws WorkflowException if an error occurred
     */
    public boolean removeStringValueFromMultipleMetadata(WorkflowAwareContent contentToEdit, String valuePath, String valueToRemove, int actionId, String comment) throws WorkflowException
    {
        ModifiableCompositeMetadata metadataHolder = contentToEdit.getMetadataHolder();
        String metadataName = valuePath;
        if (StringUtils.contains(valuePath, ModelItem.ITEM_PATH_SEPARATOR))
        {
            metadataName = StringUtils.substringAfterLast(valuePath, ModelItem.ITEM_PATH_SEPARATOR);
            String compositeValuePath = StringUtils.substringBeforeLast(valuePath, ModelItem.ITEM_PATH_SEPARATOR);
            metadataHolder = _getCompositeFromValuePath(contentToEdit, compositeValuePath);
        }
        
        if (!metadataHolder.isMultiple(metadataName))
        {
            throw new IllegalArgumentException("The value path " + valuePath + " is invalid because it's not refered to multiple data.");
        }
        
        String[] values = metadataHolder.getStringArray(metadataName, new String[0]);
        if (ArrayUtils.contains(values, valueToRemove))
        {
            if (!isAvailableAction(contentToEdit, actionId))
            {
                throw new InvalidActionException("Invalid workflow action '" + actionId + "' on content '" + contentToEdit.getId() + "': unable to remove value '" + valueToRemove + "' from '" + valuePath + "'");
            }
            
            String[] newValues = ArrayUtils.removeElement(values, valueToRemove);
            metadataHolder.setMetadata(metadataName, newValues);
            
            _applyChanges(contentToEdit, actionId, comment);
            return true;
        }
        
        return false;
    }
    
    /**
     * Remove repeater entry from content and apply changes
     * @param contentToEdit the content to edit
     * @param entryPath the path of the entry to remove
     * @param actionId the workflow action id to execute if changes have been made
     * @param comment the comment of the action
     * @return true if changes are made
     * @throws WorkflowException if an error occurred
     */
    public boolean removeRepeaterEntry(WorkflowAwareContent contentToEdit, String entryPath, int actionId, String comment) throws WorkflowException
    {
        if (!DataHolderHelper.isRepeaterEntryPath(entryPath))
        {
            throw new IllegalArgumentException("The entry path " + entryPath + " is invalid. It must end by the entry name of the repeater as path[1]");
        }
        
        ModifiableCompositeMetadata metadataHolder = contentToEdit.getMetadataHolder();
        String lastEntryName = entryPath;
        if (StringUtils.contains(entryPath, ModelItem.ITEM_PATH_SEPARATOR))
        {
            lastEntryName = StringUtils.substringAfterLast(entryPath, ModelItem.ITEM_PATH_SEPARATOR);
            String compositeValuePath = StringUtils.substringBeforeLast(entryPath, ModelItem.ITEM_PATH_SEPARATOR);
            metadataHolder = _getCompositeFromValuePath(contentToEdit, compositeValuePath);
        }
        
        Pair<String, Integer> lastEntryNameAndPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(lastEntryName);
        
        if (!isAvailableAction(contentToEdit, actionId))
        {
            throw new InvalidActionException("Invalid workflow action '" + actionId + "' on content '" + contentToEdit.getId() + "'. Unable to remove repeater entry " + entryPath);
        }
        
        _removeEntry(lastEntryNameAndPosition.getValue(), metadataHolder.getCompositeMetadata(lastEntryNameAndPosition.getKey()));

        _applyChanges(contentToEdit, actionId, comment);
        return true;
    }
    
    /**
     * Removes the repeater entry at the given position. The position starts at index 1.
     * The position can be an integer between 1 and the repeater size to remove an entry from the beginning
     * Or the position can an integer between 0 and - the repeater size to remove an entry from the end (0 means at the end, -1 means before the last one and so on)
     * @param position The position of the entry to remove
     * @param repositoryComposite the repository composite of the repeater
     * @throws IllegalArgumentException if the position is not between the negative and positive repeater size
     */
    protected void _removeEntry(int position, ModifiableCompositeMetadata repositoryComposite) //TODO already exist in the new API
    {
        int size = repositoryComposite.getMetadataNames().length;
        if (1 <= position && position <= size)
        {
            // remove the entry
            repositoryComposite.removeMetadata(String.valueOf(position));
        
            // rename all entries after the removed one
            for (int currentEntryPosition = position + 1; currentEntryPosition <= size; currentEntryPosition++)
            {
                ModifiableCompositeMetadata entryRepositoryComposite = repositoryComposite.getCompositeMetadata(String.valueOf(currentEntryPosition));
                entryRepositoryComposite.rename(RepositoryConstants.NAMESPACE_PREFIX + ":" + String.valueOf(currentEntryPosition - 1));
            }
        }
        else if (-size < position && position <= 0)
        {
            // Find the positive equivalent position and call the removeEntry method with this position
            _removeEntry(size + position, repositoryComposite);
        }
        else
        {
            throw new IllegalArgumentException("Illegal entry position: the entry index '" + position + "' is either negative or exceed the size of the repeater [" + size + "]");
        }
    }
    
    /**
     * Get the last composite and the metadata name from a value path.
     * For example, values[1]/value returns the composite of the first data of values repeater and the metadata name value
     * @param contentToEdit the content to edit
     * @param valuePath the value path
     * @return the pair of composite and metadata name
     */
    protected ModifiableCompositeMetadata _getCompositeFromValuePath(WorkflowAwareContent contentToEdit, String valuePath)
    {
        ModifiableCompositeMetadata metadataHolder = contentToEdit.getMetadataHolder();
        String[] pathSegments = valuePath.split(ModelItem.ITEM_PATH_SEPARATOR);
        for (String pathSegment : pathSegments)
        {
            Pair<String, Integer> repeaterNameAndEntryPosition = DataHolderHelper.getRepeaterNameAndEntryPosition(pathSegment);
            if (repeaterNameAndEntryPosition != null)
            {
                String repeaterMetadataName = repeaterNameAndEntryPosition.getKey();
                String repeaterEntryName = String.valueOf(repeaterNameAndEntryPosition.getValue());
                
                metadataHolder = metadataHolder.getCompositeMetadata(repeaterMetadataName).getCompositeMetadata(repeaterEntryName);
            }
            else
            {
                metadataHolder = metadataHolder.getCompositeMetadata(pathSegment);
            }
        }
        
        return metadataHolder;
    }
    
    
    /**
     * Apply changes on content: create a new version and notify listeners.
     * @param content the content to apply changes
     * @param actionId the id of workflow action to execute
     * @param comment the action comment. Can be null.
     * @throws WorkflowException if an error occurred
     */
    protected void _applyChanges(WorkflowAwareContent content, int actionId, String comment) throws WorkflowException
    {
        // Create a new version
        if (content instanceof VersionableAmetysObject)
        {
            content.saveChanges();
            ((VersionableAmetysObject) content).checkpoint();
        }
        
        // Notify listeners
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_MODIFIED, _getUser(), eventParams));
       
        Map<String, Object> input = new HashMap<>();
        if (StringUtils.isNotEmpty(comment))
        {
            input.put("comment", comment);
        }
        
        // Do workflow action
        doAction(content, actionId, input);
    }
}