/*
 *  Copyright 2011 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.time.ZonedDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.Future;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.collections.ListUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.contenttype.ContentType;
import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.data.type.ModelItemTypeConstants;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableContent;
import org.ametys.cms.repository.ModifiableWorkflowAwareContent;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.user.population.UserPopulationDAO;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.jcr.NameHelper;
import org.ametys.plugins.repository.jcr.NameHelper.NameComputationMode;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.plugins.workflow.EnhancedFunction;
import org.ametys.plugins.workflow.store.AbstractJackrabbitWorkflowStore;
import org.ametys.plugins.workflow.store.AmetysObjectWorkflowStore;
import org.ametys.runtime.i18n.I18nizableText;
import org.ametys.runtime.model.ModelItem;

import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.workflow.WorkflowException;
import com.opensymphony.workflow.spi.WorkflowEntry;
import com.opensymphony.workflow.spi.WorkflowStore;

/**
 * OSWorkflow function for creating a content.
 */
public class CreateContentFunction extends AbstractContentWorkflowComponent implements EnhancedFunction
{
    /** Constant for storing the content name to use into the transient variables map. */
    public static final String CONTENT_NAME_KEY = CreateContentFunction.class.getName() + "$contentName";
    /** Constant for storing the content title to use into the transient variables map. */
    public static final String CONTENT_TITLE_KEY = CreateContentFunction.class.getName() + "$contentTitle";
    /** Constant for storing the content title variants (for multilingual content only) to use into the transient variables map. */
    public static final String CONTENT_TITLE_VARIANTS_KEY = CreateContentFunction.class.getName() + "$contentTitleVariants";
    /** Constant for storing the content types to use into the transient variables map. */
    public static final String CONTENT_TYPES_KEY = CreateContentFunction.class.getName() + "$contentTypes";
    /** Constant for storing the content mixins to use into the transient variables map. */
    public static final String CONTENT_MIXINS_KEY = CreateContentFunction.class.getName() + "$mixins";
    /** Constant for storing the content language to use into the transient variables map. */
    public static final String CONTENT_LANGUAGE_KEY = CreateContentFunction.class.getName() + "$contentLanguage";
    /** Constant for storing the parent content to use into the transient variables map. */
    public static final String PARENT_CONTENT_ID_KEY = CreateContentFunction.class.getName() + "$parentContentId";
    /** Constant for storing the parent content metadata path to use into the transient variables map. */
    public static final String PARENT_CONTENT_METADATA_PATH_KEY = CreateContentFunction.class.getName() + "$parentContentMetadataPath";
    /** Constant for storing the function allowing to get initial values into the transient variables map. */
    public static final String INITIAL_VALUE_SUPPLIER = CreateContentFunction.class.getName() + "$initialValueSupplier";
    /** Constant for storing the parent content id to use into the transient variables map. */
    public static final String PARENT_CONTEXT_VALUE = CreateContentFunction.class.getName() + "$parentContextValue";
   
    /** Ametys object resolver available to subclasses. */
    protected AmetysObjectResolver _resolver;
    /** Observation manager available to subclasses. */
    protected ObservationManager _observationManager;
    /** The content types handler */
    protected ContentTypeExtensionPoint _contentTypeEP;
    /** The content types helper */
    protected ContentTypesHelper _contentTypeHelper;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) manager.lookup(ObservationManager.ROLE);
        _contentTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _contentTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
    }
    
    @Override
    public void execute(Map transientVars, Map args, PropertySet ps) throws WorkflowException
    {
        _logger.info("Performing content creation");
        
        try
        {
            String desiredContentName = _getNonNullVar(transientVars, CONTENT_NAME_KEY, "Missing content name");
            
            String[] contentTypes = Optional.of(CONTENT_TYPES_KEY)
                                            .map(transientVars::get)
                                            .map(ctypes -> (String[]) ctypes)
                                            .orElseThrow(() -> new WorkflowException("Missing contents types"));
            
            String[] mixins = Optional.of(CONTENT_MIXINS_KEY)
                                     .map(transientVars::get)
                                     .map(m -> (String[]) m)
                                     .orElse(new String[0]);
            
            boolean multilingual = _isMultilingual(contentTypes);
            
            String contentTitle = (String) transientVars.get(CONTENT_TITLE_KEY);
            @SuppressWarnings("unchecked")
            Map<String, String> contentTitleVariants = (Map<String, String>) transientVars.get(CONTENT_TITLE_VARIANTS_KEY);
            
            if (contentTitle == null && contentTitleVariants == null)
            {
                throw new WorkflowException("Missing content title");
            }
            
            String contentLanguage = (String) transientVars.get(CONTENT_LANGUAGE_KEY);
            if (contentLanguage == null && !multilingual)
            {
                throw new WorkflowException("Missing content language for a non-multilingual content");
            }
            
            ModifiableTraversableAmetysObject contents = _getContentRoot(transientVars);
            
            ModifiableWorkflowAwareContent content = _createContent(transientVars, args, desiredContentName, contents);
            content.setTypes(contentTypes);
            content.setMixinTypes(mixins);
            
            if (contentTitleVariants != null)
            {
                _setTitle(content, contentTypes, contentTitleVariants, contentLanguage != null ? new Locale(contentLanguage) : null);
            }
            else 
            {
                content.setTitle(contentTitle, contentLanguage != null ? new Locale(contentLanguage) : null);
            }
            
            if (!multilingual)
            {
                content.setLanguage(contentLanguage);
            }
            
            // Set the workflow id
            long workflowId = ((WorkflowEntry) transientVars.get("entry")).getId();
            content.setWorkflowId(workflowId);
            
            _populateContent(transientVars, content);
            
            // FIXME previous statements may have failed.
            contents.saveChanges();
            
            _populateAdditionalData(transientVars, content);
            
            Node node = content.getNode();
            Session session = node.getSession();
            
            _initWorkflow(transientVars, content, session, workflowId);
            
            String parentContentId = (String) transientVars.get(PARENT_CONTENT_ID_KEY);
            String parentContentMetadataPath = (String) transientVars.get(PARENT_CONTENT_METADATA_PATH_KEY);
            if (StringUtils.isNotBlank(parentContentId) && StringUtils.isNotBlank(parentContentMetadataPath))
            {
                node.setProperty("ametys-internal:subContent", true);
            }
            
            session.save();
            
            // Notify observers
            _notifyContentAdded(content, transientVars);
            
            // Content created
            transientVars.put(CONTENT_KEY, content);
            
            getResultsMap(transientVars).put("contentId", content.getId());
            getResultsMap(transientVars).put(CONTENT_KEY, content);
        }
        catch (RepositoryException e)
        {
            throw new WorkflowException("Unable to link the workflow to the content", e);
        }
        catch (AmetysRepositoryException e)
        {
            throw new WorkflowException("Unable to create the content", e);
        }
    }
    
    /**
     * Initialize the workflow of the added content.
     * @param transientVars The workflow vars
     * @param content The added content
     * @param session The session
     * @param workflowId The workflow ID
     * @throws AmetysRepositoryException if a repository error occured
     * @throws WorkflowException if a workflow error occured
     */
    protected void _initWorkflow(Map transientVars, ModifiableWorkflowAwareContent content, Session session, long workflowId) throws AmetysRepositoryException, WorkflowException
    {
        try
        {
            WorkflowStore workflowStore = (WorkflowStore) transientVars.get("store");
            
            if (workflowStore instanceof AmetysObjectWorkflowStore)
            {
                AmetysObjectWorkflowStore ametysObjectWorkflowStore = (AmetysObjectWorkflowStore) workflowStore;
                ametysObjectWorkflowStore.bindAmetysObject(content);
            }
            
            if (workflowStore instanceof AbstractJackrabbitWorkflowStore)
            {
                AbstractJackrabbitWorkflowStore jackrabbitWorkflowStore = (AbstractJackrabbitWorkflowStore) workflowStore;
                Node workflowEntryNode = jackrabbitWorkflowStore.getEntryNode(session, workflowId);
                
                Integer actionId = (Integer) transientVars.get("actionId");
                if (actionId != null)
                {
                    workflowEntryNode.setProperty("ametys-internal:initialActionId", actionId);
                }
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to link the workflow to the content", e);
        }
    }
    
    /**
     * Set the content's title variants
     * @param content The content 
     * @param cTypes The content's content types
     * @param titleVariants The title's variants
     * @param locale The title's locale. Cannot be null if content is a non-multilingual content.
     * @throws AmetysRepositoryException if failed to set title
     */
    protected void _setTitle(ModifiableContent content, String[] cTypes, Map<String, String> titleVariants, Locale locale) throws AmetysRepositoryException
    {
        ModelItem modelItem = content.getDefinition(Content.ATTRIBUTE_TITLE);
        if (ModelItemTypeConstants.MULTILINGUAL_STRING_ELEMENT_TYPE_ID.equals(modelItem.getType().getId()))
        {
            for (Entry<String, String> variant : titleVariants.entrySet())
            {
                content.setTitle(variant.getValue(), new Locale(variant.getKey()));
            }
        }
        else 
        {
            if (locale == null)
            {
                throw new IllegalArgumentException("Cannot set a title from variants with null locale on a non-multilingual content");
            }
            
            if (!titleVariants.containsKey(locale.getLanguage()))
            {
                throw new IllegalArgumentException("Title variants do not contains value for the requested locale " + locale + " for non multilingual content");
            }
            
            content.setTitle(titleVariants.get(locale.getLanguage()));
        }
    }
    
    /**
     * Determines if the content to create is a multilingual content
     * @param contentTypes The content types of content to create
     * @return true if multilingual
     */
    protected boolean _isMultilingual(String[] contentTypes)
    {
        for (String cTypeId : contentTypes)
        {
            ContentType cType = _contentTypeEP.getExtension(cTypeId);
            if (cType == null)
            {
                throw new IllegalArgumentException("The content type '" + cTypeId + "' does not exists");
            }
            if (cType.isMultilingual())
            {
                return true;
            }
        }
        
        return false;
    }

    /**
     * Notify observers that the content has been created
     * @param content The content added
     * @param transientVars The workflow vars
     * @return The {@link Future} objects of the asynchronous observers
     * @throws WorkflowException If an error occurred
     */
    protected List<Future> _notifyContentAdded(Content content, Map transientVars) throws WorkflowException
    {
        return _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_ADDED, getUser(transientVars), _eventParamsForContentAdded(content)));
    }
    
    /**
     * Gets the event parameters sent in method {@link #_notifyContentAdded(Content, Map)}
     * @param content The content added
     * @return the event parameters
     */
    protected Map<String, Object> _eventParamsForContentAdded(Content content)
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        
        return eventParams;
    }

    /**
     * Create the content object.
     * @param transientVars the workflow parameters.
     * @param args The workflow function arguments
     * @param desiredContentName the desired content name.
     * @param contentsNode the content root node in the repository.
     * @return the created Content.
     */
    protected ModifiableWorkflowAwareContent _createContent(Map transientVars, Map args, String desiredContentName, ModifiableTraversableAmetysObject contentsNode)
    {
        String contentName = NameHelper.getUniqueAmetysObjectName(contentsNode, desiredContentName, _getNameComputationMode(transientVars, args), false);
        return contentsNode.createChild(contentName, _getObjectType(transientVars, args));
    }
    
    /**
     * Return the type of the object to be created.
     * Ex: ametys:defaultContent.
     * @param transientVars The workflow vars
     * @param args The workflow function arguments
     * @return The type of the object to be used during content creation.
     */
    protected String _getObjectType(Map transientVars, Map args)
    {
        return RepositoryConstants.NAMESPACE_PREFIX + ":defaultContent";
    }
    
    /**
     * Return the mode to compute the name if not unique.
     * Ex: ametys:defaultContent.
     * @param transientVars The workflow vars
     * @param args The workflow function arguments
     * @return The unique name to be used during content creation.
     */
    protected NameComputationMode _getNameComputationMode(Map transientVars, Map args)
    {
        String computationMode = (String) args.get("nameComputationMode");
        if (StringUtils.isNotBlank(computationMode))
        {
            try
            {
                return NameComputationMode.valueOf(computationMode.toUpperCase());
            }
            catch (IllegalArgumentException e)
            {
                // Ignore
            }
        }
        
        return _getDefaultNameComputationMode();
    }
    
    /**
     * Define the default computation mode
     * @return the default computation mode
     */
    protected NameComputationMode _getDefaultNameComputationMode()
    {
        return NameComputationMode.INCREMENTAL;
    }

    /**
     * Retrieve the content root.
     * @param transientVars the workflow parameters.
     * @return the content root node.
     * @throws WorkflowException if an error occurs
     */
    protected ModifiableTraversableAmetysObject _getContentRoot(Map transientVars) throws WorkflowException
    {
        String parentContentId = (String) transientVars.get(PARENT_CONTENT_ID_KEY);
        String parentContentMetadataPath = (String) transientVars.get(PARENT_CONTENT_METADATA_PATH_KEY);
        
        if (StringUtils.isNotBlank(parentContentId) && StringUtils.isNotBlank(parentContentMetadataPath))
        {
            return _getSubContentRoot(parentContentId, parentContentMetadataPath);
        }
        
        return _resolver.resolveByPath("/" + RepositoryConstants.NAMESPACE_PREFIX + ":contents");
    }
    
    /**
     * Get the content root when creating a sub-content.
     * @param parentContentId the parent content ID.
     * @param parentContentMetadataPath the path of the metadata in which to create the sub-content.
     * @return the content collection metadata.
     * @throws WorkflowException if an error occurs.
     */
    protected ModifiableTraversableAmetysObject _getSubContentRoot(String parentContentId, String parentContentMetadataPath) throws WorkflowException
    {
        Content parentContent = _resolver.resolveById(parentContentId);
        
        if (parentContent instanceof ModifiableContent)
        {
            ModifiableCompositeMetadata meta = ((ModifiableContent) parentContent).getMetadataHolder();
            
            String metaPath = parentContentMetadataPath.replace('/', '.');
            
            String[] metadatas = StringUtils.split(metaPath, '.');
            for (int i = 0; i < metadatas.length - 1; i++)
            {
                meta = meta.getCompositeMetadata(metadatas[i], true);
            }
            
            String metaName = metadatas[metadatas.length - 1];
            
            return meta.getObjectCollection(metaName, true);
        }
        else
        {
            throw new WorkflowException("The content " + parentContentId + " is not modifiable.");
        }
    }
    
    /**
     * Get a workflow parameter, throwing an exception if it is null.
     * @param transientVars the workflow parameters.
     * @param name the variable name.
     * @param exceptionName label of the exception to throw if the variable is null.
     * @return the variable value.
     * @throws WorkflowException If an error occurred
     */
    protected String _getNonNullVar(Map transientVars, String name, String exceptionName) throws WorkflowException
    {
        String value = (String) transientVars.get(name);
        if (value == null)
        {
            throw new WorkflowException(exceptionName);
        }
        return value;
    }
    
    /**
     * Populate the content.
     * @param transientVars the transient variables.
     * @param content the content.
     * @throws WorkflowException if an error occurs.
     */
    protected void _populateContent(Map transientVars, ModifiableContent content) throws WorkflowException
    {
        UserIdentity user = getUser(transientVars);
        if (user == null)
        {
            // FIXME Login can be null when creating the content in the background environment.
            user = getSystemUser();
        }
        
        // Add standard metadata
        content.setCreator(user);
        content.setCreationDate(ZonedDateTime.now());
        content.setLastContributor(user);
        content.setLastModified(ZonedDateTime.now());
    }
    
    /**
     * Get the user to use when the content is created in a background environment.
     * @return The anonymous user
     */
    protected UserIdentity getSystemUser ()
    {
        return UserPopulationDAO.SYSTEM_USER_IDENTITY;
    }
    
    /**
     * Populate the content.
     * @param transientVars the transient variables.
     * @param content the content.
     * @throws WorkflowException if an error occurs.
     */
    protected void _populateAdditionalData(Map transientVars, ModifiableContent content) throws WorkflowException
    {
        // Nothing to do.
    }
    
    @Override
    public List<FunctionArgument> getArguments()
    {
        return ListUtils.EMPTY_LIST;
    }

    @Override
    public I18nizableText getDescription(Map<String, String> args)
    {
        return new I18nizableText("plugin.cms", "PLUGINS_CMS_CREATE_CONTENT_FUNCTION_DESCRIPTION");
    }
}