/*
 *  Copyright 2010 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.cms.workflow;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

import org.ametys.cms.contenttype.ContentTypeExtensionPoint;
import org.ametys.cms.contenttype.ContentTypesHelper;
import org.ametys.cms.contenttype.MetadataDefinition;
import org.ametys.cms.contenttype.MetadataManager;
import org.ametys.cms.contenttype.RepeaterDefinition;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.ModifiableWorkflowAwareContent;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.core.user.UserIdentity;
import org.ametys.core.util.JSONUtils;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.lock.LockHelper;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.metadata.BinaryMetadata;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.plugins.repository.metadata.File;
import org.ametys.plugins.repository.metadata.Folder;
import org.ametys.plugins.repository.metadata.Resource;
import org.ametys.plugins.repository.metadata.RichText;
import org.ametys.plugins.repository.metadata.UnknownMetadataException;
import org.ametys.plugins.repository.version.VersionableAmetysObject;
import org.ametys.runtime.parameter.ParameterHelper;

import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.workflow.WorkflowException;

/**
 * OSWorkflow function to restore an old revision of a content.
 * Builds a Map with the old content's metadata values, and passes it to the
 * {@link EditContentFunction}, which does the real job.
 */
public class RestoreRevisionFunction extends AbstractContentFunction
{
    
    /** The ametys object resolver. */
    protected AmetysObjectResolver _resolver;
    
    /** The content type extension point. */
    protected ContentTypeExtensionPoint _cTypeEP;
    
    /** The content type helper. */
    protected ContentTypesHelper _cTypeHelper;
    
    /** The JSON conversion utilities. */
    protected JSONUtils _jsonUtils;
    
    @Override
    public void service(ServiceManager manager) throws ServiceException
    {
        super.service(manager);
        _resolver = (AmetysObjectResolver) manager.lookup(AmetysObjectResolver.ROLE);
        _cTypeEP = (ContentTypeExtensionPoint) manager.lookup(ContentTypeExtensionPoint.ROLE);
        _cTypeHelper = (ContentTypesHelper) manager.lookup(ContentTypesHelper.ROLE);
        _jsonUtils = (JSONUtils) manager.lookup(JSONUtils.ROLE);
    }
    
    @Override
    public void execute(Map transientVars, Map args, PropertySet ps) throws WorkflowException
    {
        WorkflowAwareContent content = getContent(transientVars);
        UserIdentity user = getUser(transientVars);
        
        if (!(content instanceof ModifiableWorkflowAwareContent))
        {
            throw new IllegalArgumentException("The provided content " + content.getId() + " is not a ModifiableWorkflowAwareContent.");
        }
        
        ModifiableWorkflowAwareContent modifiableContent = (ModifiableWorkflowAwareContent) content;
        
        if (content instanceof LockableAmetysObject)
        {
            LockableAmetysObject lockableContent = (LockableAmetysObject) content;
            if (lockableContent.isLocked() && !LockHelper.isLockOwner(lockableContent, user))
            {
                throw new WorkflowException ("The user '" + user + "' try to restore the content '" + content.getId() + "', but this content is locked by the user '" + user + "'");
            }
            else if (lockableContent.isLocked())
            {
                lockableContent.unlock();
            }
        }
        
        String contentVersion = (String) getContextParameters(transientVars).get("contentVersion");
        
        Content oldContent = _resolver.resolveById(content.getId());
        if (oldContent instanceof VersionableAmetysObject)
        {
            ((VersionableAmetysObject) oldContent).switchToRevision(contentVersion);
        }
        
        Map<String, Object> results = getResultsMap(transientVars);
        Map<String, Object> brokenReferences = new HashMap<>();
        results.put("brokenReferences", brokenReferences);
        
        Map<String, Object> parameters = getContextParameters(transientVars);
        Map<String, Object> newValues = new HashMap<>();
        parameters.put(EditContentFunction.FORM_RAW_VALUES, newValues);
        
        parameters.put(EditContentFunction.QUIT, Boolean.TRUE);
        
        // Recursively get the old content's metadata values, and fill the "new values" map with them.
        // Additionally, detect broken references.
        processMetadatas(content, oldContent, newValues, brokenReferences);
        
        modifiableContent.setLastContributor(user);
        modifiableContent.setLastModified(new Date());
        // Remove the proposal date.
        modifiableContent.setProposalDate(null);
        
        // Commit changes
        modifiableContent.saveChanges();
    }
    
    /**
     * Process the old content metadatas.
     * @param content the current content (the one being modified).
     * @param oldContent the old content.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored).
     * @throws WorkflowException if an error occurs.
     */
    protected void processMetadatas(Content content, Content oldContent, Map<String, Object> newValues, Map<String, Object> brokenReferences) throws WorkflowException
    {
        CompositeMetadata metaHolder = oldContent.getMetadataHolder();
        
        // Browse the current content's model.
        Set<String> metadataNames = _cTypeHelper.getMetadataNames(content);
        for (String metaName : metadataNames)
        {
            MetadataDefinition metaDef = _cTypeHelper.getMetadataDefinition(metaName, content);
            
            processMetadata(metaHolder, metaName, metaDef, metaName, newValues, brokenReferences);
        }
    }
    
    /**
     * Process the old content metadatas.
     * @param metaHolder the source metadata holder.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored).
     * @throws WorkflowException if an error occurs.
     */
    protected void processMetadatas(CompositeMetadata metaHolder, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues, Map<String, Object> brokenReferences) throws WorkflowException
    {
        Set<String> subMetadataNames = metaDef.getMetadataNames();
        for (String subMetaName : subMetadataNames)
        {
            MetadataDefinition subMetaDef = metaDef.getMetadataDefinition(subMetaName);
            String subMetaPath = metaPath + "." + subMetaName;
            
            processMetadata(metaHolder, subMetaName, subMetaDef, subMetaPath, newValues, brokenReferences);
        }
    }
    
    /**
     * Process a metadata from the old content.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored).
     * @throws WorkflowException if an error occurs.
     */
    protected void processMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues, Map<String, Object> brokenReferences) throws WorkflowException
    {
        if (metaDef != null)
        {
            switch (metaDef.getType())
            {
                case STRING:
                case LONG:
                case DOUBLE:
                case BOOLEAN:
                    processStringMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case USER:
                    processUserMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case DATE:
                    processDateMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case DATETIME:
                    processDatetimeMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case GEOCODE:
                    processGeocodeMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case RICH_TEXT:
                    processRichtextMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case BINARY:
                    processBinaryMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case FILE:
                    processFileMetadata(metaHolder, metaName, metaDef, metaPath, newValues);
                    break;
                case REFERENCE:
                    processReferenceMetadata(metaHolder, metaName, metaDef, metaPath, newValues, brokenReferences);
                    break;
                case CONTENT:
                    processContentMetadata(metaHolder, metaName, metaDef, metaPath, newValues, brokenReferences);
                    break;
                case SUB_CONTENT:
                    break;
                case COMPOSITE:
                    processCompositeMetadata(metaHolder, metaName, metaDef, metaPath, newValues, brokenReferences);
                    break;
                default:
                    break;
            }
        }
    }
    
    /**
     * Get the value from a String old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processStringMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        if (metaDef.isMultiple())
        {
            String[] valuesArr = metaHolder.getStringArray(metaName, new String[0]);
            newValues.put(valueKey, Arrays.asList(valuesArr));
        }
        else
        {
            String value = metaHolder.getString(metaName, null);
            newValues.put(valueKey, value);
        }
    }
    
    /**
     * Get the value from a Date old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processDateMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        if (metaDef.isMultiple())
        {
            Date[] valuesArr = metaHolder.getDateArray(metaName, new Date[0]);
            List<String> values = new ArrayList<>();
            for (Date value : valuesArr)
            {
                values.add(ParameterHelper.valueToString(value));
            }
            
            newValues.put(valueKey, values);
        }
        else
        {
            Date value = metaHolder.getDate(metaName, null);
            newValues.put(valueKey, StringUtils.trimToEmpty(ParameterHelper.valueToString(value)));
        }
    }
    
    /**
     * Get the value from a DateTime old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processDatetimeMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        if (metaDef.isMultiple())
        {
            Date[] valuesArr = metaHolder.getDateArray(metaName, new Date[0]);
            List<String> values = new ArrayList<>();
            for (Date value : valuesArr)
            {
                values.add(ParameterHelper.valueToString(value));
            }
            
            newValues.put(valueKey, values);
        }
        else
        {
            Date value = metaHolder.getDate(metaName, null);
            newValues.put(valueKey, StringUtils.trimToEmpty(ParameterHelper.valueToString(value)));
        }
    }
    
    /**
     * Get the value from a geocode old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processGeocodeMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        Map<String, Object> values = new HashMap<>();
        
        try
        {
            CompositeMetadata meta = metaHolder.getCompositeMetadata(metaName);
            
            values.put("longitude", meta.getDouble("longitude"));
            values.put("latitude", meta.getDouble("latitude"));
            
            String jsonValues = _jsonUtils.convertObjectToJson(values);
            
            newValues.put(valueKey, jsonValues);
        }
        catch (UnknownMetadataException e)
        {
            // The composite metadata doesn't exist: store null
            newValues.put(valueKey, null);
        }
    }
    
    /**
     * Get the value from a user old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processUserMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        Map<String, Object> values = new HashMap<>();
        
        try
        {
            CompositeMetadata meta = metaHolder.getCompositeMetadata(metaName);
            
            values.put("login", meta.getString("login"));
            values.put("populationId", meta.getString("populationId"));
            
            String jsonValues = _jsonUtils.convertObjectToJson(values);
            
            newValues.put(valueKey, jsonValues);
        }
        catch (UnknownMetadataException e)
        {
            // The composite metadata doesn't exist: store null
            newValues.put(valueKey, null);
        }
    }
    
    /**
     * Get the value from a RichText old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @throws WorkflowException if an error occurs.
     */
    protected void processRichtextMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues) throws WorkflowException
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        String formatKey = EditContentFunction.INTERNAL_FORM_ELEMENTS_PREFIX + metaPath + ".format";
        String addDataKey = EditContentFunction.INTERNAL_FORM_ELEMENTS_PREFIX + metaPath + ".additionalData";
        
        try
        {
            RichText richText = metaHolder.getRichText(metaName);
            String docbookContent = IOUtils.toString(richText.getInputStream(), "UTF-8");
            
            Folder dataFolder = richText.getAdditionalDataFolder();
            Map<String, Resource> datas = new LinkedHashMap<>();
            for (File file : dataFolder.getFiles())
            {
                datas.put(file.getName(), file.getResource());
            }
            
            newValues.put(valueKey, docbookContent);
            newValues.put(formatKey, "docbook");
            newValues.put(addDataKey, datas);
        }
        catch (UnknownMetadataException e)
        {
            // The rich-text metadata doesn't exist: store null
            newValues.put(valueKey, null);
        }
        catch (IOException e)
        {
            // Error reading the rich-text content.
            throw new WorkflowException("Error reading the rich-text content for metadata " + metaPath, e);
        }
    }
    
    /**
     * Get the value from a binary old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processBinaryMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        String rawValueKey = EditContentFunction.INTERNAL_FORM_ELEMENTS_PREFIX + metaPath + ".rawValue";
        
        if (metaHolder.hasMetadata(metaName))
        {
            BinaryMetadata value = metaHolder.getBinaryMetadata(metaName);
            
            newValues.put(valueKey, EditContentFunction.UNTOUCHED_BINARY);
            newValues.put(rawValueKey, value);
        }
        else
        {
            newValues.put(valueKey, null);
        }
    }
    
    /**
     * Get the value from a File old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     */
    protected void processFileMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        if (metaHolder.hasMetadata(metaName))
        {
            Map<String, Object> values = new HashMap<>();
            
            if (org.ametys.plugins.repository.metadata.CompositeMetadata.MetadataType.BINARY.equals(metaHolder.getType(metaName)))
            {
                BinaryMetadata value = metaHolder.getBinaryMetadata(metaName);
                values.put("type", "metadata");
                values.put("id", "modified");
                
                String rawValueKey = EditContentFunction.INTERNAL_FORM_ELEMENTS_PREFIX + metaPath + ".rawValue";
                newValues.put(rawValueKey, value);
            }
            else
            {
                // If it's not a binary, it's an explorer resource ID: process it as a simple string.
                String value = metaHolder.getString(metaName, null);
                values.put("type", "explorer");
                values.put("id", value);
            }
            
            String jsonValues = _jsonUtils.convertObjectToJson(values);
            newValues.put(valueKey, jsonValues);
        }
        else
        {
            newValues.put(valueKey, null);
        }
    }
    
    /**
     * Get the value from a Reference old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored). 
     */
    protected void processReferenceMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues, Map<String, Object> brokenReferences)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        Map<String, Object> values = new HashMap<>();
        
        try
        {
            CompositeMetadata meta = metaHolder.getCompositeMetadata(metaName);
            
            values.put("value", meta.getString("value"));
            values.put("type", meta.getString("type"));
            
            String jsonValues = _jsonUtils.convertObjectToJson(values);
            
            newValues.put(valueKey, jsonValues);
        }
        catch (UnknownMetadataException e)
        {
            // The composite metadata doesn't exist: store null
            newValues.put(valueKey, null);
        }
    }
    
    /**
     * Get the value from a Content old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored).
     */
    protected void processContentMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues, Map<String, Object> brokenReferences)
    {
        String valueKey = EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath;
        
        if (metaDef.isMultiple())
        {
            String[] contentIds = metaHolder.getStringArray(metaName, new String[0]);
            List<String> validIds = new ArrayList<>(contentIds.length);
            
            for (String value : contentIds)
            {
                if (_resolver.hasAmetysObjectForId(value))
                {
                    validIds.add(value);
                }
                else if (!brokenReferences.containsKey(metaName))
                {
                    brokenReferences.put(metaName, metaDef.getLabel());
                }
            }
            
            // Set the value (even if it's an empty array, to delete potentially existing values).
            newValues.put(valueKey, validIds);
        }
        else
        {
            String value = metaHolder.getString(metaName, null);
            if (value != null)
            {
                if (_resolver.hasAmetysObjectForId(value))
                {
                    newValues.put(valueKey, value);
                }
                else
                {
                    brokenReferences.put(metaName, metaDef.getLabel());
                }
            }
            else
            {
                // Set the value even if it's null, to delete a potentially existing value.
                newValues.put(valueKey, null);
            }
        }
    }
    
    /**
     * Get the value from a Composite old content metadata and put it in the new values map.
     * @param metaHolder the source metadata holder.
     * @param metaName the metadata name.
     * @param metaDef the metadata definition.
     * @param metaPath the metadata path.
     * @param newValues the Map to fill with the old content's values.
     * @param brokenReferences the Map of broken references (which could not be restored).
     * @throws WorkflowException if an error occurs. 
     */
    protected void processCompositeMetadata(CompositeMetadata metaHolder, String metaName, MetadataDefinition metaDef, String metaPath, Map<String, Object> newValues, Map<String, Object> brokenReferences) throws WorkflowException
    {
        if (metaDef instanceof RepeaterDefinition)
        {
            if (metaHolder.hasMetadata(metaName))
            {
                CompositeMetadata repeaterMetaHolder = metaHolder.getCompositeMetadata(metaName);
                
                String[] entryNames = repeaterMetaHolder.getMetadataNames();
                Arrays.sort(entryNames, MetadataManager.REPEATER_ENTRY_COMPARATOR);
                
                newValues.put("_" + EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath + ".size", Integer.toString(entryNames.length));
                
                if (entryNames.length < 1)
                {
                    newValues.put(EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath, null);
                }
                
                for (String entryName : entryNames)
                {
                    CompositeMetadata entryMetaHolder = repeaterMetaHolder.getCompositeMetadata(entryName);
                    String entryPath = metaPath + "." + entryName;
                    
                    processMetadatas(entryMetaHolder, metaDef, entryPath, newValues, brokenReferences);
                }
            }
            else
            {
                newValues.put(EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath, null);
                newValues.put("_" + EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath + ".size", "0");
            }
        }
        else
        {
            if (metaHolder.hasMetadata(metaName))
            {
                CompositeMetadata compositeMetaHolder = metaHolder.getCompositeMetadata(metaName);
                processMetadatas(compositeMetaHolder, metaDef, metaPath, newValues, brokenReferences);
            }
            else
            {
                newValues.put(EditContentFunction.FORM_ELEMENTS_PREFIX + metaPath, null);
            }
        }
    }
    
}