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

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

import org.apache.avalon.framework.component.Component;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.solr.client.solrj.SolrServerException;

import org.ametys.cms.ObservationConstants;
import org.ametys.cms.clientsideelement.content.SmartContentClientSideElementHelper;
import org.ametys.cms.content.external.ExternalizableMetadataHelper;
import org.ametys.cms.content.indexing.solr.SolrIndexer;
import org.ametys.cms.repository.Content;
import org.ametys.cms.repository.WorkflowAwareContent;
import org.ametys.cms.workflow.ContentWorkflowHelper;
import org.ametys.core.observation.Event;
import org.ametys.core.observation.ObservationManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.ModifiableAmetysObject;
import org.ametys.plugins.repository.RemovableAmetysObject;
import org.ametys.plugins.repository.lock.LockableAmetysObject;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.runtime.plugin.component.AbstractLogEnabled;

import com.opensymphony.workflow.WorkflowException;

/**
 * Delete orgunit component
 */
public class DeleteOrgUnitComponent extends AbstractLogEnabled implements Component, Serviceable
{
    /** The avalon role. */
    public static final String ROLE = DeleteOrgUnitComponent.class.getName();
   
    private static final int _REMOVE_REFERENCE_DEFAULT_ACTION_ID = 22;
    
    /** The organisation chart page handler */
    protected OrganisationChartPageHandler _oCPageHandler;
    
    /** The Content workflow helper */
    protected ContentWorkflowHelper _contentWorkflowHelper;
    
    /** The Solr indexer. */
    protected SolrIndexer _solrIndexer;
    
    /** The Ametys object resolver */
    protected AmetysObjectResolver _resolver;
    
    /** The observation manager */
    protected ObservationManager _observationManager;
    
    /** The current user provider */
    protected CurrentUserProvider _currentUserProvider;
    
    /** Helper for smart content client elements */
    protected SmartContentClientSideElementHelper _smartHelper;
    
    @Override
    public void service(ServiceManager smanager) throws ServiceException
    {
        _oCPageHandler = (OrganisationChartPageHandler) smanager.lookup(OrganisationChartPageHandler.ROLE);
        _contentWorkflowHelper = (ContentWorkflowHelper) smanager.lookup(ContentWorkflowHelper.ROLE);
        _solrIndexer = (SolrIndexer) smanager.lookup(SolrIndexer.ROLE);
        _resolver = (AmetysObjectResolver) smanager.lookup(AmetysObjectResolver.ROLE);
        _observationManager = (ObservationManager) smanager.lookup(ObservationManager.ROLE);
        _currentUserProvider = (CurrentUserProvider) smanager.lookup(CurrentUserProvider.ROLE);
        _smartHelper = (SmartContentClientSideElementHelper) smanager.lookup(SmartContentClientSideElementHelper.ROLE);
    }
    
    /**
     * Delete orgUnits contents
     * @param contentsId The ids of contents to delete
     * @param parameters the additional parameters
     * @param rights the map of rights id with its prefix
     * @return the deleted and undeleted contents
     */
    public Map<String, Object> deleteContents(List<String> contentsId, Map<String, Object> parameters, Map<String, String> rights)
    {
        Map<String, Object> results = new HashMap<>();
        
        List<String> alreadyDeletedContentIds = new ArrayList<>();
        for (String contentId : contentsId)
        {
            if (!alreadyDeletedContentIds.contains(contentId))
            {
                Content content = _resolver.resolveById(contentId);
                
                Map<String, Object> result = new HashMap<>();
                result.put("deleted-contents", new ArrayList<String>());
                result.put("undeleted-contents", new ArrayList<Content>());
                result.put("referenced-contents", new ArrayList<Content>());
                result.put("unauthorized-contents", new ArrayList<Content>());
                result.put("locked-contents", new ArrayList<Content>());
                result.put("initial-content", content.getId());
                results.put(contentId, result);
                
                boolean referenced = _oCPageHandler.isReferencedOrgUnit(content);
                if (referenced || !checkBeforeDeletion(content, result, rights))
                {
                    if (referenced)
                    {
                        // Indicate that the content is referenced.
                        @SuppressWarnings("unchecked")
                        List<Content> referencedContents = (List<Content>) result.get("referenced-contents");
                        referencedContents.add(content);
                    }
                    result.put("check-before-deletion-failed", true);
                }
                else
                {
                    // Process deletion
                    deleteContent(content, result, parameters, rights);

                    @SuppressWarnings("unchecked")
                    List<String> deletedContents = (List<String>) result.get("deleted-contents");
                    if (deletedContents != null)
                    {
                        alreadyDeletedContentIds.addAll(deletedContents);
                        
                    }
                }
            }
            else
            {
                getLogger().info("Content with id '{}' has been already deleted during its parent deletion", contentId);
            }
        }

        return results;
    }

    /**
     * Delete one content
     * @param content the content to delete
     * @param results the results map
     * @param rights the map of rights id with its prefix
     * @param parameters the additional parameters
     */
    protected void deleteContent(Content content, Map<String, Object> results, Map<String, Object> parameters, Map<String, String> rights)
    {
        // 1 - First delete relation to parent
        Content parentOrgUnit = _oCPageHandler.getParentContent(content);
        boolean success = true;
        if (parentOrgUnit != null)
        {
            success = _removeRelation((WorkflowAwareContent) parentOrgUnit, content, OrganisationChartPageHandler.METADATA_CHILD_ORGUNIT, _REMOVE_REFERENCE_DEFAULT_ACTION_ID, results);
        }
        
        // 2 - If succeed, process to deletion
        if (success)
        {
            deleteOrgUnit(content, results, rights);
        }
        else
        {
            @SuppressWarnings("unchecked")
            List<Content> undeletedContents = (List<Content>) results.get("undeleted-contents");
            undeletedContents.add(content);
        }
    }
    
    /**
     * Delete one orgUnit
     * @param orgUnit the orgUnit to delete
     * @param rights the map of rights id with its prefix
     * @param results the results map
     */
    @SuppressWarnings("unchecked")
    protected void deleteOrgUnit(Content orgUnit, Map<String, Object> results, Map<String, String> rights)
    {
        Set<String> toDelete = _getChildrenIdToDelete(orgUnit, results, rights);
        
        List<Content> referencedContents = (List<Content>) results.get("referenced-contents");
        List<Content> lockedContents = (List<Content>) results.get("locked-contents");
        List<Content> unauthorizedContents = (List<Content>) results.get("unauthorized-contents");
        
        if (referencedContents.size() == 0 && lockedContents.size() == 0 && unauthorizedContents.size() == 0)
        {
            _finalizeDeleteContents(toDelete, orgUnit.getParent(), results);
        }
    }
    
    /**
     * Get the id of children to be deleted. 
     * All children shared with other contents which are not part of deletion, will be not deleted.
     * @param orgUnit The orgunit to delete
     * @param results The results
     * @param rights the map of rights id with its prefix
     * @return The id of contents to be deleted
     */
    protected Set<String> _getChildrenIdToDelete (Content orgUnit, Map<String, Object> results, Map<String, String> rights)
    {
        Set<String> toDelete = new HashSet<>();
        
        if (_canDeleteContent(orgUnit, results, rights))
        {
            toDelete.add(orgUnit.getId());
            
            for (Content childOrgUnit : _oCPageHandler.getChildContents(orgUnit))
            {
                if (!_oCPageHandler.isReferencedOrgUnit(orgUnit))
                {
                    toDelete.addAll(_getChildrenIdToDelete(childOrgUnit, results, rights));
                }
                else
                {
                    // The child program item can not be deleted, remove the relation to the parent and stop iteration
                    @SuppressWarnings("unchecked")
                    List<Content> referencedContents = (List<Content>) results.get("referenced-contents");
                    referencedContents.add(childOrgUnit);
                }
            }
        }
        
        return toDelete;
    }

    /**
     * Finalize the deletion of contents. Call observers and remove contents
     * @param contentIdsToDelete the list of content id to delete
     * @param parent the jcr parent for saving changes
     * @param results the results map
     */
    private void _finalizeDeleteContents(Set<String> contentIdsToDelete, ModifiableAmetysObject parent, Map<String, Object> results)
    {
        @SuppressWarnings("unchecked")
        List<Content> unauthorizedContents = (List<Content>) results.get("unauthorized-contents");
        @SuppressWarnings("unchecked")
        List<Content> lockedContents = (List<Content>) results.get("locked-contents");
        
        if (!unauthorizedContents.isEmpty() || !lockedContents.isEmpty())
        {
            //Do Nothing
            return;
        }
        
        try
        {
            _observationManager.addArgumentForEvents(new String[] {ObservationConstants.EVENT_CONTENT_DELETED}, ObservationConstants.ARGS_CONTENT_COMMIT, false);
            
            Map<String, Map<String, Object>> eventParams = new HashMap<>();
            for (String id : contentIdsToDelete)
            {
                Content content = _resolver.resolveById(id);
                Map<String, Object> eventParam = _getEventParametersForDeletion(content);
                eventParams.put(id, eventParam);
                
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETING, _currentUserProvider.getUser(), eventParam));
                
                // Remove the content.
                LockableAmetysObject lockedContent = (LockableAmetysObject) content;
                if (lockedContent.isLocked())
                {
                    lockedContent.unlock();
                }
                
                ((RemovableAmetysObject) content).remove();
            }
            
            
            parent.saveChanges();
            
            for (String id : contentIdsToDelete)
            {
                _observationManager.notify(new Event(ObservationConstants.EVENT_CONTENT_DELETED, _currentUserProvider.getUser(), eventParams.get(id)));
                
                @SuppressWarnings("unchecked")
                List<String> deletedContents = (List<String>) results.get("deleted-contents");
                deletedContents.add(id);
            }
        }
        finally 
        {
            _observationManager.removeArgumentForEvents(new String[] {ObservationConstants.EVENT_CONTENT_DELETED}, ObservationConstants.ARGS_CONTENT_COMMIT);
            _commitAllChanges();
        }
    }
    
    /**
     * Check that deletion can be performed without blocking errors
     * @param content The initial content to delete
     * @param results The results
     * @param rights the map of rights id with its prefix
     * @return true if the deletion can be performed
     */
    protected boolean checkBeforeDeletion(Content content, Map<String, Object> results, Map<String, String> rights)
    {
        // Check right and lock on content it self
        boolean allRight = _canDeleteContent(content, results, rights);
        
        // Check lock on parent contents
        allRight = _checkParentBeforeDeletion(content, results) && allRight;
        
        // Check right and lock on children to be deleted or modified
        allRight = _checkChildrenBeforeDeletion(content, results, rights) && allRight;
        
        return allRight;
    }
    
    /**
     * True if we can delete the content (check if removable, rights and if locked)
     * @param content the content
     * @param results the results map
     * @param rights the map of rights id with its prefix
     * @return true if we can delete the content
     */
    protected boolean _canDeleteContent(Content content, Map<String, Object> results, Map<String, String> rights)
    {
        if (!(content instanceof RemovableAmetysObject))
        {
            throw new IllegalArgumentException("The content [" + content.getId() + "] is not a RemovableAmetysObject, it can't be deleted.");
        }
        
        if (!_hasRight(content, rights))
        {
            // User has no sufficient right
            @SuppressWarnings("unchecked")
            List<Content> norightContents = (List<Content>) results.get("unauthorized-contents");
            norightContents.add(content);
            
            return false;
        }
        else if (_isLocked(content))
        {
            @SuppressWarnings("unchecked")
            List<Content> lockedContents = (List<Content>) results.get("locked-contents");
            lockedContents.add(content);
            
            return false;
        }
        
        return true;
    }
    
    /**
     * True if the parent content is not locked
     * @param content the content
     * @param results the results map
     * @return true if the parent content is not locked
     */
    protected boolean _checkParentBeforeDeletion(Content content,  Map<String, Object> results)
    {
        boolean allRight = true;
        
        // Check if parents are not locked
        Content parentContent = _oCPageHandler.getParentContent(content);
        if (_isLocked(parentContent))
        {
            @SuppressWarnings("unchecked")
            List<Content> lockedContents = (List<Content>) results.get("locked-contents");
            lockedContents.add(parentContent);
            
            allRight = false;
        }
        
        return allRight;
    }
    
    /**
     * Browse children to check if deletion could succeed
     * @param contentToCheck The current content to check
     * @param results The result
     * @param rights the map of rights id with its prefix
     * @return true if the deletion can be processed
     */
    private boolean _checkChildrenBeforeDeletion(Content contentToCheck, Map<String, Object> results, Map<String, String> rights)
    {
        boolean allRight = true;
        
        List<Content> childOrgUnits = _oCPageHandler.getChildContents(contentToCheck);
        for (Content childOrgUnit : childOrgUnits)
        {
            if (!_canDeleteContent(childOrgUnit, results, rights))
            {
                allRight = false;
            }
            else if (_oCPageHandler.isReferencedOrgUnit(childOrgUnit))
            {
                @SuppressWarnings("unchecked")
                List<Content> referencedContents = (List<Content>) results.get("referenced-contents");
                referencedContents.add(childOrgUnit);
                
                allRight = false;
            }
            else
            {
                // Browse children recursively
                allRight = _checkChildrenBeforeDeletion(childOrgUnit, results, rights) && allRight;
            }
        }
        
        return allRight;
    }
    
    /**
     * Remove the relation parent-child relation on content. 
     * @param contentToEdit The content to modified
     * @param refContentToRemove The referenced content to be removed from content
     * @param metadataName The name of metadata holding the child or parent relationship
     * @param actionId The id of workflow action to edit the relation
     * @param results the results map
     * @return boolean true if remove relation successfully
     */
    protected boolean _removeRelation(WorkflowAwareContent contentToEdit, Content refContentToRemove, String metadataName, int actionId, Map<String, Object> results)
    {
        try
        {
            ModifiableCompositeMetadata metadataHolder = contentToEdit.getMetadataHolder();

            String[] values = metadataHolder.getStringArray(metadataName, new String[0]);
            
            if (ArrayUtils.contains(values, refContentToRemove.getId()))
            {
                String[] newValues = ArrayUtils.removeElement(values, refContentToRemove.getId());
                
                List<Content> newContents = Arrays.asList(newValues).stream()
                        .map(id -> (Content) _resolver.resolveById(id))
                        .collect(Collectors.toList());
                
                ExternalizableMetadataHelper.setMetadata(metadataHolder, metadataName, newContents.toArray(new Content[newContents.size()]));
                _applyChanges(contentToEdit, actionId);
            }
            
            return true;
        }
        catch (WorkflowException | AmetysRepositoryException e)
        {
            getLogger().error("Unable to remove relationship to content {} ({}) on content {} ({}) for metadata {}", refContentToRemove.getTitle(), refContentToRemove.getId(), contentToEdit.getTitle(), contentToEdit.getId(), metadataName, e);
            return false;
        }
    }
    
    private void _applyChanges(WorkflowAwareContent content, int actionId) throws WorkflowException
    {
        // 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, _currentUserProvider.getUser(), eventParams));
       
        _contentWorkflowHelper.doAction(content, actionId);
    }
    
    /**
     * Get parameters for content deleted {@link Event}
     * @param content the removed content
     * @return the event's parameters
     */
    protected Map<String, Object> _getEventParametersForDeletion (Content content)
    {
        Map<String, Object> eventParams = new HashMap<>();
        eventParams.put(ObservationConstants.ARGS_CONTENT, content);
        eventParams.put(ObservationConstants.ARGS_CONTENT_NAME, content.getName());
        eventParams.put(ObservationConstants.ARGS_CONTENT_ID, content.getId());
        return eventParams;
    }
    
    /**
     * Commit all changes in solr
     */
    protected void _commitAllChanges()
    {
        // Before trying to commit, be sure all the async observers of the current request are finished
        for (Future future : _observationManager.getFuturesForRequest())
        {
            try
            {
                future.get();
            }
            catch (ExecutionException | InterruptedException e)
            {
                getLogger().info("An exception occured when calling #get() on Future result of an observer." , e);
            }
        }
        
        // Commit all uncommited changes
        try
        {
            _solrIndexer.commit();
            
            if (getLogger().isDebugEnabled())
            {
                getLogger().info("Deleted contents are now committed into Solr.");
            }
        }
        catch (IOException | SolrServerException e)
        {
            getLogger().error("Impossible to commit changes", e);
        }
    }
    
    /**
     * Determines if the content is locked
     * @param content the content
     * @return true if the content is locked
     */
    protected boolean _isLocked(Content content)
    {
        return _smartHelper.isLocked(content);
    }
    
    /**
     * Determines if the user has sufficient right for the given content
     * @param content the content
     * @param rights the map of rights id with its prefix
     * @return true if user has sufficient right
     */
    protected boolean _hasRight(Content content, Map<String, String> rights)
    {
        if (rights.isEmpty())
        {
            return true;
        }
        
        return _smartHelper.hasRight(rights, content);
    }
}