/*
 *  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.LinkedHashMap;
import java.util.List;
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.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.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.WorkflowAwareContent;
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.workflow.AbstractWorkflowComponent;
import org.ametys.plugins.workflow.AbstractWorkflowComponent.ConditionFailure;
import org.ametys.plugins.workflow.support.WorkflowProvider;
import org.ametys.plugins.workflow.support.WorkflowProvider.AmetysObjectWorkflow;
import org.ametys.runtime.model.View;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

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
    {
        Map<String, Object> inputs = new HashMap<>();
        return createContent(workflowName, initialActionId, contentName, contentTitle, contentTypes, mixins, languageCode, 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"
     * @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
    {
        Map<String, Object> inputs = new HashMap<>();
        return createContent(workflowName, initialActionId, contentName, titleVariants, contentTypes, mixins, 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 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, Map<String, Object> inputs) throws AmetysRepositoryException, WorkflowException 
    {
        _getCommonInputsForCreation(inputs, contentName, contentTypes, mixins);
        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 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, Map<String, Object> inputs) throws AmetysRepositoryException, WorkflowException
    {
        _getCommonInputsForCreation(inputs, contentName, contentTypes, mixins);
        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)
    {
        inputs.put(CreateContentFunction.CONTENT_NAME_KEY, contentName);
        inputs.put(CreateContentFunction.CONTENT_TYPES_KEY, contentTypes);
        inputs.put(CreateContentFunction.CONTENT_MIXINS_KEY, mixins);
        
        Map<String, Object> results = new LinkedHashMap<>();
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, results);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, new ArrayList<>());
    }
    
    /**
     * 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)
    {
        return isAvailableAction(content, actionId, new HashMap<>());
    }
    
    /**
     * Determines if the workflow action is available
     * @param content the content to consider.
     * @param actionId the workflow action id to check
     * @param inputs The parameters to transmit to the workflow functions. Cannot be null. 
     * @return <code>true</code> if the wortkflow action is available
     */
    public boolean isAvailableAction(WorkflowAwareContent content, int actionId, Map<String, Object> inputs)
    {
        int[] actionIds = getAvailableActions(content, inputs);
        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();
        
        List<ConditionFailure> failures = new ArrayList<>();
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, failures);
        
        int[] availableActions = workflow.getAvailableActions(wId, inputs);
        
        if (!failures.isEmpty() && getLogger().isDebugEnabled())
        {
            getLogger().debug("Validation failures obtained while looking for available actions for content '{}'\n{}", content.getId(), String.join("\n", failures.stream().map(ConditionFailure::text).toList()));
        }
        
        return availableActions;
    }
    
    /**
     * 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
    {
        return doAction(content, actionId, inputs, true);
    }
    
    /**
     * 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).
     * @param logError <code>true</code> to log the action error
     * @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, boolean logError) throws AmetysRepositoryException, WorkflowException
    {
        if (getLogger().isInfoEnabled())
        {
            getLogger().info("User " + _getUser() + " try to perform action " + actionId + " on content " + content.getId());
        }

        Map<String, Object> results = new LinkedHashMap<>();
        inputs.put(AbstractWorkflowComponent.RESULT_MAP_KEY, results);
        inputs.put(AbstractContentWorkflowComponent.CONTENT_KEY, content);
        
        List<ConditionFailure> failures = new ArrayList<>();
        inputs.put(AbstractWorkflowComponent.FAIL_CONDITIONS_KEY, failures);
        
        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)
        {
            if (logError)
            {
                String failureString = "";
                if (!failures.isEmpty())
                {
                    failureString = ", due to the following error(s):\n" + String.join("\n", failures.stream().map(ConditionFailure::text).toList());
                }
                
                getLogger().error("Cannot perform workflow action {} on content '{}'{}", actionId, content.getId(), failureString, e);
            }
            throw e; 
        }
        
        return results;
    }
    
    /**
     * Edit a {@link Content} programmatically.
     * @param content the {@link ModifiableContent}.
     * @param values the typed values to set.
     * @param workflowActionId the id of the workflow action
     * @return the workflow results.
     * @throws WorkflowException if an error occurs while processing the workflow action
     */
    public Map<String, Object> editContent(WorkflowAwareContent content, Map<String, Object> values, int workflowActionId) throws WorkflowException
    {
        return editContent(content, values, workflowActionId, null);
    }
    
    /**
     * Edit a {@link Content} programmatically.
     * @param content the {@link ModifiableContent}.
     * @param values the typed values to set.
     * @param workflowActionId the id of the workflow action
     * @param view the view to edit
     * @return the workflow results.
     * @throws WorkflowException if an error occurs while processing the workflow action
     */
    public Map<String, Object> editContent(WorkflowAwareContent content, Map<String, Object> values, int workflowActionId, View view) throws WorkflowException
    {
        Map<String, Object> parameters = new HashMap<>();
        parameters.put(EditContentFunction.VIEW, view);
        parameters.put(EditContentFunction.VALUES_KEY, values);
        parameters.put(EditContentFunction.QUIT, true);

        Map<String, Object> inputs = new HashMap<>();
        inputs.put(AbstractWorkflowComponent.CONTEXT_PARAMETERS_KEY, parameters);
        
        return doAction(content, workflowActionId, inputs);
    }
    
    private UserIdentity _getUser()
    {
        return _userProvider.getUser();
    }
}